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.
Auf dieser Seite wird gezeigt, welche .NET-Mitglieder in welche SQL-Funktionen übersetzt werden, wenn der SQL Server-Provider verwendet wird.
Aggregatfunktionen
Allgemeine Informationen zur Verwendung von Aggregatfunktionen in Abfragen finden Sie unter "Aggregatfunktionen".
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| EF.Functions.StandardDeviationSample(group.Select(x => x.Property)) | STDEV(Property) | |
| EF.Functions.StandardDeviationPopulation(group.Select(x => x.Property)) | STDEVP(Property) | |
| EF.Functions.VarianceSample(group.Select(x => x.Property)) | VAR(Property) | |
| EF.Functions.VariancePopulation(group.Select(x => x.Property)) | VARP(Property) | |
| Gruppe.Durchschnitt(x => x.Eigenschaft) | AVG(Property) | |
| group.Count() | COUNT(*) | |
| group.LongCount() | COUNT_BIG(*) | |
| Group.Max(x => x.Property) | MAX(Property) | |
| group.Min(x => x.Property) | MIN(Property) | |
| group.Sum(x => x.Property) | SUM(Property) | |
| string.Concat(group.Select(x => x.Property)) | STRING_AGG(Eigenschaft, N'') | |
| string.Concat(group.OrderBy(x => x.Other).Select(x => x.Property)) | STRING_AGG(Eigenschaft, N'') WITHIN GROUP (ORDER BY Other) | EF Core 11.0 |
| string.Join(separator, group.Select(x => x.Property)) | STRING_AGG(Eigenschaft, @separator) | |
| string.Join(separator, group.OrderBy(x => x.Other).Select(x => x.Property)) | STRING_AGG(Property, @separator) WITHIN GROUP (ORDER BY Other) | EF Core 11.0 |
Binäre Funktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| bytes.Contains(value) | CHARINDEX(@value, @bytes)> 0 | |
| bytes.ElementAt(i) | TEILZEICHENFOLGE(@bytes, @i + 1, 1) | |
| bytes.First() | SUBSTRING(@bytes, 1, 1) | |
| bytes.Length | DATALENGTH(@bytes) | |
| bytes.SequenceEqual(second) | @bytes = @second | |
| bytes[i] | TEILZEICHENFOLGE(@bytes, @i + 1, 1) | |
| EF.Functions.DataLength(arg) | DATALENGTH(@arg) |
Konvertierungsfunktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| bytes.ToString() | CONVERT(varchar(100), @bytes) | |
| byteValue.ToString() | CONVERT(varchar(3), @byteValue) | |
| charValue.ToString() | CONVERT(varchar(1), @charValue) | |
| Convert.ToBoolean(value) | CONVERT(bit, @value) | |
| Convert.ToByte(value) | CONVERT(tinyint, @value) | |
| Convert.ToDecimal(value) | CONVERT(dezimal(18, 2), @value) | |
| Convert.ToDouble(value) | CONVERT(float, @value) | |
| Convert.ToInt16(value) | CONVERT(smallint, @value) | |
| Convert.ToInt32(value) | CONVERT(int, @value)) | |
| Convert.ToInt64(value) | CONVERT(bigint, @value) | |
| Convert.ToString(value) | CONVERT(nvarchar(max), @value) | |
| dateOnly.ToString() | CONVERT(varchar(100), @dateOnly) | |
| dateTime.ToString() | CONVERT(varchar(100), @dateTime) | |
| dateTimeOffset.ToString() | CONVERT(varchar(100), @dateTimeOffset) | |
| decimalValue.ToString() | CONVERT(varchar(100), @decimalValue) | |
| doubleValue.ToString() | CONVERT(varchar(100), @doubleValue) | |
| floatValue.ToString() | CONVERT(varchar(100), @floatValue) | |
| guid.ToString() | CONVERT(varchar(36), @guid) | |
| intValue.ToString() | CONVERT(varchar(11), @intValue) | |
| longValue.ToString() | CONVERT(varchar(20), @longValue) | |
| sbyteValue.ToString() | CONVERT(varchar(4), @sbyteValue) | |
| shortValue.ToString() | CONVERT(varchar(6), @shortValue) | |
| timeOnly.ToString() | CONVERT(varchar(100), @timeOnly) | |
| timeSpan.ToString() | CONVERT(varchar(100), @timeSpan) | |
| uintValue.ToString() | CONVERT(varchar(10), @uintValue) | |
| ulongValue.ToString() | CONVERT(varchar(19), @ulongValue) | |
| ushortValue.ToString() | CONVERT(varchar(5), @ushortValue) |
Datums- und Uhrzeitfunktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| DateTime.Now | GETDATE() | |
| DateTime.Today | CONVERT(date, GETDATE()) | |
| DateTime.UtcNow | GETUTCDATE() | |
| dateTime.AddDays(value) | DATEADD(Tag, @value, @dateTime) | |
| dateTime.AddHours(value) | DATEADD(stunde, @value, @dateTime) | |
| dateTime.AddMilliseconds(value) | DATEADD(Millisekunden, @value, @dateTime) | |
| dateTime.AddMinutes(value) | DATEADD(Minute, @value, @dateTime) | |
| dateTime.AddMonths(months) | DATEADD(Monat, @months, @dateTime) | |
| dateTime.AddSeconds(value) | DATEADD(second, @value, @dateTime) | |
| dateTime.AddYears(value) | DATEADD(Jahr, @value, @dateTime) | |
| dateTime.Date | CONVERT(Datum; @dateTime) | |
| dateTime.Day | DATEPART(Tag, @dateTime) | |
| dateTime.DayOfYear | DATEPART(TagDesJahres, @dateTime) | |
| dateTime.Hour | DATEPART(Stunde, @dateTime) | |
| dateTime.Microsecond | DATEPART(Mikrosekunde, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Millisecond | DATEPART(Millisekunden, @dateTime) | |
| dateTime.Minute | DATEPART(minute, @dateTime) | |
| dateTime.Month | DATEPART(Monat, @dateTime) | |
| dateTime.Nanosecond | DATEPART(Nanosekunden, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Second | DATEPART(Sekunde, @dateTime) | |
| dateTime.TimeOfDay | CONVERT(time, @dateTime) | |
| dateTime.Year | DATEPART(Jahr, @dateTime) | |
| DateTimeOffset.Now | SYSDATETIMEOFFSET() | |
| DateTimeOffset.UtcNow | SYSUTCDATETIME() | |
| dateTimeOffset.AddDays(days) | DATEADD(day, @days, @dateTimeOffset) | |
| dateTimeOffset.AddHours(hours) | DATEADD(stunde, @hours, @dateTimeOffset) | |
| dateTimeOffset.AddMilliseconds(milliseconds) | DATEADD(Millisekunden, @milliseconds, @dateTimeOffset) | |
| dateTimeOffset.AddMinutes(minutes) | DATEADD(Minute, @minutes, @dateTimeOffset) | |
| dateTimeOffset.AddMonths(months) | DATEADD(Monat, @months, @dateTimeOffset) | |
| dateTimeOffset.AddSeconds(seconds) | DATEADD(second, @seconds, @dateTimeOffset) | |
| dateTimeOffset.AddYears(years) | DATEADD(Jahr, @years, @dateTimeOffset) | |
| dateTimeOffset.Date | CONVERT(Datum; @dateTimeOffset) | |
| dateTimeOffset.DateTime | CONVERT(datetime2, @dateTimeOffset) | EF Core 11.0 |
| dateTimeOffset.Day | DATEPART(Tag, @dateTimeOffset) | |
| dateTimeOffset.DayOfYear | DATEPART(TagDesJahres, @dateTimeOffset) | |
| dateTimeOffset.Hour | DATEPART(Stunde, @dateTimeOffset) | |
| dateTimeOffset.LocalDateTime | CONVERT(datetime2, @dateTimeOffset AT TIME ZONE CURRENT_TIMEZONE_ID()) | EF Core 11.0 |
| dateTimeOffset.Microsecond | DATEPART(Mikrosekunde, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Millisecond | DATEPART(Millisekunden, @dateTimeOffset) | |
| dateTimeOffset.Minute | DATEPART(minute, @dateTimeOffset) | |
| dateTimeOffset.Month | DATEPART(Monat, @dateTimeOffset) | |
| dateTimeOffset.Nanosecond | DATEPART(Nanosekunden, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Offset.TotalMinutes | CAST(DATEPART(tz, @dateTimeOffset) AS float) | EF Core 11.0 |
| dateTimeOffset.Second | DATEPART(Sekunde, @dateTimeOffset) | |
| dateTimeOffset.TimeOfDay | CONVERT(time, @dateTimeOffset) | |
| dateTimeOffset.ToOffset(offset) | SWITCHOFFSET(@dateTimeOffset, @offset) | EF Core 11.0 |
| dateTimeOffset.ToUnixTimeSeconds() | DATEDIFF_BIG(Sekunde: "1970-01-01T00:00:00.000000+00:00", @dateTimeOffset) | |
| dateTimeOffset.ToUnixTimeMilliseconds() | DATEDIFF_BIG(Millisekunde, '1970-01-01T00:00:00.0000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.UtcDateTime | CONVERT(datetime2, @dateTimeOffset AT TIME ZONE 'UTC') | EF Core 11.0 |
| dateTimeOffset.Year | DATEPART(Jahr, @dateTimeOffset) | |
| new DateTimeOffset(dateTime) | TODATETIMEOFFSET(@dateTime, '+00:00') | EF Core 11.0 |
| new DateTimeOffset(dateTime, offset) | TODATETIMEOFFSET(@dateTime, @offset) | EF Core 11.0 |
| DateOnly.FromDateTime(dateTime) | CONVERT(Datum; @dateTime) | |
| dateOnly.AddDays(value) | DATEADD(day, @value, @dateOnly) | |
| dateOnly.AddMonths(months) | DATEADD(Monat, @months, @dateOnly) | |
| dateOnly.AddYears(value) | DATEADD(Jahr, @value, @dateOnly) | |
| dateOnly.Day | DATEPART(Tag, @dateOnly) | |
| dateOnly.DayOfYear | DATEPART(TagDesJahres, @dateOnly) | |
| dateOnly.Month | DATEPART(Monat, @dateOnly) | |
| dateOnly.Year | DATEPART(Jahr, @dateOnly) | |
| dateOnly.DayNumber | DATEDIFF(Tag, '0001-01-01', @dateOnly) | EF Core 10.0 |
| EF. Functions.AtTimeZone(dateTime, timeZone) | @dateTime AT TIME ZONE @timeZone | |
| EF.Functions.DateDiffDay(start, end) | DATEDIFF(tag, @start, @end)) | |
| EF.Functions.DateDiffHour(start, end) | DATEDIFF(Stunde, @start, @end) | |
| EF.Functions.DateDiffMicrosecond(start, end) | DATEDIFF(mikrosekunden, @start, @end) | |
| EF.Functions.DateDiffMillisecond(start, end) | DATEDIFF(Millisekunden, @start, @end) | |
| EF.Functions.DateDiffMinute(start, end) | DATEDIFF(minute, @start, @d2) | |
| EF.Functions.DateDiffMonth(start, end) | DATEDIFF(Monat, @start, @end) | |
| EF Functions.DateDiffNanosecond(start, end) | DATEDIFF(Nanosekunden, @start, @end) | |
| EF.Functions.DateDiffSecond(start, end) | DATEDIFF(Sekunde, @start, @end)) | |
| EF.Functions.DateDiffWeek(start, end) | DATEDIFF(week, @start, @end) | |
| EF.Functions.DateDiffYear(start, end) | DATEDIFF(year, @start, @end)) | |
| EF.Functions.DateFromParts(Jahr, Monat, Tag) | DATEFROMPARTS(@year, @month, @day) | |
| EF.Functions.DateTime2FromParts(Jahr, Monat, Tag, ...) | DATETIME2FROMPARTS(@year, @month, @day, ...) | |
| EF.Functions.DateTimeFromParts(Jahr, Monat, Tag, ...) | DATETIMEFROMPARTS(@year, @month, @day, ...) | |
| EF. Functions.DateTimeOffsetFromParts(Jahr, Monat, Tag, ...) | DATETIMEOFFSETFROMPARTS(@year, @month, @day, ...) | |
| EF.Functions.DateTrunc(datepart, value) | DATETRUNC(@datepart, @value) | EF Core 11.0 |
| EF.Functions.IsDate(expression) | ISDATE(@expression) | |
| EF.Functions.SmallDateTimeFromParts(year, month, day, ...) | SMALLDATETIMEFROMPARTS(@year, @month, @day, ...) | |
| EF.Functions.TimeFromParts(stunde, minute, sekunde, ...) | TIMEFROMPARTS(@hour, @minute, @second, ...) | |
| timeOnly.AddHours(value) | DATEADD(stunde, @value, @timeOnly) | |
| timeOnly.AddMinutes(value) | DATEADD(Minute, @value, @timeOnly) | |
| timeOnly.Hour | DATEPART(Stunde, @timeOnly) | |
| timeOnly.IsBetween(start, end) | @timeOnly >= @start UND @timeOnly<@end | |
| timeOnly.Microsecond | DATEPART(Mikrosekunde, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Millisecond | DATEPART(Millisekunden, @timeOnly) | |
| timeOnly.Minute | DATEPART(minute, @timeOnly) | |
| timeOnly.Nanosecond | DATEPART(Nanosekunden, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Second | DATEPART(Sekunde, @timeOnly) | |
| timeSpan.Hours | DATEPART(Stunde, @timeSpan) | |
| timeSpan.Microsecond | DATEPART(Mikrosekunde, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Milliseconds | DATEPART(Millisekunden, @timeSpan) | |
| timeSpan.Minutes | DATEPART(minute, @timeSpan) | |
| timeSpan.Nanosecond | DATEPART(Nanosekunden, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Seconds | DATEPART(Sekunde, @timeSpan) |
Numeric-Funktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| double.DegreesToRadians(x) | RADIANS(@x) | |
| double.RadiansToDegrees(x) | DEGREES(@x) | |
| EF.Functions.Random() | RAND() | |
| Math.Abs(value) | ABS(@value) | |
| Math.Acos(d) | ACOS(@d) | |
| Math.Asin(d) | ASIN(@d) | |
| Math.Atan(d) | ATAN(@d) | |
| Math.Atan2(y, x) | ATN2(@y, @x) ) | |
| Math.Ceiling(d) | CEILING(@d) | |
| Math.Cos(d) | COS(@d) | |
| Math.Exp(d) | EXP(@d) | |
| Math.Floor(d) | FLOOR(@d) | |
| Math.Log(d) | LOG(@d) | |
| Math.Log(a, newBase) | LOG(@a, @newBase) | |
| Math.Log10(d) | LOG10(@d) | |
| Math.Max(x, y) | GREATEST(@x, @y) | EF Core 9.0 |
| Math.Min(x, y) | LEAST(@x; @y) | EF Core 9.0 |
| Math.Pow(x, y) | POWER(@x, @y)) | |
| Math.Round(d) | ROUND(@d, 0) | |
| Math.Round(d, Dezimalstellen) | ROUND(@d; @decimals) | |
| Math.Sign(value) | SIGN(@value) | |
| Math.Sin(a) | SIN(@a) | |
| Math.Sqrt(d) | SQRT(@d) | |
| Math.Tan(a) | TAN(@a) | |
| Math.Truncate(d) | ROUND(@d, 0, 1) |
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.
Zeichenfolgenfunktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| EF.Functions.Collate(operand, collation) | @operand VERGLEICHEN @collation | |
| EF.Functions.Contains(propertyReference, searchCondition) | CONTAINS(@propertyReference, @searchCondition) | |
| EF.Functions.Contains(propertyReference, searchCondition, languageTerm) | CONTAINS(@propertyReference, @searchCondition, LANGUAGE @languageTerm) | |
| EF.Functions.FreeText(propertyReference, freeText) | FREETEXT(@propertyReference, @freeText) | |
| EF.Functions.FreeText(propertyReference, freeText, languageTerm) | FREETEXT(@propertyReference, @freeText, LANGUAGE @languageTerm) | |
| EF.Functions.IsNumeric(expression) | ISNUMERIC(@expression) | |
| EF.Functions.Like(matchExpression, pattern) | @matchExpression WIE @pattern | |
| EF.Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression WIE @pattern ESCAPE @escapeCharacter | |
| Zeichenfolge.Compare(strA, strB) | CASE WHEN @strA = @strB THEN 0 ... ENDE | |
| string.Concat(str0, str1) | @str0 + @str1 | |
| string.IsNullOrEmpty(value) | @value IST NULL ODR @value WIE N'' | |
| string.IsNullOrWhiteSpace(value) | @value IST NULL ODER @value = N'' | |
| String.Join(", ", new [] { x, y, z}) | CONCAT_WS(N', ', @x, @y, @z) | EF Core 9.0 |
| stringValue.CompareTo(strB) | CASE WHEN @stringValue = @strB THEN 0 ... ENDE | |
| stringValue.Contains(value) | @stringValue WIE N'%' + @value + N'%' | |
| stringValue.EndsWith(value) | @stringValue WIE N'%' + @value | |
| stringValue.FirstOrDefault() | SUBSTRING(@stringValue, 1, 1) | |
| stringValue.IndexOf(value) | CHARINDEX(@value, @stringValue) - 1 | |
| stringValue.IndexOf(value, startIndex) | CHARINDEX(@value, @stringValue, @startIndex) - 1 | |
| stringValue.LastOrDefault() | SUBSTRING(@stringValue, LEN(@stringValue), 1) // Diese Funktion gibt das letzte Zeichen eines Strings zurück. | |
| stringValue.Length | LEN(@stringValue) | |
| stringValue.Replace(@oldValue, @newValue) | REPLACE(@stringValue, @oldValue, @newValue) | |
| stringValue.StartsWith(value) | @stringValue WIE @value + N'%' | |
| stringValue.Substring(startIndex) | SUBSTRING(@stringValue, @startIndex + 1, LEN(@stringValue)) | |
| stringValue.Substring(startIndex, length) | SUBSTRING(@stringValue, @startIndex + 1, @length)) | |
| stringValue.ToLower() | LOWER(@stringValue) | |
| stringValue.ToUpper() | UPPER(@stringValue) | |
| stringValue.Trim() | LTRIM(RTRIM(@stringValue)) | |
| stringValue.TrimEnd() | RTRIM(@stringValue) | |
| stringValue.TrimStart() | LTRIM(@stringValue) |
JSON-Funktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| EF. Functions.JsonContains(json, searchValue, path?, searchMode?) | JSON_CONTAINS(@json, @searchValue, @path?, @searchMode?) | EF 11.0 |
| EF.Functions.JsonPathExists(json, path) | JSON_PATH_EXISTS(@json, @path) | EF 11.0 |
Sonstige Funktionen
| .NET | SQL | Hinzugefügt in |
|---|---|---|
| enumValue.HasFlag(flag) | @enumValue & @flag = @flag | |
| Guid.NewGuid() | NEWID() | |
| nullable.GetValueOrDefault() | COALESCE(@nullable, 0) | |
| nullable.GetValueOrDefault(defaultValue) | COALESCE(@nullable, @defaultValue) |
Hinweis
Einige SQL-Übersetzungen wurden zu Veranschaulichungszwecken vereinfacht. Der tatsächliche SQL-Code ist komplexer, um einen größeren Wertebereich zu verarbeiten.
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.
