Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
Tato stránka ukazuje, které .NET členy jsou přeloženy do kterých funkcí SQL při použití poskytovatele SQL Server.
Agregační funkce
Obecné informace o používání agregačních funkcí v dotazech najdete v tématu Agregační funkce.
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| EF. Functions.StandardDeviationSample(group. Select(x => x.Property)) | STDEV(Vlastnost) | |
| EF.Functions.StandardDeviationPopulation(group.Select(x => x.Property)) | STDEVP(Vlastnost) | |
| EF.Functions.VarianceSample(group.Select(x => x.Property)) | VAR(– vlastnost) | |
| EF.Functions.VariancePopulation(group.Select(x => x.Property)) | VARP(Vlastnost) | |
| skupina.Průměr(x => x.Property) | AVG(Vlastnost) | |
| skupina.Count() | COUNT(*) | |
| skupina. LongCount() | COUNT_BIG(*) | |
| skupina.Max(x => x.Property) | MAX(Vlastnost) | |
| skupina.Min(x=> x.Property) | MIN(Vlastnost) | |
| skupina.Sum(x => x.Property) | SUMA(Vlastnost) | |
| string.Concat(group.Select(x => x.Property)) | STRING_AGG(Vlastnost, N') | |
| string.Concat(group.OrderBy(x => x.Other).Select(x => x.Property)) | STRING_AGG(vlastnost, N') WITHIN GROUP (ORDER BY Other) | EF Core 11.0 |
| řetězec.Join(oddělovač, skupina.Select(x => x.Property)) | STRING_AGG(Vlastnost, @separator) | |
| string.Join(separator, group.OrderBy(x => x.Other).Select(x => x.Property)) | STRING_AGG(vlastnost, @separator) WITHIN GROUP (ORDER BY Other) | EF Core 11.0 |
Binární funkce
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| byty. Contains(value) | CHARINDEX(@value; @bytes)> 0 | |
| bytes.ElementAt(i) | SUBSTRING(@bytes; @i + 1; 1) | |
| bytes.First() | SUBSTRING(@bytes, 1, 1) | |
| byty. Délka | DATALENGTH(@bytes) | |
| byty. SequenceEqual(druhý) | @bytes = @second | |
| bytes[i] | SUBSTRING(@bytes; @i + 1; 1) | |
| EF.Functions.DataLength(arg) | DATALENGTH(@arg) |
Převodní funkce
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| 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(decimal(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(hodnota) | 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) |
Funkce pro datum a čas
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| DateTime.Now | GETDATE() | |
| DateTime.Today | CONVERT(date, GETDATE()) | |
| DateTime.UtcNow (Aktuální čas v UTC) | GETUTCDATE() | |
| dateTime.AddDays(value) | DATEADD(den, @value, @dateTime) | |
| dateTime.AddHours(value) (Tato metoda přidává zadaný počet hodin k časovému objektu.) | DATEADD(hodina, @value, @dateTime) | |
| dateTime.AddMilliseconds(value) | DATEADD(milisekunda, @value, @dateTime) | |
| dateTime.AddMinutes(hodnota) | DATEADD(minuta, @value, @dateTime) | |
| dateTime.PřidatMěsíce(měsíce) | DATEADD(měsíc, @months, @dateTime) | |
| dateTime.AddSeconds(value) | DATEADD(sekunda, @value, @dateTime) | |
| dateTime.AddYears(value) | DATEADD(rok, @value, @dateTime)) | |
| dateTime.Date | CONVERT(datum, @dateTime) | |
| dateTime.Day | DATEPART(den, @dateTime) | |
| dateTime.DayOfYear (den v roce) | DATEPART(denvroku, @dateTime) | |
| dateTime.Hour | DATEPART(hodina, @dateTime) | |
| dateTime.Microsecond | DATEPART(mikrosekundy, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Millisecond | DATEPART(milisekunda, @dateTime) | |
| dateTime.Minute | DATEPART(minuta, @dateTime) | |
| dateTime.Month | DATEPART(měsíc, @dateTime) | |
| dateTime.Nanosecond | DATEPART(nanosekundy, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Second | DATEPART(sekunda, @dateTime) | |
| dateTime.TimeOfDay | CONVERT(time, @dateTime) | |
| dateTime.Year | DATEPART(rok, @dateTime) | |
| DateTimeOffset.Now | SYSDATETIMEOFFSET() | |
| DateTimeOffset.UtcNow | SYSUTCDATETIME() | |
| dateTimeOffset.AddDays(days) | DATEADD(den, @days, @dateTimeOffset) | |
| dateTimeOffset.AddHours(hours) | DATEADD(hodina, @hours, @dateTimeOffset) | |
| dateTimeOffset.AddMilliseconds(milisekundy) | DATEADD(milisekunda, @milliseconds, @dateTimeOffset) | |
| dateTimeOffset.AddMinutes(minutes) | DATEADD(minuta, @minutes, @dateTimeOffset) | |
| dateTimeOffset.AddMonths(počet měsíců) | DATEADD(měsíc, @months, @dateTimeOffset) | |
| dateTimeOffset.AddSeconds(seconds) | DATEADD(sekunda, @seconds, @dateTimeOffset) | |
| dateTimeOffset.AddYears(roků) | DATEADD(rok, @years, @dateTimeOffset)) | |
| dateTimeOffset.Date | CONVERT(datum, @dateTimeOffset) | |
| dateTimeOffset.DateTime | CONVERT(datetime2, @dateTimeOffset) | EF Core 11.0 |
| dateTimeOffset.Day | DATEPART(den, @dateTimeOffset) | |
| dateTimeOffset.DayOfYear | DATEPART(denvroku, @dateTimeOffset) | |
| dateTimeOffset.Hour | DATEPART(hodina, @dateTimeOffset) | |
| dateTimeOffset.LocalDateTime (lokální datum a čas) | 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(milisekunda, @dateTimeOffset) | |
| dateTimeOffset.Minute | DATEPART(minuta, @dateTimeOffset) | |
| dateTimeOffset.Month | DATEPART(měsíc, @dateTimeOffset) | |
| dateTimeOffset.Nanosekunda | DATEPART(nanosekundy, @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 | CONVERT(time, @dateTimeOffset) | |
| dateTimeOffset.ToOffset(offset) | 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.000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.UtcDateTime | CONVERT(datetime2, @dateTimeOffset V ČASOVÉ ZÓNĚ '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(datum, @dateTime) | |
| dateOnly.AddDays(value) | DATEADD(den, @value, @dateOnly) | |
| dateOnly.AddMonths(months) | DATEADD(měsíc, @months, @dateOnly) | |
| dateOnly.AddYears(value) | DATEADD(rok, @value, @dateOnly)) | |
| dateOnly.Day | DATEPART(den, @dateOnly) | |
| dateOnly.DayOfYear | DATEPART(denvroku, @dateOnly) | |
| dateOnly.Month | DATEPART(měsíc, @dateOnly) | |
| dateOnly.Year | DATEPART(rok, @dateOnly) | |
| dateOnly.DayNumber | DATEDIFF(den, '0001-01-01', @dateOnly) | EF Core 10.0 |
| EF. Functions.AtTimeZone(dateTime, timeZone) | @dateTime V ČASOVÉM PÁSMU @timeZone | |
| EF.Functions.DateDiffDay(start, end) | DATEDIFF(den, @start, @end) | |
| EF.Functions.DateDiffHour(start, end) | DATEDIFF(hodina, @start, @end) | |
| EF.Functions.DateDiffMicrosecond(začátek, konec) | DATEDIFF(mikrosekundy, @start, @end) | |
| EF. Functions.DateDiffMillisecond(začátek, konec) | DATEDIFF(milisekundy, @start, @end) | |
| EF.Functions.DateDiffMinute(start, end) | DATEDIFF(minuta, @start, @d2) | |
| EF.Functions.DateDiffMonth(start, end) | DATEDIFF(měsíc, @start, @end) | |
| EF.Functions.DateDiffNanosecond(start, end) | DATEDIFF(nanosekunda, @start, @end) | |
| EF. Functions.DateDiffSecond(začátek, konec) | DATEDIFF(sekunda, @start, @end) | |
| EF.Functions.DateDiffWeek(start, end) | DATEDIFF(týden, @start, @end) | |
| EF.Functions.DateDiffYear(start, end) | DATEDIFF(year, @start, @end)) | |
| EF. Functions.DateFromParts(rok, měsíc, den) | DATEFROMPARTS(@year, @month, @day)) | |
| EF. Functions.DateTime2FromParts(rok, měsíc, den, ...) | DATETIME2FROMPARTS(@year; @month, @day...) | |
| EF.Functions.DateTimeFromParts(year, month, day, ...) | DATETIMEFROMPARTS(@year; @month, @day...) | |
| EF.Functions.DateTimeOffsetFromParts(year, month, day, ...) | DATETIMEOFFSETFROMPARTS(@year, @month, @day...) | |
| EF. Functions.DateTrunc(datepart; value) | DATETRUNC(@datepart; @value) | EF Core 11.0 |
| EF.Functions.IsDate(výraz) | ISDATE(@expression) | |
| EF.Functions.SmallDateTimeFromParts(rok, měsíc, den, ...) | SMALLDATETIMEFROMPARTS(@year, @month, @day...) | |
| EF. Functions.TimeFromParts(hodina, minuta, sekunda, ...) | TIMEFROMPARTS(@hour; @minute; @second...) | |
| timeOnly.AddHours(value) | DATEADD(hodina, @value, @timeOnly) | |
| timeOnly.AddMinutes(value) | DATEADD(minuta, @value, @timeOnly) | |
| timeOnly.Hour | DATEPART(hodina, @timeOnly) | |
| timeOnly.IsBetween(start, end) | @timeOnly >= @start AND @timeOnly<@end | |
| timeOnly.Microsecond | DATEPART(mikrosekundy, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Millisecond | DATEPART(milisekunda, @timeOnly) | |
| timeOnly.Minute | DATEPART(minuta, @timeOnly) | |
| timeOnly.Nanosecond | DATEPART(nanosekundy, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Second | DATEPART(sekunda, @timeOnly) | |
| timeSpan.Hours | DATEPART(hodina, @timeSpan) | |
| timeSpan.Mikrosekunda | DATEPART(mikrosekundy, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Milliseconds | DATEPART(milisekunda, @timeSpan) | |
| timeSpan.Minutes | DATEPART(minuta, @timeSpan) | |
| timeSpan.Nanosecond | DATEPART(nanosekundy, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Seconds | DATEPART(sekunda, @timeSpan) |
Numerické funkce
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| dvojitý. 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, počet desetinných míst) | 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) |
Tip
Kromě zde uvedených metod jsou také přeloženy odpovídající obecné matematické implementace a metody MathF . Například Math.Sin, MathF.Sin, double.Sin a float.Sin všechny mapují na SIN funkci v SQL.
Funkce řetězců
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| EF. Functions.Collate(operand, kolace) | @operand KOLACIONOVAT @collation | |
| EF.Functions.Contains(propertyReference, searchCondition) | CONTAINS(@propertyReference; @searchCondition) | |
| EF.Functions.Contains(propertyReference, searchCondition, languageTerm) | CONTAINS(@propertyReference, @searchCondition, JAZYK @languageTerm) | |
| EF.Functions.FreeText(propertyReference, freeText) | FREETEXT(@propertyReference; @freeText) | |
| EF.Functions.FreeText(propertyReference, freeText, languageTerm) | FREETEXT(@propertyReference, @freeText, JAZYK @languageTerm) | |
| EF.Functions.IsNumeric(expression) | ISNUMERIC(@expression) | |
| EF. Functions.Like(matchExpression; pattern) | @matchExpression JAKO @pattern | |
| EF.Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression JAKO @pattern ESCAPE @escapeCharacter | |
| string.Compare(strA, strB) | CASE WHEN @strA = @strB THEN 0 ... KONEC | |
| Řetězec.Concat(str0, str1) | @str0 + @str1 | |
| string.IsNullOrEmpty(hodnota) | @value JE NULL NEBO @value LIKE N'' | |
| string.IsNullOrWhiteSpace(value) | @value IS NULL NEBO @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 ... KONEC | |
| stringValue.Contains(value) | @stringValue LIKE N'%' + @value +N'%' | |
| stringValue.EndsWith(value) | @stringValue LIKE N'%' + @value | |
| stringValue.FirstOrDefault() | PODŘETĚŽCE(@stringValue; 1; 1) | |
| stringValue.IndexOf(value) | CHARINDEX(@value; @stringValue) - 1 | |
| stringValue.IndexOf(hodnota, 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 LIKE @value +N'%' | |
| stringValue.Substring(startIndex) | SUBSTRING(@stringValue; @startIndex + 1; DÉLKA(@stringValue)) | |
| stringValue.Substring(startIndex; length) | PODŘETĚŽK(@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) |
Funkce JSON
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| EF.Functions.JsonContains(json, searchValue, path?, searchMode?) | JSON_CONTAINS(@json; @searchValue; @path?; @searchMode?) | EF 11.0 |
| EF. Functions.JsonPathExists(json, cesta) | JSON_PATH_EXISTS(@json; @path) | EF 11.0 |
Různé funkce
| platforma .NET | SQL | Přidáno do |
|---|---|---|
| enumValue.HasFlag(flag) | @enumValue & @flag = @flag | |
| Guid.NewGuid() | NEWID() | |
| Nullable. GetValueOrDefault() | COALESCE(@nullable, 0) | |
| Nullable.GetValueOrDefault(defaultValue) | COALESCE(@nullable; @defaultValue) |
Poznámka:
Některé překlady SQL se zjednodušily pro účely ilustrace. Skutečný SQL je složitější pro zpracování širšího rozsahu hodnot.
Viz také
Spolupracujte s námi na GitHubu
Zdroj tohoto obsahu najdete na GitHubu, kde můžete také vytvářet a kontrolovat problémy a žádosti o přijetí změn. Další informace najdete v našem průvodci pro přispěvatele.
