Funktionszuordnungen des SQLite Entity Framework Core-Anbieters
Diese Seite zeigt, welche .NET-Member in welche SQL-Funktionen übersetzt werden, wenn der SQLite-Anbieter verwendet wird.
Aggregatfunktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| group.Average(x => x.Property) | AVG(Property) | |
| group.Average(x => x.DecimalProperty) | ef_avg(DecimalProperty) | EF Core 9.0 |
| group.Count() | COUNT(*) | |
| group.LongCount() | COUNT(*) | |
| group.Max(x => x.Property) | MAX(Property) | |
| group.Min(x => x.Property) | MIN(Property) | |
| group.Sum(x => x.Property) | SUM(Property) | |
| group.Sum(x => x.DecimalProperty) | ef_sum(DecimalProperty) | EF Core 9.0 |
| string.Concat(group.Select(x => x.Property)) | group_concat(Property, '') | EF Core 7.0 |
| string.Join(separator, group.Select(x => x.Property)) | group_concat(Property, @separator) | EF Core 7.0 |
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 Core 8.0 |
| EF.Functions.Unhex(value, ignoreChars) | unhex(@value, @ignoreChars) | EF Core 8.0 |
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) |
| 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) | EF Core 8.0 |
| dateOnly.Month | strftime('%m', @dateOnly) | |
| dateOnly.Year | strftime('%Y', @dateOnly) | |
| 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, 'start of day') | |
| 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')) * 864000000000 | |
| 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) | |
| decimalValue - d | ef_add(@decimalValue, ef_negate(@d)) | |
| decimalValue * d | ef_multiply(@decimalValue, @d) | |
| decimalValue / d | ef_divide(@decimalValue, @d) | |
| decimalValue % d | ef_mod(@decimalValue, @d) | |
| decimalValue + d | ef_add(@decimalValue, @d) | |
| decimalValue < d | ef_compare(@decimalValue, @d)< 0 | |
| decimalValue <= d | ef_compare(@decimalValue, @d)<= 0 | |
| decimalValue > d | ef_compare(@decimalValue, @d)> 0 | |
| decimalValue >= d | ef_compare(@decimalValue, @d)>= 0 | |
| double.DegreesToRadians(degrees) | radians(@degrees) | EF Core 8.0 |
| double.RadiansToDegrees(radians) | degrees(@dradians) | EF Core 8.0 |
| doubleValue % d | mod(@doubleValue, @d) | |
| EF.Functions.Random() | abs(random() / 9223372036854780000.0) | |
| Math.Abs(value) | abs(@value) | |
| Math.Acos(value) | acos(@value) | EF Core 8.0 |
| Math.Acosh(d) | acosh(@d) | EF Core 8.0 |
| Math.Asin(d) | asin(@d) | EF Core 8.0 |
| Math.Asinh(d) | asinh(@d) | EF Core 8.0 |
| Math.Atan(d) | atan(@d) | EF Core 8.0 |
| Math.Atan2(y, x) | atan2(@y, @x) | EF Core 8.0 |
| Math.Atanh(d) | atanh(@d) | EF Core 8.0 |
| Math.Ceiling(d) | ceiling(@d) | EF Core 8.0 |
| Math.Cos(d) | cos(@d) | EF Core 8.0 |
| Math.Cosh(value) | cosh(@value) | EF Core 8.0 |
| Math.Exp(d) | exp(@d) | EF Core 8.0 |
| Math.Floor(d) | floor(@d) | EF Core 8.0 |
| 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, digits) | 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 Entity Framework Core erstellt.
Zeichenfolgenfunktionen
| .NET | SQL |
|---|---|
| char.ToLower(c) | lower(@c) |
| char.ToUpper(c) | upper(@c) |
| EF.Functions.Collate(operand, collation) | @operand COLLATE @collation |
| EF.Functions.Glob(matchExpression, pattern) | @matchExpression GLOB @pattern |
| EF.Functions.Like(matchExpression, pattern) | @matchExpression LIKE @pattern |
| EF.Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression LIKE @pattern ESCAPE @escapeCharacter |
| Regex.IsMatch(input, pattern) | @input REGEXP @pattern |
| string.Compare(strA, strB) | CASE WHEN @strA = @strB THEN 0 ... ENDE |
| string.Concat(str0, str1) | @str0 || @str1 |
| string.IsNullOrEmpty(value) | @value IS NULL OR @value = '' |
| string.IsNullOrWhiteSpace(value) | @value IS NULL OR trim(@value) = '' |
| stringValue.CompareTo(strB) | CASE WHEN @stringValue = @strB THEN 0 ... ENDE |
| stringValue.Contains(value) | instr(@stringValue, @value)> 0 |
| stringValue.EndsWith(value) | @stringValue LIKE '%' || @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 LIKE @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() | coalesce(@nullable, 0) |
| nullable.GetValueOrDefault(defaultValue) | coalesce(@nullable, @defaultValue) |
Siehe auch
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.
