Mapování funkcí zprostředkovatele Microsoft SQL Serveru

Tato stránka ukazuje, které členy .NET jsou přeloženy do kterých funkcí SQL při použití zprostředkovatele SQL Serveru.

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')
řetězec.Join(oddělovač, skupina.Select(x => x.Property))	STRING_AGG(Vlastnost, @separator)

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.Day	DATEPART(den, @dateTimeOffset)
dateTimeOffset.DayOfYear	DATEPART(dayofyear, @dateTimeOffset)
dateTimeOffset.Hour	DATEPART(hodina, @dateTimeOffset)
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.Second	DATEPART(sekunda, @dateTimeOffset)
dateTimeOffset.TimeOfDay	CONVERT(time, @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(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(dayofyear, @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.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)

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é

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-03-27