Nuta
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować się zalogować lub zmienić katalog.
Dostęp do tej strony wymaga autoryzacji. Możesz spróbować zmienić katalogi.
Na tej stronie przedstawiono, które elementy członkowskie platformy .NET są tłumaczone na funkcje SQL podczas korzystania z dostawcy programu SQL Server.
Funkcje agregujące
| .NET | SQL | Dodano element 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.Property) | MIN(Właściwość) | |
| grupa. Sum(x => x.Property) | SUM(Właściwość) | |
| struna. Concat(grupa. Select(x => x.Property)) | STRING_AGG(Właściwość, N'') | |
| struna. Join(separator, grupa. Select(x => x.Property)) | STRING_AGG(Właściwość, @separator) |
Funkcje binarne
| .NET | SQL | Dodano element w |
|---|---|---|
| Bajtów. Contains(value) | CHARINDEX(@value, @bytes)> 0 | |
| Bajtów. ElementAt(i) | PODCIĄG (@bytes, @i + 1, 1) | |
| Bajtów. First() | PODCIĄG (@bytes, 1, 1) | |
| Bajtów. Długość | DATALENGTH(@bytes) | |
| Bajtów. SequenceEqual(sekunda) | @bytes = @second | |
| bajty[i] | PODCIĄG (@bytes, @i + 1, 1) | |
| EF. Functions.DataLength(arg) | DATALENGTH(@arg) |
Funkcje konwersji
| .NET | SQL | Dodano element w |
|---|---|---|
| Bajtów. ToString() | CONVERT(varchar(100), @bytes) | |
| byteValue.ToString() | CONVERT(varchar(3), @byteValue) | |
| charValue.ToString() | CONVERT(varchar(1), @charValue) | |
| Convert.ToBoolean(wartość) | CONVERT(bit, @value) | |
| Konwertuj.ToByte(wartość) | CONVERT(tinyint, @value) | |
| Konwertuj.ToDecimal(wartość) | CONVERT(liczba dziesiętna(18, 2), @value) | |
| Convert.ToDouble(wartość) | CONVERT(float, @value) | |
| Konwertuj.ToInt16(wartość) | CONVERT(smallint, @value) | |
| Konwertuj.ToInt32(wartość) | CONVERT(int, @value) | |
| Konwertuj.ToInt64(wartość) | 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() | 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 element w |
|---|---|---|
| DateTime.Now | GETDATE() | |
| DateTime.Today | CONVERT(date, GETDATE()) | |
| DateTime.UtcNow | GETUTCDATE() | |
| dateTime.AddDays(wartość) | DATEADD(dzień, @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(dayofyear, @dateTime) | |
| dateTime.Hour | DATEPART(godzina, @dateTime) | |
| dateTime.Microsecond | DATEPART(mikrosekundy, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Millisecond | DATEPART(milisekundy, @dateTime) | |
| dateTime.Minute | DATEPART(minuta, minuta, @dateTime) | |
| dateTime.Month | DATEPART(miesiąc, @dateTime) | |
| dateTime.Nanosecond | DATEPART(nanosecond, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Second | DATEPART(sekunda, @dateTime) | |
| dateTime.TimeOfDay | KONWERTUJ(czas, @dateTime) | |
| dateTime.Year | DATEPART(rok, @dateTime) | |
| DateTimeOffset.Now | SYSDATETIMEOFFSET() | |
| DateTimeOffset.UtcNow | SYSUTCDATETIME() | |
| dateTimeOffset.AddDays(dni) | DATEADD(dzień, @days, @dateTimeOffset) | |
| dateTimeOffset.AddHours(godziny) | DATEADD(godzina, @hours, @dateTimeOffset) | |
| dateTimeOffset.AddMilliseconds(milisekundy) | DATEADD(milisekunda, @milliseconds, @dateTimeOffset) | |
| dateTimeOffset.AddMinutes(minuty) | 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.Day | DATEPART(dzień, @dateTimeOffset) | |
| dateTimeOffset.DayOfYear | DATEPART(dayofyear, @dateTimeOffset) | |
| dateTimeOffset.Hour | DATEPART(godzina, @dateTimeOffset) | |
| dateTimeOffset.Microsecond | DATEPART(mikrosekundy, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Millisecond | DATEPART(milisekundy, @dateTimeOffset) | |
| dateTimeOffset.Minute | DATEPART(minuta, minuta, @dateTimeOffset) | |
| dateTimeOffset.Month | DATEPART(miesiąc, @dateTimeOffset) | |
| dateTimeOffset.Nanosecond | DATEPART(nanosecond, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Second | DATEPART(sekunda, @dateTimeOffset) | |
| dateTimeOffset.TimeOfDay | KONWERTUJ(czas, @dateTimeOffset) | |
| dateTimeOffset.ToUnixTimeSeconds() | DATEDIFF_BIG(sekunda, '1970-01-01T00:00:00.0000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.ToUnixTimeMilliseconds() | DATEDIFF_BIG (milisekundy, '1970-01-01T00:00:00.000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.Year | DATEPART(rok, @dateTimeOffset) | |
| DateOnly.FromDateTime(dateTime) | CONVERT(data, @dateTime) | |
| dateOnly.AddDays(wartość) | DATEADD(dzień, @value, @dateOnly) | |
| dateOnly.AddMonths(miesiące) | DATEADD(miesiąc, @months, @dateOnly) | |
| dateOnly.AddYears(wartość) | DATEADD(rok, @value, @dateOnly) | |
| dateOnly.Day | DATEPART(dzień, @dateOnly) | |
| dateOnly.DayOfYear | DATEPART(dayofyear, @dateOnly) | |
| dateOnly.Month | DATEPART(miesiąc, @dateOnly) | |
| dateOnly.Year | DATEPART(rok, @dateOnly) | |
| dateOnly.DayNumber | DATEDIFF(dzień, '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(start, end) | 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(start, end) | DATEDIFF(nanosecond, @start, @end) | |
| EF. Functions.DateDiffSecond(start, end) | DATEDIFF(sekunda, @start, @end) | |
| EF. Functions.DateDiffWeek(start, end) | DATEDIFF(tydzień, @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.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) | |
| timeOnly.Hour | 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, 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, minuta, @timeSpan) | |
| timeSpan.Nanosecond | DATEPART(nanosecond, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Seconds | DATEPART(sekunda, @timeSpan) |
Funkcje liczbowe
| .NET | SQL | Dodano element 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) |
Napiwek
Oprócz metod wymienionych tutaj, odpowiednie ogólne implementacje matematyczne i metody MathF są również tłumaczone. Na przykład , Math.Sin, MathF.Sindouble.Sini float.Sin wszystkie mapuj SIN na funkcję w języku SQL.
Funkcje ciągów
| .NET | SQL | Dodano element w |
|---|---|---|
| EF. Functions.Collate(operand, sortowanie) | @operand COLLATE @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 LUBIĆ @pattern | |
| EF. Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression JAK @pattern UCIECZKA @escapeCharacter | |
| struna. Compare(strA, strB) | PRZYPADEK, GDY @strA = @strB WTEDY 0 ... KONIEC | |
| struna. Concat(str0, str1) | @str0 + @str1 | |
| struna. IsNullOrEmpty(wartość) | @value MA WARTOŚĆ NULL LUB @value NA PRZYKŁAD N'' | |
| struna. IsNullOrWhiteSpace(wartość) | @value MA WARTOŚĆ NULL LUB @value = N'' | |
| struna. 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() | PODCIĄG (@stringValue, 1, 1) | |
| stringValue.IndexOf(wartość) | CHARINDEX(@value, @stringValue) - 1 | |
| stringValue.IndexOf(value, startIndex) | CHARINDEX(@value, @stringValue, @startIndex) - 1 | |
| stringValue.LastOrDefault() | PODCIĄG (@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) | PODCIĄG (@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) |
Różne funkcje
| .NET | SQL | Dodano element w |
|---|---|---|
| enumValue.HasFlag(flaga) | @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 na GitHub
Źródło tej treści można znaleźć na GitHubie, gdzie można także tworzyć i przeglądać problemy oraz pull requesty. Więcej informacji znajdziesz w naszym przewodniku dla współautorów.
