Megjegyzés
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhat bejelentkezni vagy módosítani a címtárat.
Az oldalhoz való hozzáféréshez engedély szükséges. Megpróbálhatja módosítani a címtárat.
Ez az oldal azt mutatja be, hogy mely .NET-tagok mely SQL-függvényekkel lesznek lefordítva az SQL Server adatszolgáltató használatakor.
Összesítő függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| EF. Functions.StandardDeviationSample(group. Select(x => x.Property)) | STDEV(tulajdonság) | |
| EF.Functions.StandardDeviationPopulation(group.Select(x => x.Property)) | STDEVP(Property) | |
| EF.Functions.VarianceSample(group.Select(x => x.Property)) | VAR(Tulajdonság) | |
| EF.Functions.VariancePopulation(group.Select(x => x.Property)) | VARP(tulajdonság) | |
| csoport.Átlag(x => x.Tulajdonság) | AVG(tulajdonság) | |
| csoport. Darabszám() | DARAB(*) | |
| csoport. LongCount() | COUNT_BIG(*) | |
| csoport.Max(x => x.Tulajdonság) | MAX(tulajdonság) | |
| csoport.Min(x => x.Property) | MIN(Tulajdonság) | |
| csoport.Sum(x => x.Tulajdonság) | SUM(Tulajdonság) | |
| karakterlánc.Concat(csoport.Select(x => x.Property)) | STRING_AGG(Tulajdonság, N'') | |
| string.Join(elválasztó, csoport.Select(x => x.Property)) | STRING_AGG(Tulajdonság, @separator) |
Bináris függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| bytes.Contains(érték) | CHARINDEX(@value, @bytes)> 0 | |
| Bájtok.ElementAt(i) | SUBSTRING(@bytes, @i + 1, 1) | |
| bytes.First() | SUBSTRING(@bytes, 1, 1) | |
| Bájt. Hosszúság | DATALENGTH(@bytes) | |
| bytes.SequenceEqual(second) | @bytes = @second | |
| bájt[i] | SUBSTRING(@bytes, @i + 1, 1) | |
| EF.Functions.DataLength(arg) | DATALENGTH(@arg) |
Konverziós függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| bytes.ToString() | KONVERTÁLÁS(varchar(100), @bytes) | |
| byteValue.ToString() | KONVERT(varchar(3), @byteValue) | |
| charValue.ToString() | KONVERTÁLÁS(varchar(1), @charValue) | |
| Convert.ToBoolean(value) | KONVERTÁLÁS(bit, @value) | |
| Convert.ToByte(érték) | KONVERTÁLÁS(tinyint, @value) | |
| Convert.ToDecimal(value) | KONVERTÁLÁS(decimális(18; 2), @value) | |
| Convert.ToDouble(value) | KONVERTÁLÁS(lebegőpontos, @value) | |
| Convert.ToInt16(érték) | KONVERTÁLÁS(smallint, @value) | |
| Convert.ToInt32(érték) | KONVERTÁLÁS(int, @value) | |
| Convert.ToInt64(érték) | KONVERTÁLÁS(bigint, @value) | |
| Convert.ToString(érték) | KONVERTÁLÁS(nvarchar(max), @value) | |
| dateOnly.ToString() | KONVERTÁLÁS(varchar(100), @dateOnly) | |
| dateTime.ToString() | KONVERTÁLÁS(varchar(100), @dateTime) | |
| dateTimeOffset.ToString() | KONVERTÁLÁS(varchar(100), @dateTimeOffset) | |
| decimalValue.ToString() | KONVERTÁLÁS(varchar(100), @decimalValue) | |
| doubleValue.ToString() | KONVERTÁLÁS(varchar(100), @doubleValue) | |
| floatValue.ToString() | KONVERTÁLÁS(varchar(100), @floatValue) | |
| guid.ToString() | KONVERTÁLÁS(varchar(36), @guid) | |
| intValue.ToString() | CONVERT(varchar(11), @intValue) | |
| longValue.ToString() | CONVERT(varchar(20), @longValue) | |
| sbyteValue.ToString() | KONVERTÁLÁS(varchar(4), @sbyteValue) | |
| shortValue.ToString() | KONVERTÁLÁS(varchar(6), @shortValue) | |
| timeOnly.ToString() | KONVERTÁLÁS(varchar(100), @timeOnly) | |
| timeSpan.ToString() | KONVERTÁLÁS(varchar(100), @timeSpan) | |
| uintValue.ToString() | KONVERTÁLÁS(varchar(10), @uintValue) | |
| ulongValue.ToString() | KONVERTÁLÁS(varchar(19), @ulongValue) | |
| ushortValue.ToString() | CONVERT(varchar(5), @ushortValue) |
Dátum- és időfüggvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| DateTime.Now | GETDATE() | |
| DateTime.Today | KONVERTÁLÁS(dátum, GETDATE()) | |
| DateTime.UtcNow | GETUTCDATE() - visszaadja az aktuális UTC dátumot. | |
| dateTime.AddDays(érték) | DATEADD(nap, @value, @dateTime) | |
| dateTime.AddHours(value) | DATEADD(óra, @value, @dateTime) | |
| dateTime.AddMilliseconds(value) | DATEADD(ezredmásodperc, @value; @dateTime) | |
| dateTime.AddMinutes(érték) | DATEADD(perc, @value, @dateTime) | |
| dateTime.AddMonths(hónapok) | DATEADD(month, @months, @dateTime)) | |
| dateTime.AddSeconds(value) | DATEADD(másodperc, @value, @dateTime) | |
| dateTime.AddYears(érték) | DATEADD(év, @value, @dateTime) | |
| dateTime.Date | KONVERT(dátum, @dateTime) | |
| dateTime.Day | DÁTUMRÉSZ(nap, @dateTime) | |
| dateTime.DayOfYear | DATEPART(évnapja, @dateTime) | |
| dateTime.óra | DATEPART(óra, @dateTime) | |
| dateTime.Microsecond | DATEPART(mikroszekundum, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Milliszekundum | DATEPART(ezredmásodperc, @dateTime) | |
| dateTime.Minute | DATEPART(perc, @dateTime) | |
| dateTime.Hónap | DATEPART(hónap, @dateTime) | |
| dateTime.Nanosecond | DATEPART(nanosecond, @dateTime) % 1000 | EF Core 10.0 |
| dateTime.Second | DATEPART(másodperc, @dateTime) | |
| dateTime.TimeOfDay | KONVERTÁLÁS(idő, @dateTime) | |
| dateTime.Year | DATEPART(év, @dateTime) | |
| DateTimeOffset.Now | SYSDATETIMEOFFSET() | |
| DateTimeOffset.UtcNow | SYSUTCDATETIME() | |
| dateTimeOffset.AddDays(days) | DATEADD(nap, @days, @dateTimeOffset) | |
| dateTimeOffset.AddHours(órák) | DATEADD(óra, @hours, @dateTimeOffset) | |
| dateTimeOffset.AddMilliseconds(milliseconds) | DATEADD(ezredmásodperc, @milliseconds; @dateTimeOffset) | |
| dateTimeOffset.AddMinutes(perc) | DATEADD(perc, @minutes, @dateTimeOffset) | |
| dateTimeOffset.AddMonths(hónapok száma) | DATEADD(month, @months, @dateTimeOffset)) | |
| dateTimeOffset.AddSeconds(másodpercek) | DATEADD(másodperc, @seconds, @dateTimeOffset) | |
| dateTimeOffset.AddYears(év) | DATEADD(év, @years, @dateTimeOffset) | |
| dateTimeOffset.Dátum | KONVERT(dátum, @dateTimeOffset) | |
| dateTimeOffset.Day | DÁTUMRÉSZ(nap, @dateTimeOffset) | |
| dateTimeOffset.DayOfYear (az év napja) | DATEPART(évnapja, @dateTimeOffset) | |
| dateTimeOffset.Hour | DATEPART(óra, @dateTimeOffset) | |
| dateTimeOffset.Mikroszekundum | DATEPART(mikroszekundum, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Ezredmásodperc | DATEPART(ezredmásodperc, @dateTimeOffset) | |
| dateTimeOffset.Minute | DATEPART(perc, @dateTimeOffset) | |
| dateTimeOffset.Month | DATEPART(hónap, @dateTimeOffset) | |
| dateTimeOffset.Nanosecond | DATEPART(nanosecond, @dateTimeOffset) % 1000 | EF Core 10.0 |
| dateTimeOffset.Second | DATEPART(másodperc, @dateTimeOffset) | |
| dateTimeOffset.TimeOfDay | KONVERTÁLÁS(idő, @dateTimeOffset) | |
| dateTimeOffset.ToUnixTimeSeconds() | DATEDIFF_BIG(másodperc, '1970-01-01T00:00:00.000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.ToUnixTimeMilliseconds() | DATEDIFF_BIG(milliszekundum, '1970-01-01T00:00:00.0000000+00:00', @dateTimeOffset) | |
| dateTimeOffset.Year | DATEPART(év, @dateTimeOffset) | |
| DateOnly.FromDateTime(dateTime) | KONVERT(dátum, @dateTime) | |
| dateOnly.AddDays(érték) | DATEADD(nap, @value, @dateOnly) | |
| dateOnly.AddMonths(hónapok) | DATEADD(month, @months, @dateOnly)) | |
| dateOnly.AddYears(value) | DATEADD(év, @value, @dateOnly) | |
| csakDátum.nap | DÁTUMRÉSZ(nap, @dateOnly) | |
| dateOnly.DayOfYear | DATEPART(évnapja, @dateOnly) | |
| dateOnly.Hónap | DATEPART(hónap, @dateOnly) | |
| dateOnly.Év | DATEPART(év, @dateOnly) | |
| dateOnly.DayNumber | DATEDIFF(nap, '0001-01-01', @dateOnly) | EF Core 10.0 |
| EF. Functions.AtTimeZone(dateTime, timeZone) | @dateTime AZ IDŐZÓNÁBAN @timeZone | |
| EF. Functions.DateDiffDay(start, end) | DATEDIFF(nap, @start, @end) | |
| EF.Functions.DateDiffHour(start, end) | DATEDIFF(óra, @start, @end) | |
| EF.Functions.DateDiffMicrosecond(start, end) | DATEDIFF(mikroszekundum, @start, @end) | |
| EF.Functions.DateDiffMillisecond(start, end) | DATEDIFF(milliszekundum, @start, @end) | |
| EF.Functions.DateDiffMinute(kezdet, vég) | DATEDIFF(perc, @start, @d2) | |
| EF.Funkciók.DateDiffMonth(kezdet, vég) | DATEDIFF(hónap, @start, @end) | |
| EF.Functions.DateDiffNanosecond(kezdet, vég) | DATEDIFF(nanosecond, @start, @end) | |
| EF.Functions.DateDiffSecond(start, end) | DATEDIFF(másodperc, @start, @end) | |
| EF.Functions.DateDiffWeek(kezdete, vége) | DATEDIFF(hét, @start, @end)) | |
| EF.Functions.DateDiffÉv(szülő, vég) | DATEDIFF(év, @start, @end) | |
| EF.Functions.DateFromParts(év, hónap, nap) | DATEFROMPARTS(@year, @month, @day) | |
| EF.Functions.DateTime2FromParts(év, hónap, nap, ...) | DATETIME2FROMPARTS(@year; @month; @day...) | |
| EF.Functions.DateTimeFromParts(év, hónap, nap, ...) | DATETIMEFROMPARTS(@year; @month; @day; ...) | |
| EF.Functions.DateTimeOffsetFromParts(év, hónap, nap, ...) | DATETIMEOFFSETFROMPARTS(@year; @month; @day; ...) | |
| EF.Functions.IsDate(kifejezés) | ISDATE(@expression) | |
| EF.Functions.SmallDateTimeFromParts(év, hónap, nap, ...) | SMALLDATETIMEFROMPARTS(@year; @month; @day; ...) | |
| EF.Functions.TimeFromParts(óra, perc, másodperc, ...) | TIMEFROMPARTS(@hour; @minute; @second; ...) | |
| timeOnly.AddHours(value) | DATEADD(óra, @value, @timeOnly) | |
| timeOnly.HozzáadPercet(érték) | DATEADD(perc, @value, @timeOnly) | |
| időCsak.Óra | DATEPART(óra, @timeOnly) | |
| timeOnly.IsKözöttVan(kezdet, vég) | @timeOnly >= @start ÉS @timeOnly<@end | |
| timeOnly.Microsecond | DATEPART(mikroszekundum, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Ezredmásodperc | DATEPART(ezredmásodperc, @timeOnly) | |
| timeOnly.Minute | DATEPART(perc, @timeOnly) | |
| timeOnly.Nanoszekundum | DATEPART(nanosecond, @timeOnly) % 1000 | EF Core 10.0 |
| timeOnly.Second | DATEPART(másodperc, @timeOnly) | |
| időtartam.Órák | DATEPART(óra, @timeSpan) | |
| timeSpan.Mikroszekundum | DATEPART(mikroszekundum, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.Milliszekundum | DATEPART(ezredmásodperc, @timeSpan) | |
| timeSpan.Minutes | DATEPART(perc, @timeSpan) | |
| timeSpan.Nanoszekundum | DATEPART(nanosecond, @timeSpan) % 1000 | EF Core 10.0 |
| timeSpan.másodpercek | DATEPART(másodperc, @timeSpan) |
Numerikus függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| double.FokokRadiánba(x) | RADIANS(@x) | |
| double.RadiansToDegrees(x) | FOK(@x) | |
| EF.Functions.Random() | RAND() | |
| Math.Abs(érték) | ABS(@érték) | |
| 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) | MENNYEZET(@d) | |
| Math.Cos(d) | COS(@d) | |
| Math.Exp(d) | EXP(@d) | |
| Math.Floor(d) | PADLÓ(@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) | KEREK(@d; 0) | |
| Math.Round(d, tizedesjegyek) | KEREK(@d, @decimals) | |
| Math.Sign(érték) | SIGN(@value) | |
| Math.Sin(a) | SIN(@a) | |
| Math.Sqrt(d) | SQRT(@d) | |
| Math.Tan(a) | TAN(@a) | |
| Math.Truncate(d) | KEREK(@d, 0, 1) |
Borravaló
Az itt felsorolt módszerek mellett a megfelelő általános matematikai implementációkat és MathF metódusokat is lefordítjuk. Például a Math.Sin, MathF.Sin, double.Sinés float.Sin mind az SQL SIN függvényére való leképezést jelentik.
Karakterlánc függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| EF.Functions.Collate(operandus, kolláció) | @operand KIEGÉSZÍT @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) | SZABADSZÖVEG(@propertyReference, @freeText) | |
| EF.Functions.FreeText(propertyReference, freeText, languageTerm) | SZABADSZÖVEG(@propertyReference, @freeText, NYELV @languageTerm) | |
| EF.Functions.IsNumeric(kifejezés) | ISNUMERIC(@expression) | |
| EF.Functions.Like(matchExpression, pattern) | @matchExpression SZERET @pattern | |
| EF.Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression MINT @pattern KIMENEKÍTÉS @escapeCharacter | |
| sztring.Compare(strA, strB) | ESET AMIKOR @strA = @strB AKKOR 0 ... END | |
| karakterlánc.Concat(str0, str1) | @str0 + @str1 | |
| string.IsNullOrEmpty(value) | @value NULL VAGY @value LIKE N'' | |
| sztring.IsNullOrWhiteSpace(érték) | @value NULLA VAGY @value = N'' | |
| Szöveg.Csatlakozás(", ", new [] { x, y, z}) | CONCAT_WS(N", ", @x, @y, @z) | EF Core 9.0 |
| stringValue.CompareTo(strB) | ESET AMIKOR @stringValue = @strB AKKOR 0 ... END | |
| stringValue.Contains(value) | @stringValue LIKE N'%' + @value + N'%' | |
| stringValue.EndsWith(value) | @stringValue LIKE N'%' + @value | |
| stringValue.FirstOrDefault() | RÉSZLET(@stringValue, 1, 1) | |
| stringValue.IndexOf(value) | CHARINDEX(@value, @stringValue) – 1 | |
| stringValue.IndexOf(érték, 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, 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) |
Egyéb függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| enumValue.HasFlag(flag) | @enumValue & @flag = @flag | |
| Guid.NewGuid() | NEWID() | |
| nullable.GetValueOrDefault() | COALESCE(@nullable, 0) | |
| Null-értékellhető.GetValueOrDefault(alapértelmezettÉrték) | COALESCE(@nullable, @defaultValue) |
Jegyzet
Néhány SQL-fordítást egyszerűsítettek illusztrációs célokra. A tényleges SQL összetettebb az értékek szélesebb körének kezeléséhez.
Lásd még:
- Vektorkeresési függvény leképezései
- Teljes szöveges keresési függvényleképezések
- térbeli függvényleképezések
- HierarchyId-függvényleképezések
Dolgozzon együtt velünk a GitHubon
A tartalom forrása a GitHubon található, ahol létrehozhat és áttekinthet problémákat és lekéréses kérelmeket is. További információért tekintse meg a közreműködői útmutatónkat.
