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 SQL Server-Anbieter verwendet wird.
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(*) | |
| Gruppe. Max(x => x.Property) | MAX(Property) | |
| Gruppe. Min(x => x.Property) | MIN(Property) | |
| Gruppe. Sum(x => x.Property) | SUM(Property) | |
| Schnur. Verkettung(Gruppe). Select(x => x.Property)) | STRING_AGG(Eigenschaft, N'') | |
| Schnur. Join(Trennzeichen, Gruppe). Select(x => x.Property)) | STRING_AGG(Eigenschaft, @separator) |
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() | TEILZEICHENFOLGE(@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(Hour, @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(dayofyear, @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(Tag, @days, @dateTimeOffset) | |
| dateTimeOffset.AddHours(hours) | DATEADD(Hour, @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.Day | DATEPART(Tag, @dateTimeOffset) | |
| dateTimeOffset.DayOfYear | DATEPART(dayofyear, @dateTimeOffset) | |
| dateTimeOffset.Hour | DATEPART(Stunde, @dateTimeOffset) | |
| 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.Second | DATEPART(Sekunde, @dateTimeOffset) | |
| dateTimeOffset.TimeOfDay | CONVERT(time, @dateTimeOffset) | |
| 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.Year | DATEPART(Jahr, @dateTimeOffset) | |
| DateOnly.FromDateTime(dateTime) | CONVERT(Datum; @dateTime) | |
| dateOnly.AddDays(value) | DATEADD(Tag, @value, @dateOnly) | |
| dateOnly.AddMonths(months) | DATEADD(Monat, @months, @dateOnly) | |
| dateOnly.AddYears(value) | DATEADD(Jahr, @value, @dateOnly) | |
| dateOnly.Day | DATEPART(Tag, @dateOnly) | |
| dateOnly.DayOfYear | DATEPART(dayofyear, @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 ZUR ZEITZONE @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(Woche, , @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.IsDate(expression) | ISDATE(@expression) | |
| EF. Functions.SmallDateTimeFromParts(Jahr, Monat, Tag, ...) | SMALLDATETIMEFROMPARTS(@year, @month, , @day...) | |
| EF.Functions.TimeFromParts(stunde, minute, sekunde, ...) | TIMEFROMPARTS(@hour, @minute, , @second...) | |
| timeOnly.AddHours(value) | DATEADD(Hour, @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, sortation) | @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 | |
| Schnur. 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() | TEILZEICHENFOLGE(@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) | |
| 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) |
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.
