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 elementy członkowskie platformy .NET są tłumaczone na funkcje SQL podczas korzystania z dostawcy programu 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, group.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) | SUBSTRING(@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] | PODCIĄG (@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(decimal(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(dayofyear, @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.Dzień | 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, @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.0000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.Year | DATEPART(rok, @dateTimeOffset) | |
| 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(dayofyear, @dateOnly) | |
| dateOnly.Month | DATEPART(miesiąc, @dateOnly) | |
| dateOnly.Year | DATEPART(rok, @dateOnly) | |
| dateOnly.DayNumber | DATEDIFF(day, '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(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.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) | 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 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(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(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) |
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.
