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 bemutatja, hogy a .NET tagok hogyan fordítódnak le SQL függvényekre az SQLite szolgáltató használatakor.
Összesítő függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| csoport.Átlag(x => x.Tulajdonság) | AVG(tulajdonság) | |
| csoport.átlag(x => x.DecimalProperty) | ef_avg(DecimalProperty) | EF Core 9.0 |
| csoport. Darabszám() | DARAB(*) | |
| csoport. LongCount() | DARAB(*) | |
| 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) | |
| csoport.Sum(x => x.DecimalProperty) | ef_sum(DecimalProperty) | EF Core 9.0 |
| karakterlánc.Concat(csoport.Select(x => x.Property)) | group_concat(Tulajdonság; '') | |
| string.Join(elválasztó, csoport.Select(x => x.Property)) | group_concat(Tulajdonság, @separator)) |
Bináris függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| bytes.Contains(érték) | instr(@bytes; char(@value)) > 0 | |
| Bájt. Hosszúság | hossz(@bytes) | |
| bytes.SequenceEqual(second) | @bytes = @second | |
| EF.Functions.Hex(bytes) | hexa(@bytes) | |
| EF. Functions.Substr(bájt; startIndex) | substr(@bytes, @startIndex) | |
| EF. Functions.Substr(bájt, startIndex, hossz) | substr(@bytes, @startIndex, @length) | |
| EF.Functions.Unhex(érték) | unhex(@value) | |
| EF.Functions.Unhex(érték, ignoráltKarakterek) | unhex(@value, @ignoreChars) |
Konverziós függvények
| .NET | SQL |
|---|---|
| boolValue.ToString() | CAST(@boolValue AS TEXT) |
| byteValue.ToString() | CAST(@byteValue AS TEXT) |
| bytes.ToString() | Az SQL utasítás: CAST(@bytes AS TEXT) konvertálja a bájtokat szöveggé. |
| charValue.ToString() | CAST(@charValue AS TEXT) |
| dateTime.ToString() | CAST(@dateTime AS TEXT) |
| dateTimeOffset.ToString() | CAST(@dateTimeOffset AS TEXT) |
| decimalValue.ToString() | CAST(@decimalValue AS TEXT) |
| doubleValue.ToString() | CAST(@doubleValue AS TEXT) |
| floatValue.ToString() | CAST(@floatValue AS TEXT) |
| guid.ToString() | CAST(@guid AS TEXT) |
| intValue.ToString() | CAST(@intValue AS TEXT) |
| longValue.ToString() | CAST(@longValue AS TEXT) |
| sbyteValue.ToString() | CAST(@sbyteValue AS TEXT) |
| shortValue.ToString() | CAST(@shortValue AS TEXT) |
| timeSpan.ToString() | CAST(@timeSpan AS TEXT) |
| uintValue.ToString() | CAST(@uintValue AS TEXT) |
| ushortValue.ToString() | CAST(@ushortValue AS TEXT) |
Dátum- és időfüggvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| dateOnly.AddDays(érték) | date(@dateOnly, @value || ' napok') | |
| dateOnly.AddMonths(hónapok) | date(@dateOnly, @months || " hónapok") | |
| dateOnly.AddYears(value) | date(@dateOnly; @value || ' évek') | |
| csakDátum.nap | strftime('%d", @dateOnly) | |
| csakDátum.HétNapja | strftime('%w", @dateOnly) | |
| dateOnly.DayOfYear | strftime('%j", @dateOnly) | |
| DateOnly.FromDateTime(dateTime) | date(@dateTime) | |
| dateOnly.Hónap | strftime('%m", @dateOnly) | |
| dateOnly.Év | strftime('%Y", @dateOnly) | |
| dateOnly.DayNumber | CAST(julianday(@dateOnly) - julianday('0001-01-01') AS INTEGER) | EF Core 10.0 |
| DateTime.Now | datetime('now', 'localtime') | |
| DateTime.Today | datetime('now', 'localtime', 'start of day') | |
| DateTime.UtcNow | datetime('now') | |
| dateTime.AddDays(érték) | datetime(@dateTime, @value || ' napok') | |
| dateTime.AddHours(value) | datetime(@dateTime, @d || ' óra') | |
| dateTime.AddMilliseconds(value) | datetime(@dateTime, (@value / 1000,0) || ' másodperc') | |
| dateTime.AddMinutes(érték) | datetime(@dateTime, @value || ' perc') | |
| dateTime.AddMonths(hónapok) | datetime(@dateTime, @months || ' hónapok') | |
| dateTime.AddSeconds(value) | datetime(@dateTime, @value || " másodperc") | |
| dateTime.AddTicks(érték) | datetime(@dateTime, (@value / 10000000.0) || ' másodperc') | |
| dateTime.AddYears(érték) | datetime(@dateTime, @value || ' év') | |
| dateTime.Date | datetime(@dateTime; "nap kezdete") | |
| dateTime.Day | strftime('%d", @dateTime) | |
| dateTime.DayOfWeek | strftime('%w", @dateTime) | |
| dateTime.DayOfYear | strftime('%j", @dateTime) | |
| dateTime.óra | strftime('%H", @dateTime) | |
| dateTime.Milliszekundum | (strftime('%f', @dateTime) * 1000) % 1000 | |
| dateTime.Minute | strftime('%M", @dateTime) | |
| dateTime.Hónap | strftime('%m", @dateTime) | |
| dateTime.Second | strftime('%S", @dateTime) | |
| dateTime.Ticks | (julianday(@dateTime) - julianday('0001-01-01 00:00:00')) * 86400000000 | |
| dateTime.TimeOfDay | time(@dateTime) | |
| dateTime.Year | strftime('%Y", @dateTime) |
Megjegyzés:
Néhány SQL-t egyszerűsítettünk illusztrációs célokra. A tényleges SQL összetettebb az értékek szélesebb körének kezeléséhez.
Numerikus függvények
| .NET | SQL | Hozzáadva |
|---|---|---|
| -decimalValue | ef_negate(@decimalValue) | |
| decimalValue – d | ef_add(@decimalValue, ef_negate(@d)) | |
| decimalValue * d | ef_multiply(@decimalValue, @d) | |
| decimalValue /d | ef_divide(@decimalValue, @d) | |
| decimalValue % d | ef_mod(@decimalValue, @d) | |
| decimalValue + d | ef_add(@decimalValue, @d) | |
| decimalValue < d | ef_compare(@decimalValue, @d)< 0 | |
| decimalValue <= d | ef_compare(@decimalValue; @d)<= 0 | |
| decimalValue > d | ef_compare(@decimalValue, @d)> 0 | |
| decimalValue >= d | ef_compare(@decimalValue; @d)>= 0 | |
| double.DegreesToRadians(fok) | radián(@degrees) | |
| Double.RadiansToDegrees(radián) | fok(@dradians) | |
| doubleValue % d | mod(@doubleValue, @d) | |
| EF.Functions.Random() | abs(random() / 922337203685478000.0) | |
| Math.Abs(érték) | abs(@value) | |
| Math.Acos(érték) | acos(@value) | |
| Math.Acosh(d) | acosh(@d) | |
| Math.Asin(d) | asin(@d) | |
| Math.Asinh(d) | asinh(@d) | |
| Math.Atan(d) | atan(@d) | |
| Math.Atan2(y; x) | atan2(@y, @x) | |
| Math.Atanh(d) | atanh(@d) | |
| Math.Ceiling(d) | plafon(@d) | |
| Math.Cos(d) | cos(@d) | |
| Math.Cosh(érték) | cosh(@value) | |
| Math.Exp(d) | exp(@d) | |
| Math.Floor(d) | padló(@d) | |
| Math.Log(d) | ln(@d) | EF Core 8.0 |
| Math.Log(a, newBase) | log(@newBase, @a) | EF Core 8.0 |
| Math.Log2(x) | log2(@x) | EF Core 8.0 |
| Math.Log10(d) | log10(@d) | EF Core 8.0 |
| Math.Max(val1; val2) | max(@val1, @val2) | |
| Math.Min(val1; val2) | min(@val1; @val2) | |
| Math.Pow(x; y) | pow(@x, @y) | EF Core 8.0 |
| Math.Round(d) | kerek(@d) | |
| Math.Round(d; számjegyek) | kerek(@d, @digits) | |
| Math.Sign(d) | sign(@d) | EF Core 8.0 |
| Math.Sin(a) | sin(@a) | EF Core 8.0 |
| Math.Sinh(érték) | sinh(@value) | EF Core 8.0 |
| Math.Sqrt(d) | sqrt(@d) | EF Core 8.0 |
| Math.Tan(a) | tan(@a) | EF Core 8.0 |
| Math.Tanh(érték) | tanh(@value) | EF Core 8.0 |
| Math.Truncate(d) | trunc(@d) | EF Core 8.0 |
Jótanács
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.
Jótanács
Az előtaggal ef_ ellátott SQL-függvényeket az EF Core hozza létre.
Karakterlánc függvények
| .NET | SQL |
|---|---|
| char.ToLower(c) | lower(@c) |
| char.ToUpper(c) | upper(@c) |
| EF.Functions.Collate(operandus, kolláció) | @operand KIEGÉSZÍT @collation |
| EF. Functions.Glob(matchExpression, pattern) | @matchExpression GLOB @pattern |
| EF. Functions.Like(matchExpression, pattern) | @matchExpression SZERET @pattern |
| EF. Functions.Like(matchExpression, pattern, escapeCharacter) | @matchExpression MINT @pattern KIMENEKÍTÉS @escapeCharacter |
| Regex.IsMatch(bemenet, minta) | @input REGEXP @pattern |
| húr. Compare(strA, strB) | ESET AMIKOR @strA = @strB AKKOR 0 ... END |
| karakterlánc.Concat(str0, str1) | @str0 || @str1 |
| string.IsNullOrEmpty(value) | @value NULL VAGY @value = '' |
| sztring.IsNullOrWhiteSpace(érték) | @value NULL VAGY levágás(@value) = '' |
| stringValue.CompareTo(strB) | ESET AMIKOR @stringValue = @strB AKKOR 0 ... END |
| stringValue.Contains(value) | instr(@stringValue, @value)> 0 |
| stringValue.EndsWith(value) | @stringValue LIKE '%' || @value |
| stringValue.FirstOrDefault() | substr(@stringValue, 1, 1) |
| stringValue.IndexOf(value) | instr(@stringValue, @value) - 1 |
| stringValue.LastOrDefault() | substr(@stringValue, length(@stringValue), 1) |
| stringValue.Length | hossz(@stringValue) |
| stringValue.Replace(oldValue, newValue) | replace(@stringValue, @oldValue, @newValue)) |
| stringValue.StartsWith(value) | @stringValue LIKE @value || '%' |
| stringValue.Substring(startIndex) | substr(@stringValue, @startIndex + 1) |
| stringValue.Substring(startIndex, length) | substr(@stringValue, @startIndex + 1, @length) |
| stringValue.ToLower() | lower(@stringValue) |
| stringValue.ToUpper() | upper(@stringValue) |
| stringValue.Trim() | levág(@stringValue) |
| stringValue.Trim(trimChar) | levágás(@stringValue, @trimChar) |
| stringValue.TrimEnd() | rtrim(@stringValue) // Eltávolítja a szóközöket a szöveg végéről |
| stringValue.TrimEnd(trimChar) | rtrim(@stringValue, @trimChar) |
| stringValue.TrimStart() | ltrim(@stringValue) |
| stringValue.TrimStart(trimChar) | ltrim(@stringValue, @trimChar) |
Megjegyzés:
Néhány SQL-t egyszerűsítettünk illusztrációs célokra. A tényleges SQL összetettebb az értékek szélesebb körének kezeléséhez.
Egyéb függvények
| .NET | SQL |
|---|---|
| gyűjtemény. Contains(item) | @item BAN @collection |
| enumValue.HasFlag(flag) | @enumValue & @flag = @flag |
| nullable.GetValueOrDefault() | coalesce(@nullable; 0) |
| Null-értékellhető.GetValueOrDefault(alapértelmezettÉrték) | coalesce(@nullable, @defaultValue) |
Lásd még
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.
