Notatka
Dostęp do tej strony wymaga autoryzacji. Może spróbować zalogować się lub zmienić katalogi.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Na tej stronie przedstawiono, które .NET składowe są tłumaczone na funkcje SQL podczas korzystania z dostawcy SQL Server.
Funkcje agregujące
| .NET | SQL | Dodano w |
|---|---|---|
| EF.Functions.StandardDeviationSample(group.Select(x => x.Property)) | STDEV(Właściwość) | |
| EF.Functions.StandardDeviationPopulation(group.Select(x => x.Property)) | STDEVP(Właściwość) | |
| EF.Functions.VarianceSample(group.Select(x => x.Property)) | VAR(Właściwość) | |
| EF.Functions.VariancePopulation(group.Select(x => x.Property)) | VARP(Właściwość) | |
| grupa.Average(x => x.Property) | AVG(Właściwość) | |
| grupa.Count() | COUNT(*) | |
| grupa. LongCount() | COUNT_BIG(*) | |
| grupa.Max(x => x.Property) | MAX(Właściwość) | |
| grupa.Min(x => x.Właściwość) | MIN(Właściwość) | |
| grupa.Sum(x => x.Property) | SUM(Właściwość) | |
| string.Concat(group.Select(x => x.Property)) | STRING_AGG(Właściwość, N'') | |
| string.Join(separator, grupa.Select(x => x.Property)) | STRING_AGG(Właściwość, @separator) |
Funkcje binarne
| .NET | SQL | Dodano w |
|---|---|---|
| bytes.Contains(value) | CHARINDEX(@value, @bytes)> 0 | |
| Bajty.ElementAt(i) | PODCIĄG (@bytes, @i + 1, 1) | |
| bytes.First() | PODCIĄG (@bytes, 1, 1) | |
| Bajtów. Długość | DATALENGTH(@bytes) | |
| Bajtów. SequenceEqual(sekunda) | @bytes = @second | |
| bajt[i] | SUBSTRING(@bytes, @i + 1, 1) | |
| EF.Functions.DataLength(arg) | DATALENGTH(@arg) |
Funkcje konwersji
| .NET | SQL | Dodano w |
|---|---|---|
| bytes.ToString() | CONVERT(varchar(100), @bytes) | |
| byteValue.ToString() | CONVERT(varchar(3), @byteValue) | |
| charValue.ToString() | CONVERT(varchar(1), @charValue) | |
| Convert.ToBoolean(wartość) | CONVERT(bit, @value) | |
| Convert.ToByte(value) | CONVERT(tinyint, @value) | |
| Konwertować.ToDecimal(value) | CONVERT(liczba dziesiętna(18, 2), @value) | |
| Convert.ToDouble(wartość) | CONVERT(float, @value) | |
| Convert.ToInt16(wartość) | CONVERT(smallint, @value) | |
| Convert.ToInt32(wartość) | CONVERT(int, @value) | |
| Convert.ToInt64(value) | CONVERT(bigint, @value) | |
| Convert.ToString(wartość) | 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() // converts the value to a string (konwertuje wartość na ciąg znaków) | 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) |
Funkcje daty i godziny
| .NET | SQL | Dodano w |
|---|---|---|
| DateTime.Now | GETDATE() | |
| DateTime.Today | CONVERT(date, GETDATE()) | |
| DateTime.UtcNow | GETUTCDATE() | |
| dateTime.AddDays(wartość) | DATEADD(dni, @value, @dateTime) | |
| dateTime.AddHours(wartość) | DATEADD(godzina, @value, @dateTime) | |
| dateTime.AddMilliseconds(wartość) | DATEADD(milisekunda, @value, @dateTime) | |
| dateTime.AddMinutes(wartość) | DATEADD(minuta, @value, @dateTime) | |
| dateTime.AddMonths(miesiące) | DATEADD(miesiąc, @months, @dateTime) | |
| dateTime.AddSeconds(wartość) | DATEADD(sekunda, @value, @dateTime) | |
| dateTime.AddYears(value) | DATEADD(rok, @value, @dateTime) | |
| dateTime.Date | CONVERT(data, @dateTime) | |
| dateTime.Day | DATEPART(dzień, @dateTime) | |
| dateTime.DayOfYear | DATEPART(dzień_roku, @dateTime) | |
| dataCzas.Godzina | DATEPART(godzina, @dateTime) | |
| dateTime.Microsecond | DATEPART(mikrosekundy, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Millisecond | DATEPART(milisekundy, @dateTime) | |
| dateTime.Minute | DATEPART(minuta, @dateTime) | |
| dateTime.Month | DATEPART(miesiąc, @dateTime) | |
| dateTime.Nanosecond | DATEPART(nanosecond, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Second (sekunda) | DATEPART(sekunda, @dateTime) | |
| dateTime.TimeOfDay | KONWERTUJ(czas, @dateTime) | |
| dateTime.Year | DATEPART(rok, @dateTime) | |
| DateTimeOffset.Now (aktualna data i czas z uwzględnieniem przesunięcia strefy czasowej) | SYSDATETIMEOFFSET() | |
| DateTimeOffset.UtcNow | SYSUTCDATETIME() | |
| dateTimeOffset.AddDays(dni) | DATEADD(dni, @days, @dateTimeOffset) | |
| dateTimeOffset.AddHours(godziny) | DATEADD(godzina, @hours, @dateTimeOffset) | |
| dateTimeOffset.AddMilliseconds(milisekund) | DATEADD(milisekunda, @milliseconds, @dateTimeOffset) | |
| dateTimeOffset.AddMinutes(minutes) | DATEADD(minuta, @minutes, @dateTimeOffset) | |
| dateTimeOffset.AddMonths(miesiące) | DATEADD(miesiąc, @months, @dateTimeOffset) | |
| dateTimeOffset.AddSeconds(sekundy) | DATEADD(sekunda, @seconds, @dateTimeOffset) | |
| dateTimeOffset.AddYears(years) | DATEADD(rok, @years, @dateTimeOffset) | |
| dateTimeOffset.Date | CONVERT(data, @dateTimeOffset) | |
| dateTimeOffset.DateTime | CONVERT(datetime2, @dateTimeOffset) | EF Core 11.0 |
| dateTimeOffset.Dzień | DATEPART(dzień, @dateTimeOffset) | |
| dateTimeOffset.DayOfYear | DATEPART(dzień_roku, @dateTimeOffset) | |
| dateTimeOffset.Hour | DATEPART(godzina, @dateTimeOffset) | |
| dateTimeOffset.LocalDateTime | CONVERT(datetime2, @dateTimeOffset AT TIME ZONE CURRENT_TIMEZONE_ID()) | EF Core 11.0 |
| dateTimeOffset.Microsecond | DATEPART(mikrosekundy, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Millisecond | DATEPART(milisekundy, @dateTimeOffset) | |
| dateTimeOffset.Minute | DATEPART(minuta, @dateTimeOffset) | |
| dateTimeOffset.Month | DATEPART(miesiąc, @dateTimeOffset) | |
| dateTimeOffset.Nanosecond | DATEPART(nanosekunda, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Offset.TotalMinutes | CAST(DATEPART(tz, @dateTimeOffset) AS float) | EF Core 11.0 |
| dateTimeOffset.Second | DATEPART(sekunda, @dateTimeOffset) | |
| dateTimeOffset.TimeOfDay | KONWERTUJ(czas, @dateTimeOffset) | |
| dateTimeOffset.ToOffset(przesunięcie) | SWITCHOFFSET(@dateTimeOffset, @offset) | EF Core 11.0 |
| dateTimeOffset.ToUnixTimeSeconds() | DATEDIFF_BIG(sekunda, '1970-01-01T00:00:00.0000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.ToUnixTimeMilliseconds() | DATEDIFF_BIG(milisekundy, '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(rok, @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(data, @dateTime) | |
| dateOnly.AddDays(wartość) | DATEADD(dni, @value, @dateOnly) | |
| dateOnly.AddMonths(miesiące) | DATEADD(miesiąc, @months, @dateOnly) | |
| dateOnly.AddYears(wartość) | DATEADD(rok, @value, @dateOnly) | |
| dateOnly.Dzień | DATEPART(dzień, @dateOnly) | |
| dateOnly.DzieńRoku | DATEPART(dzień_roku, @dateOnly) | |
| dateOnly.Month | DATEPART(miesiąc, @dateOnly) | |
| dateOnly.Year | DATEPART(rok, @dateOnly) | |
| dateOnly.DayNumber | DATEDIFF(dni, '0001-01-01', @dateOnly) | EF Core 10.0 |
| EF. Functions.AtTimeZone(dateTime, timeZone) | @dateTime W STREFIE CZASOWEJ @timeZone | |
| EF.Functions.DateDiffDay(start, end) | DATEDIFF(dzień, @start, @end) | |
| EF.Functions.DateDiffHour(start, end) | DATEDIFF(godzina, @start, @end) | |
| EF.Functions.DateDiffMicrosecond(początek, koniec) | DATEDIFF(mikrosekundy, @start, @end) | |
| EF.Functions.DateDiffMillisecond(start, end) | DATEDIFF(milisekundy, @start, @end) | |
| EF. Functions.DateDiffMinute(start, end) | DATEDIFF(minuta, @start, @d2) | |
| EF.Functions.DateDiffMonth(start, end) | DATEDIFF(miesiąc, @start, @end) | |
| EF.Functions.DateDiffNanosecond(początek, koniec) | DATEDIFF(nanosekunda, @start, @end) | |
| EF.Functions.DateDiffSecond(start, end) | DATEDIFF(sekundy, @start, @end)) | |
| EF. Functions.DateDiffWeek(start, end) | DATEDIFF(tygodnie, @start, @end) | |
| EF.Functions.DateDiffYear(start, end) | DATEDIFF(rok, @start, @end) | |
| EF. Functions.DateFromParts(rok, miesiąc, dzień) | DATEFROMPARTS(@year, @month, @day) | |
| EF. Functions.DateTime2FromParts(rok, miesiąc, dzień, ...) | DATETIME2FROMPARTS(@year, @month, @day, ...) | |
| EF.Functions.DateTimeFromParts(rok, miesiąc, dzień, ...) | DATETIMEFROMPARTS(@year, @month, @day, ...) | |
| EF.Functions.DateTimeOffsetFromParts(rok, miesiąc, dzień, ...) | 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(rok, miesiąc, dzień, ...) | SMALLDATETIMEFROMPARTS(@year, @month, @day, ...) | |
| EF. Functions.TimeFromParts(godzina, minuta, sekunda, ...) | TIMEFROMPARTS(@hour, @minute, @second, ...) | |
| timeOnly.AddHours(wartość) | DATEADD(godzina, @value, @timeOnly) | |
| timeOnly.AddMinutes(wartość) | DATEADD(minuta, @value, @timeOnly) | |
| Godzina z timeOnly | DATEPART(godzina, @timeOnly) | |
| timeOnly.IsBetween(początek, koniec) | @timeOnly >= @start AND @timeOnly<@end | |
| timeOnly.Microsecond (mikrosekunda) | DATEPART(mikrosekundy, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Millisecond | DATEPART(milisekundy, @timeOnly) | |
| timeOnly.Minute | DATEPART(minuta, @timeOnly) | |
| timeOnly.Nanosecond | DATEPART(nanosecond, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Second | DATEPART(sekunda, @timeOnly) | |
| timeSpan.Hours | DATEPART(godzina, @timeSpan) | |
| timeSpan.Mikrosekunda | DATEPART(mikrosekundy, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Milliseconds | DATEPART(milisekundy, @timeSpan) | |
| timeSpan.Minutes | DATEPART(minuta, @timeSpan) | |
| timeSpan.Nanosecond | DATEPART(nanosecond, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Seconds | DATEPART(sekunda, @timeSpan) |
Funkcje liczbowe
| .NET | SQL | Dodano w |
|---|---|---|
| podwójny. DegreesToRadians(x) | RADIANS (@x) | |
| podwójny. RadiansToDegrees(x) | DEGREES(@x) | |
| EF.Functions.Random() | RAND() | |
| Math.Abs(wartość) | 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, dziesiętne) | ROUND(@d, @decimals) | |
| Math.Sign(wartość) | SIGN(@value) | |
| Math.Sin(a) | SIN(@a) | |
| Math.Sqrt(d) | SQRT(@d) | |
| Math.Tan(a) | TAN(@a) | |
| Math.Truncate(d) | ROUND(@d, 0, 1) |
Wskazówka
Oprócz metod wymienionych tutaj, odpowiednie ogólne implementacje matematyczne i metody MathF są również tłumaczone. Na przykład, Math.Sin, MathF.Sin, double.Sin i float.Sin wszystkie mapują do funkcji SIN w języku SQL.
Funkcje ciągów
| .NET | SQL | Dodano w |
|---|---|---|
| EF.Functions.Collate(operand, zestawienie) | @operand COLLATE (komenda SQL) @collation | |
| EF.Functions.Contains(propertyReference, searchCondition) | CONTAINS(@propertyReference, @searchCondition) | |
| EF.Functions.Contains(propertyReference, searchCondition, languageTerm) | ZAWIERA(@propertyReference, @searchCondition, JĘZYK @languageTerm) | |
| EF.Functions.FreeText(propertyReference, freeText) | FREETEXT(@propertyReference, @freeText) | |
| EF.Funkcje.FreeText(propertyReference, freeText, languageTerm) | FREETEXT(@propertyReference, @freeText, LANGUAGE @languageTerm) | |
| EF.Functions.IsNumeric(expression) | ISNUMERIC(@expression) | |
| EF.Functions.Like(matchExpression, pattern) | @matchExpression POLUBIĆ @pattern | |
| EF.Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression LIKE @pattern ESCAPE @escapeCharacter | |
| String.Compare(strA, strB) | PRZYPADEK, GDY @strA = @strB WTEDY 0 ... KONIEC | |
| String.Concat(str0, str1) | @str0 + @str1 | |
| string.IsNullOrEmpty(value) | @value MA WARTOŚĆ NULL LUB @value NA PRZYKŁAD N'' | |
| string.IsNullOrWhiteSpace(value) | @value MA WARTOŚĆ NULL LUB @value = N'' | |
| ciąg.Join(", ", new [] { x, y, z }) | CONCAT_WS(N', ', @x, @y, @z)) | EF Core 9.0 |
| stringValue.CompareTo(strB) | PRZYPADEK, GDY @stringValue = @strB WTEDY 0 ... KONIEC | |
| stringValue.Contains(wartość) | @stringValue LIKE N'%' + @value + N'%' | |
| stringValue.EndsWith(wartość) | @stringValue LIKE N'%' + @value | |
| stringValue.FirstOrDefault() | SUBSTRING(@stringValue, 1, 1) | |
| stringValue.IndexOf(wartość) | CHARINDEX(@value, @stringValue) - 1 | |
| stringValue.IndexOf(wartość, indeksPoczątkowy) | 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(wartość) | @stringValue LIKE @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) |
Funkcje JSON
| .NET | SQL | Dodano w |
|---|---|---|
| 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 |
Różne funkcje
| .NET | SQL | Dodano w |
|---|---|---|
| enumValue.HasFlag(flag) | @enumValue & @flag = @flag | |
| Guid.NewGuid() | NEWID() | |
| nullable.GetValueOrDefault() | COALESCE(@nullable, 0) | |
| Nullable.GetValueOrDefault(defaultValue) | COALESCE(@nullable, @defaultValue) |
Uwaga
Niektóre tłumaczenia SQL zostały uproszczone w celach ilustracyjnych. Rzeczywisty język SQL jest bardziej złożony do obsługi szerszego zakresu wartości.
Zobacz też
Współpracuj z nami w serwisie GitHub
Źródło tej zawartości można znaleźć w witrynie GitHub, gdzie można również tworzyć i przeglądać problemy i żądania ściągnięcia. Więcej informacji znajdziesz w naszym przewodniku dla współtwórców.
