Hinweis
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, sich anzumelden oder das Verzeichnis zu wechseln.
Für den Zugriff auf diese Seite ist eine Autorisierung erforderlich. Sie können versuchen, das Verzeichnis zu wechseln.
Diese Seite zeigt, welche .NET-Member in welche SQL-Funktionen übersetzt werden, wenn der SQLite-Anbieter verwendet wird.
Aggregatfunktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| Gruppe.Durchschnitt(x => x.Eigenschaft) | AVG(Property) | |
| Gruppe.Durchschnitt(x => x.DecimalProperty) | ef_avg(DecimalProperty) | EF Core 9.0 |
| group.Count() | COUNT(*) | |
| group.LongCount() | COUNT(*) | |
| Gruppe. Max(x => x.Property) | MAX(Property) | |
| Gruppe. Min(x => x.Property) | MIN(Property) | |
| Gruppe. Sum(x => x.Property) | SUM(Property) | |
| gruppe.Sum(x => x.DecimalProperty) | ef_sum(DecimalProperty) | EF Core 9.0 |
| Schnur. Verkettung(Gruppe). Select(x => x.Property)) | group_concat(Eigenschaft; '') | |
| Schnur. Join(Trennzeichen, Gruppe). Select(x => x.Property)) | group_concat(Eigenschaft, @separator) |
Binäre Funktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| bytes.Contains(value) | instr(@bytes, char(@value)) > 0 | |
| bytes.Length | length(@bytes) | |
| bytes.SequenceEqual(second) | @bytes = @second | |
| EF.Functions.Hex(bytes) | hex(@bytes) | |
| EF. Functions.Substr(bytes, startIndex) | substr(@bytes, @startIndex) | |
| EF. Functions.Substr(Bytes, startIndex, length) | substr(@bytes, @startIndex, @length) | |
| EF.Functions.Unhex(value) | unhex(@value) | |
| EF. Functions.Unhex(value, ignoreChars) | unhex(@value, @ignoreChars) |
Konvertierungsfunktionen
| .NET | SQL |
|---|---|
| boolValue.ToString() | CAST(@boolValue AS TEXT) |
| byteValue.ToString() | CAST(@byteValue AS TEXT) |
| bytes.ToString() | CAST(@bytes AS TEXT) |
| charValue.ToString() | CAST(@charValue AS TEXT) |
| dateTime.ToString() | CAST(@dateTime AS TEXT) |
| dateTimeOffset.ToString() | CAST(@dateTimeOffset AS TEXT) |
| decimalValue.ToString() | CAST(@decimalValue AS TEXT) |
| doubleValue.ToString() | CAST(@doubleValue AS TEXT) |
| floatValue.ToString() | CAST(@floatValue AS TEXT) |
| guid.ToString() | CAST(@guid AS TEXT) |
| intValue.ToString() | CAST(@intValue AS TEXT) |
| longValue.ToString() | CAST(@longValue AS TEXT) // Konvertiert @longValue als Text |
| sbyteValue.ToString() | CAST(@sbyteValue AS TEXT) |
| shortValue.ToString() | CAST(@shortValue AS TEXT) |
| timeSpan.ToString() | CAST(@timeSpan AS TEXT) |
| uintValue.ToString() | CAST(@uintValue AS TEXT) |
| ushortValue.ToString() | CAST(@ushortValue AS TEXT) |
Datums- und Uhrzeitfunktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| dateOnly.AddDays(value) | date(@dateOnly, @value || ' Tage') | |
| dateOnly.AddMonths(months) | date(@dateOnly, @months || ' Monate') | |
| dateOnly.AddYears(value) | date(@dateOnly, @value || ' Jahre') | |
| dateOnly.Day | strftime('%d', @dateOnly) | |
| dateOnly.DayOfWeek | strftime('%w', @dateOnly) | |
| dateOnly.DayOfYear | strftime('%j', @dateOnly) | |
| DateOnly.FromDateTime(dateTime) | date(@dateTime) | |
| dateOnly.Month | strftime('%m', @dateOnly) | |
| dateOnly.Year | strftime('%Y', @dateOnly) | |
| dateOnly.DayNumber | CAST(julianday(@dateOnly) - julianday('0001-01-01') AS INTEGER) | EF Core 10.0 |
| DateTime.Now | datetime('now', 'localtime') | |
| DateTime.Today | datetime('now', 'localtime', 'start of day') | |
| DateTime.UtcNow | datetime('now') | |
| dateTime.AddDays(value) | datetime(@dateTime, @value || ' Tage') | |
| dateTime.AddHours(value) | datetime(@dateTime, @d || ' Stunden') | |
| dateTime.AddMilliseconds(value) | datetime(@dateTime, (@value / 1000.0) || ' Sekunden') | |
| dateTime.AddMinutes(value) | datetime(@dateTime, @value || ' Minuten') | |
| dateTime.AddMonths(months) | datetime(@dateTime, @months || ' Monate') | |
| dateTime.AddSeconds(value) | datetime(@dateTime, @value || ' Sekunden') | |
| dateTime.AddTicks(value) | datetime(@dateTime, (@value / 10000000.0) || ' Sekunden') | |
| dateTime.AddYears(value) | datetime(@dateTime, @value || ' Jahre') | |
| dateTime.Date | datetime(@dateTime, 'Tagesbeginn') | |
| dateTime.Day | strftime('%d', @dateTime) | |
| dateTime.DayOfWeek | strftime('%w', @dateTime) | |
| dateTime.DayOfYear | strftime('%j', @dateTime) | |
| dateTime.Hour | strftime('%H', @dateTime) | |
| dateTime.Millisecond | (strftime('%f', @dateTime) * 1000) % 1000 | |
| dateTime.Minute | strftime('%M', @dateTime) | |
| dateTime.Month | strftime('%m', @dateTime) | |
| dateTime.Second | strftime('%S', @dateTime) | |
| dateTime.Ticks | (julianday(@dateTime) - julianday('0001-01-01 00:00:00')) * 86400000000 | |
| dateTime.TimeOfDay | time(@dateTime) | |
| dateTime.Year | strftime('%Y', @dateTime) |
Hinweis
Einige SQL-Anweisungen wurden zu Veranschaulichungszwecken vereinfacht. Der tatsächliche SQL-Code ist komplexer, um einen größeren Wertebereich zu verarbeiten.
Numeric-Funktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| -decimalValue | ef_negate(@decimalValue) | |
| Dezimalwert - d | ef_add(@decimalValue, ef_negate(@d)) | |
| Dezimalwert * d | ef_multiply(@decimalValue; @d) | |
| Dezimalwert /d | ef_divide(@decimalValue; @d) | |
| Dezimalwert % d | ef_mod(@decimalValue; @d) | |
| Dezimalwert + d | ef_add(@decimalValue; @d) | |
| Dezimalwert < d | ef_compare(@decimalValue, @d)< 0 | |
| Dezimalwert <= d | ef_compare(@decimalValue; @d)<= 0 | |
| Dezimalwert > d | ef_compare(@decimalValue, @d)> 0 | |
| Dezimalwert >= d | ef_compare(@decimalValue; @d)>= 0 | |
| double.DegreesToRadians(degrees) | radians(@degrees) | |
| double.RadiansToDegrees(radians) | degrees(@dradians) | |
| doubleValue % d | mod(@doubleValue, @d) | |
| EF.Functions.Random() | abs(random() / 9223372036854780000.0) | |
| Math.Abs(value) | abs(@value) | |
| Math.Acos(value) | acos(@value) | |
| Math.Acosh(d) | acosh(@d) | |
| Math.Asin(d) | asin(@d) | |
| Math.Asinh(d) | asinh(@d) | |
| Math.Atan(d) | atan(@d) | |
| Math.Atan2(y, x) | atan2(@y, @x) | |
| Math.Atanh(d) | atanh(@d) | |
| Math.Ceiling(d) | ceiling(@d) | |
| Math.Cos(d) | cos(@d) | |
| Math.Cosh(value) | cosh(@value) | |
| Math.Exp(d) | exp(@d) | |
| Math.Floor(d) | floor(@d) | |
| Math.Log(d) | ln(@d) | EF Core 8.0 |
| Math.Log(a, newBase) | log(@newBase, @a) | EF Core 8.0 |
| Math.Log2(x) | log2(@x) | EF Core 8.0 |
| Math.Log10(d) | log10(@d) | EF Core 8.0 |
| Math.Max(val1, val2) | max(@val1, @val2) | |
| Math.Min(val1, val2) | min(@val1, @val2) | |
| Math.Pow(x, y) | pow(@x, @y) | EF Core 8.0 |
| Math.Round(d) | round(@d) | |
| Math.Round(d, Ziffern) | round(@d, @digits) | |
| Math.Sign(d) | sign(@d) | EF Core 8.0 |
| Math.Sin(a) | sin(@a) | EF Core 8.0 |
| Math.Sinh(value) | sinh(@value) | EF Core 8.0 |
| Math.Sqrt(d) | sqrt(@d) | EF Core 8.0 |
| Math.Tan(a) | tan(@a) | EF Core 8.0 |
| Math.Tanh(value) | tanh(@value) | EF Core 8.0 |
| Math.Truncate(d) | trunc(@d) | EF Core 8.0 |
Tipp
Zusätzlich zu den hier aufgeführten Methoden werden auch entsprechende generische mathematische Implementierungen und MathF Methoden übersetzt. Beispiel: Math.Sin, MathF.Sin, double.Sin und float.Sin alle Zuordnungen zur sin-Funktion in SQL.
Tipp
SQL-Funktionen mit dem Präfix ef_ werden von EF Core erstellt.
Zeichenfolgenfunktionen
| .NET | SQL |
|---|---|
| char.ToLower(c) | lower(@c) |
| char.ToUpper(c) | upper(@c) |
| EF. Functions.Collate(operand, sortation) | @operand VERGLEICHEN @collation |
| EF. Functions.Glob(matchExpression, Pattern) | @matchExpression GLOB @pattern |
| EF. Functions.Like(matchExpression, Pattern) | @matchExpression WIE @pattern |
| EF. Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression WIE @pattern ESCAPE @escapeCharacter |
| Regex.IsMatch(input, pattern) | @input REGEXP @pattern |
| Zeichenfolge.Compare(strA, strB) | CASE WHEN @strA = @strB THEN 0 ... ENDE |
| Schnur. Concat(str0, str1) | @str0 || @str1 |
| string.IsNullOrEmpty(value) | @value IS NULL oder @value = '' |
| string.IsNullOrWhiteSpace(value) | @value IST NULL ODER trim(@value) = '' |
| stringValue.CompareTo(strB) | CASE WHEN @stringValue = @strB THEN 0 ... ENDE |
| stringValue.Contains(value) | instr(@stringValue, @value)> 0 |
| stringValue.EndsWith(value) | @stringValue WIE '%' || @value |
| stringValue.FirstOrDefault() | substr(@stringValue, 1, 1) |
| stringValue.IndexOf(value) | instr(@stringValue, @value) - 1 |
| stringValue.LastOrDefault() | substr(@stringValue, length(@stringValue), 1) |
| stringValue.Length | length(@stringValue) |
| stringValue.Replace(oldValue, newValue) | replace(@stringValue, @oldValue, @newValue) |
| stringValue.StartsWith(value) | @stringValue WIE @value || '%' |
| stringValue.Substring(startIndex) | substr(@stringValue, @startIndex + 1) |
| stringValue.Substring(startIndex, length) | substr(@stringValue, @startIndex + 1, @length) |
| stringValue.ToLower() | lower(@stringValue) |
| stringValue.ToUpper() | upper(@stringValue) |
| stringValue.Trim() | trim(@stringValue) |
| stringValue.Trim(trimChar) | trim(@stringValue, @trimChar) |
| stringValue.TrimEnd() | rtrim(@stringValue) |
| stringValue.TrimEnd(trimChar) | rtrim(@stringValue, @trimChar) |
| stringValue.TrimStart() | ltrim(@stringValue) |
| stringValue.TrimStart(trimChar) | ltrim(@stringValue, @trimChar) |
Hinweis
Einige SQL-Anweisungen wurden zu Veranschaulichungszwecken vereinfacht. Der tatsächliche SQL-Code ist komplexer, um einen größeren Wertebereich zu verarbeiten.
Sonstige Funktionen
| .NET | SQL |
|---|---|
| collection.Contains(item) | @item IN @collection |
| enumValue.HasFlag(flag) | @enumValue & @flag = @flag |
| nullable.GetValueOrDefault() | koeszenz(@nullable, 0) |
| nullable.GetValueOrDefault(defaultValue) | Klammern(@nullable; @defaultValue) |
Weitere Informationen
Zusammenarbeit auf GitHub
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
