More test cleanup, formatting, organization

LucDeCaf · LucDeCaf · commit 54d46c0f5bd9 · 2026-01-21T17:20:15.000+02:00
diff --git a/PowerSync/PowerSync.Common/Client/PowerSyncDatabase.cs b/PowerSync/PowerSync.Common/Client/PowerSyncDatabase.cs
@@ -63,15 +63,12 @@ public interface IPowerSyncDatabase : IEventStream<PowerSyncDBEvent>
     Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parameters = null);
 
     Task<T[]> GetAll<T>(string sql, object?[]? parameters = null);
-
-    Task<T?> GetOptional<T>(string sql, object?[]? parameters = null);
-
-    Task<T> Get<T>(string sql, object?[]? parameters = null);
-
     Task<dynamic[]> GetAll(string sql, object?[]? parameters = null);
 
+    Task<T?> GetOptional<T>(string sql, object?[]? parameters = null);
     Task<dynamic?> GetOptional(string sql, object?[]? parameters = null);
 
+    Task<T> Get<T>(string sql, object?[]? parameters = null);
     Task<dynamic> Get(string sql, object?[]? parameters = null);
 
     Task<T> ReadLock<T>(Func<ILockContext, Task<T>> fn, DBLockOptions? options = null);
@@ -474,7 +471,7 @@ public async Task<UploadQueueStats> GetUploadQueueStats(bool includeSize = false
     /// </summary>
     public async Task<CrudBatch?> GetCrudBatch(int limit = 100)
     {
-        var crudResult = await GetAll<CrudEntryJSON>($"SELECT id, tx_id AS TransactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT ?", [limit + 1]);
+        var crudResult = await GetAll<CrudEntryJSON>($"SELECT id, tx_id as transactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT ?", [limit + 1]);
 
         var all = crudResult.Select(CrudEntry.FromRow).ToList();
 
@@ -516,7 +513,7 @@ public async Task<UploadQueueStats> GetUploadQueueStats(bool includeSize = false
         return await ReadTransaction(async tx =>
         {
             var first = await tx.GetOptional<CrudEntryJSON>(
-            $"SELECT id, tx_id AS TransactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT 1");
+            $"SELECT id, tx_id AS transactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT 1");
 
             if (first == null)
             {
@@ -534,7 +531,7 @@ public async Task<UploadQueueStats> GetUploadQueueStats(bool includeSize = false
             else
             {
                 var result = await tx.GetAll<CrudEntryJSON>(
-                    $"SELECT id, tx_id AS TransactionId, data FROM {PSInternalTable.CRUD} WHERE tx_id = ? ORDER BY id ASC",
+                    $"SELECT id, tx_id as transactionId, data FROM {PSInternalTable.CRUD} WHERE tx_id = ? ORDER BY id ASC",
                     [txId]);
 
                 all = result.Select(CrudEntry.FromRow).ToList();
@@ -596,38 +593,40 @@ public async Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parame
         return await Database.ExecuteBatch(query, parameters);
     }
 
-    public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)
+    public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)
     {
         await WaitForReady();
-        return await Database.GetAll(query, parameters);
+        return await Database.GetAll<T>(query, parameters);
     }
 
-    public async Task<dynamic?> GetOptional(string query, object?[]? parameters = null)
+    public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)
     {
         await WaitForReady();
-        return await Database.GetOptional(query, parameters);
+        return await Database.GetAll(query, parameters);
     }
-    public async Task<dynamic> Get(string query, object?[]? parameters = null)
+
+    public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)
     {
         await WaitForReady();
-        return await Database.Get(query, parameters);
+        return await Database.GetOptional<T>(query, parameters);
     }
 
-    public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)
+    public async Task<dynamic?> GetOptional(string query, object?[]? parameters = null)
     {
         await WaitForReady();
-        return await Database.GetAll<T>(query, parameters);
+        return await Database.GetOptional(query, parameters);
     }
 
-    public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)
+    public async Task<T> Get<T>(string query, object?[]? parameters = null)
     {
         await WaitForReady();
-        return await Database.GetOptional<T>(query, parameters);
+        return await Database.Get<T>(query, parameters);
     }
-    public async Task<T> Get<T>(string query, object?[]? parameters = null)
+
+    public async Task<dynamic> Get(string query, object?[]? parameters = null)
     {
         await WaitForReady();
-        return await Database.Get<T>(query, parameters);
+        return await Database.Get(query, parameters);
     }
 
     public async Task<T> ReadLock<T>(Func<ILockContext, Task<T>> fn, DBLockOptions? options = null)
diff --git a/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteAdapter.cs b/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteAdapter.cs
@@ -154,34 +154,34 @@ public async Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parame
         return await WriteTransaction((ctx) => ctx.ExecuteBatch(query, parameters));
     }
 
-    public async Task<T> Get<T>(string sql, object?[]? parameters = null)
+    public async Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)
     {
-        return await ReadLock((ctx) => ctx.Get<T>(sql, parameters));
+        return await ReadLock((ctx) => ctx.GetAll<T>(sql, parameters));
     }
 
-    public async Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)
+    public async Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)
     {
-        return await ReadLock((ctx) => ctx.GetAll<T>(sql, parameters));
+        return await ReadLock((ctx) => ctx.GetAll(sql, parameters));
     }
 
     public async Task<T?> GetOptional<T>(string sql, object?[]? parameters = null)
     {
         return await ReadLock((ctx) => ctx.GetOptional<T>(sql, parameters));
     }
 
-    public async Task<dynamic> Get(string sql, object?[]? parameters = null)
+    public async Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)
     {
-        return await ReadLock((ctx) => ctx.Get(sql, parameters));
+        return await ReadLock((ctx) => ctx.GetOptional(sql, parameters));
     }
 
-    public async Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)
+    public async Task<T> Get<T>(string sql, object?[]? parameters = null)
     {
-        return await ReadLock((ctx) => ctx.GetAll(sql, parameters));
+        return await ReadLock((ctx) => ctx.Get<T>(sql, parameters));
     }
 
-    public async Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)
+    public async Task<dynamic> Get(string sql, object?[]? parameters = null)
     {
-        return await ReadLock((ctx) => ctx.GetOptional(sql, parameters));
+        return await ReadLock((ctx) => ctx.Get(sql, parameters));
     }
 
     public async Task<T> ReadTransaction<T>(Func<ITransaction, Task<T>> fn, DBLockOptions? options = null)
@@ -325,33 +325,33 @@ public Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parameters =
         return connection.ExecuteBatch(query, parameters);
     }
 
-    public Task<T> Get<T>(string sql, object?[]? parameters = null)
+    public Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)
     {
-        return connection.Get<T>(sql, parameters);
+        return connection.GetAll<T>(sql, parameters);
     }
 
-    public Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)
+    public Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)
     {
-        return connection.GetAll<T>(sql, parameters);
+        return connection.GetAll(sql, parameters);
     }
 
     public Task<T?> GetOptional<T>(string sql, object?[]? parameters = null)
     {
         return connection.GetOptional<T>(sql, parameters);
     }
 
-    public Task<dynamic> Get(string sql, object?[]? parameters = null)
+    public Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)
     {
-        return connection.Get(sql, parameters);
+        return connection.GetOptional(sql, parameters);
     }
 
-    public Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)
+    public Task<T> Get<T>(string sql, object?[]? parameters = null)
     {
-        return connection.GetAll(sql, parameters);
+        return connection.Get<T>(sql, parameters);
     }
 
-    public Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)
+    public Task<dynamic> Get(string sql, object?[]? parameters = null)
     {
-        return connection.GetOptional(sql, parameters);
+        return connection.Get(sql, parameters);
     }
 }
diff --git a/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteConnection.cs b/PowerSync/PowerSync.Common/MDSQLite/MDSQLiteConnection.cs
@@ -160,28 +160,28 @@ private static List<string> PrepareQueryString(ref string query, int parameterCo
         return dynamicParamsList;
     }
 
-    public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)
+    public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)
     {
         DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);
-        return dynamicParams == null
-            ? await Db.QueryFirstOrDefaultAsync<T>(query, commandType: CommandType.Text)
-            : await Db.QueryFirstOrDefaultAsync<T>(query, dynamicParams, commandType: CommandType.Text);
+        return [..dynamicParams == null
+            ? await Db.QueryAsync<T>(query, commandType: CommandType.Text)
+            : await Db.QueryAsync<T>(query, dynamicParams, commandType: CommandType.Text)];
     }
 
-    public async Task<T> Get<T>(string query, object?[]? parameters = null)
+    public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)
     {
         DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);
-        return dynamicParams == null
-            ? await Db.QueryFirstAsync<T>(query, commandType: CommandType.Text)
-            : await Db.QueryFirstAsync<T>(query, dynamicParams, commandType: CommandType.Text);
+        return [..dynamicParams == null
+            ? await Db.QueryAsync(query, commandType: CommandType.Text)
+            : await Db.QueryAsync(query, dynamicParams, commandType: CommandType.Text)];
     }
 
-    public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)
+    public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)
     {
         DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);
-        return [..dynamicParams == null
-            ? await Db.QueryAsync<T>(query, commandType: CommandType.Text)
-            : await Db.QueryAsync<T>(query, dynamicParams, commandType: CommandType.Text)];
+        return dynamicParams == null
+            ? await Db.QueryFirstOrDefaultAsync<T>(query, commandType: CommandType.Text)
+            : await Db.QueryFirstOrDefaultAsync<T>(query, dynamicParams, commandType: CommandType.Text);
     }
 
     public async Task<dynamic?> GetOptional(string query, object?[]? parameters = null)
@@ -192,20 +192,20 @@ public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)
             : await Db.QueryFirstOrDefaultAsync(query, dynamicParams, commandType: CommandType.Text);
     }
 
-    public async Task<dynamic> Get(string query, object?[]? parameters = null)
+    public async Task<T> Get<T>(string query, object?[]? parameters = null)
     {
         DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);
         return dynamicParams == null
-            ? await Db.QueryFirstAsync(query, commandType: CommandType.Text)
-            : await Db.QueryFirstAsync(query, dynamicParams, commandType: CommandType.Text);
+            ? await Db.QueryFirstAsync<T>(query, commandType: CommandType.Text)
+            : await Db.QueryFirstAsync<T>(query, dynamicParams, commandType: CommandType.Text);
     }
 
-    public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)
+    public async Task<dynamic> Get(string query, object?[]? parameters = null)
     {
         DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);
-        return [..dynamicParams == null
-            ? await Db.QueryAsync(query, commandType: CommandType.Text)
-            : await Db.QueryAsync(query, dynamicParams, commandType: CommandType.Text)];
+        return dynamicParams == null
+            ? await Db.QueryFirstAsync(query, commandType: CommandType.Text)
+            : await Db.QueryFirstAsync(query, dynamicParams, commandType: CommandType.Text);
     }
 
     public async Task<NonQueryResult> Execute(string query, object?[]? parameters = null)
diff --git a/Tests/PowerSync/PowerSync.Common.Tests/Client/Sync/CRUDTests.cs b/Tests/PowerSync/PowerSync.Common.Tests/Client/Sync/CRUDTests.cs

Original file line number	Diff line number	Diff line change
`@@ -63,15 +63,12 @@ public interface IPowerSyncDatabase : IEventStream<PowerSyncDBEvent>`
`63`	`63`	`Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parameters = null);`
`64`	`64`
`65`	`65`	`Task<T[]> GetAll<T>(string sql, object?[]? parameters = null);`
`66`		`-`
`67`		`- Task<T?> GetOptional<T>(string sql, object?[]? parameters = null);`
`68`		`-`
`69`		`- Task<T> Get<T>(string sql, object?[]? parameters = null);`
`70`		`-`
`71`	`66`	`Task<dynamic[]> GetAll(string sql, object?[]? parameters = null);`
`72`	`67`
	`68`	`+ Task<T?> GetOptional<T>(string sql, object?[]? parameters = null);`
`73`	`69`	`Task<dynamic?> GetOptional(string sql, object?[]? parameters = null);`
`74`	`70`
	`71`	`+ Task<T> Get<T>(string sql, object?[]? parameters = null);`
`75`	`72`	`Task<dynamic> Get(string sql, object?[]? parameters = null);`
`76`	`73`
`77`	`74`	`Task<T> ReadLock<T>(Func<ILockContext, Task<T>> fn, DBLockOptions? options = null);`
`@@ -474,7 +471,7 @@ public async Task<UploadQueueStats> GetUploadQueueStats(bool includeSize = false`
`474`	`471`	`/// </summary>`
`475`	`472`	`public async Task<CrudBatch?> GetCrudBatch(int limit = 100)`
`476`	`473`	`{`
`477`		`- var crudResult = await GetAll<CrudEntryJSON>($"SELECT id, tx_id AS TransactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT ?", [limit + 1]);`
	`474`	`+ var crudResult = await GetAll<CrudEntryJSON>($"SELECT id, tx_id as transactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT ?", [limit + 1]);`
`478`	`475`
`479`	`476`	`var all = crudResult.Select(CrudEntry.FromRow).ToList();`
`480`	`477`
`@@ -516,7 +513,7 @@ public async Task<UploadQueueStats> GetUploadQueueStats(bool includeSize = false`
`516`	`513`	`return await ReadTransaction(async tx =>`
`517`	`514`	`{`
`518`	`515`	`var first = await tx.GetOptional<CrudEntryJSON>(`
`519`		`- $"SELECT id, tx_id AS TransactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT 1");`
	`516`	`+ $"SELECT id, tx_id AS transactionId, data FROM {PSInternalTable.CRUD} ORDER BY id ASC LIMIT 1");`
`520`	`517`
`521`	`518`	`if (first == null)`
`522`	`519`	`{`
`@@ -534,7 +531,7 @@ public async Task<UploadQueueStats> GetUploadQueueStats(bool includeSize = false`
`534`	`531`	`else`
`535`	`532`	`{`
`536`	`533`	`var result = await tx.GetAll<CrudEntryJSON>(`
`537`		`- $"SELECT id, tx_id AS TransactionId, data FROM {PSInternalTable.CRUD} WHERE tx_id = ? ORDER BY id ASC",`
	`534`	`+ $"SELECT id, tx_id as transactionId, data FROM {PSInternalTable.CRUD} WHERE tx_id = ? ORDER BY id ASC",`
`538`	`535`	`[txId]);`
`539`	`536`
`540`	`537`	`all = result.Select(CrudEntry.FromRow).ToList();`
`@@ -596,38 +593,40 @@ public async Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parame`
`596`	`593`	`return await Database.ExecuteBatch(query, parameters);`
`597`	`594`	`}`
`598`	`595`
`599`		`- public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)`
	`596`	`+ public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)`
`600`	`597`	`{`
`601`	`598`	`await WaitForReady();`
`602`		`- return await Database.GetAll(query, parameters);`
	`599`	`+ return await Database.GetAll<T>(query, parameters);`
`603`	`600`	`}`
`604`	`601`
`605`		`- public async Task<dynamic?> GetOptional(string query, object?[]? parameters = null)`
	`602`	`+ public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)`
`606`	`603`	`{`
`607`	`604`	`await WaitForReady();`
`608`		`- return await Database.GetOptional(query, parameters);`
	`605`	`+ return await Database.GetAll(query, parameters);`
`609`	`606`	`}`
`610`		`- public async Task<dynamic> Get(string query, object?[]? parameters = null)`
	`607`	`+`
	`608`	`+ public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)`
`611`	`609`	`{`
`612`	`610`	`await WaitForReady();`
`613`		`- return await Database.Get(query, parameters);`
	`611`	`+ return await Database.GetOptional<T>(query, parameters);`
`614`	`612`	`}`
`615`	`613`
`616`		`- public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)`
	`614`	`+ public async Task<dynamic?> GetOptional(string query, object?[]? parameters = null)`
`617`	`615`	`{`
`618`	`616`	`await WaitForReady();`
`619`		`- return await Database.GetAll<T>(query, parameters);`
	`617`	`+ return await Database.GetOptional(query, parameters);`
`620`	`618`	`}`
`621`	`619`
`622`		`- public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)`
	`620`	`+ public async Task<T> Get<T>(string query, object?[]? parameters = null)`
`623`	`621`	`{`
`624`	`622`	`await WaitForReady();`
`625`		`- return await Database.GetOptional<T>(query, parameters);`
	`623`	`+ return await Database.Get<T>(query, parameters);`
`626`	`624`	`}`
`627`		`- public async Task<T> Get<T>(string query, object?[]? parameters = null)`
	`625`	`+`
	`626`	`+ public async Task<dynamic> Get(string query, object?[]? parameters = null)`
`628`	`627`	`{`
`629`	`628`	`await WaitForReady();`
`630`		`- return await Database.Get<T>(query, parameters);`
	`629`	`+ return await Database.Get(query, parameters);`
`631`	`630`	`}`
`632`	`631`
`633`	`632`	`public async Task<T> ReadLock<T>(Func<ILockContext, Task<T>> fn, DBLockOptions? options = null)`
Original file line number	Diff line number	Diff line change
`@@ -154,34 +154,34 @@ public async Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parame`
`154`	`154`	`return await WriteTransaction((ctx) => ctx.ExecuteBatch(query, parameters));`
`155`	`155`	`}`
`156`	`156`
`157`		`- public async Task<T> Get<T>(string sql, object?[]? parameters = null)`
	`157`	`+ public async Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)`
`158`	`158`	`{`
`159`		`- return await ReadLock((ctx) => ctx.Get<T>(sql, parameters));`
	`159`	`+ return await ReadLock((ctx) => ctx.GetAll<T>(sql, parameters));`
`160`	`160`	`}`
`161`	`161`
`162`		`- public async Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)`
	`162`	`+ public async Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)`
`163`	`163`	`{`
`164`		`- return await ReadLock((ctx) => ctx.GetAll<T>(sql, parameters));`
	`164`	`+ return await ReadLock((ctx) => ctx.GetAll(sql, parameters));`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`public async Task<T?> GetOptional<T>(string sql, object?[]? parameters = null)`
`168`	`168`	`{`
`169`	`169`	`return await ReadLock((ctx) => ctx.GetOptional<T>(sql, parameters));`
`170`	`170`	`}`
`171`	`171`
`172`		`- public async Task<dynamic> Get(string sql, object?[]? parameters = null)`
	`172`	`+ public async Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)`
`173`	`173`	`{`
`174`		`- return await ReadLock((ctx) => ctx.Get(sql, parameters));`
	`174`	`+ return await ReadLock((ctx) => ctx.GetOptional(sql, parameters));`
`175`	`175`	`}`
`176`	`176`
`177`		`- public async Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)`
	`177`	`+ public async Task<T> Get<T>(string sql, object?[]? parameters = null)`
`178`	`178`	`{`
`179`		`- return await ReadLock((ctx) => ctx.GetAll(sql, parameters));`
	`179`	`+ return await ReadLock((ctx) => ctx.Get<T>(sql, parameters));`
`180`	`180`	`}`
`181`	`181`
`182`		`- public async Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)`
	`182`	`+ public async Task<dynamic> Get(string sql, object?[]? parameters = null)`
`183`	`183`	`{`
`184`		`- return await ReadLock((ctx) => ctx.GetOptional(sql, parameters));`
	`184`	`+ return await ReadLock((ctx) => ctx.Get(sql, parameters));`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`public async Task<T> ReadTransaction<T>(Func<ITransaction, Task<T>> fn, DBLockOptions? options = null)`
`@@ -325,33 +325,33 @@ public Task<NonQueryResult> ExecuteBatch(string query, object?[][]? parameters =`
`325`	`325`	`return connection.ExecuteBatch(query, parameters);`
`326`	`326`	`}`
`327`	`327`
`328`		`- public Task<T> Get<T>(string sql, object?[]? parameters = null)`
	`328`	`+ public Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)`
`329`	`329`	`{`
`330`		`- return connection.Get<T>(sql, parameters);`
	`330`	`+ return connection.GetAll<T>(sql, parameters);`
`331`	`331`	`}`
`332`	`332`
`333`		`- public Task<T[]> GetAll<T>(string sql, object?[]? parameters = null)`
	`333`	`+ public Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)`
`334`	`334`	`{`
`335`		`- return connection.GetAll<T>(sql, parameters);`
	`335`	`+ return connection.GetAll(sql, parameters);`
`336`	`336`	`}`
`337`	`337`
`338`	`338`	`public Task<T?> GetOptional<T>(string sql, object?[]? parameters = null)`
`339`	`339`	`{`
`340`	`340`	`return connection.GetOptional<T>(sql, parameters);`
`341`	`341`	`}`
`342`	`342`
`343`		`- public Task<dynamic> Get(string sql, object?[]? parameters = null)`
	`343`	`+ public Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)`
`344`	`344`	`{`
`345`		`- return connection.Get(sql, parameters);`
	`345`	`+ return connection.GetOptional(sql, parameters);`
`346`	`346`	`}`
`347`	`347`
`348`		`- public Task<dynamic[]> GetAll(string sql, object?[]? parameters = null)`
	`348`	`+ public Task<T> Get<T>(string sql, object?[]? parameters = null)`
`349`	`349`	`{`
`350`		`- return connection.GetAll(sql, parameters);`
	`350`	`+ return connection.Get<T>(sql, parameters);`
`351`	`351`	`}`
`352`	`352`
`353`		`- public Task<dynamic?> GetOptional(string sql, object?[]? parameters = null)`
	`353`	`+ public Task<dynamic> Get(string sql, object?[]? parameters = null)`
`354`	`354`	`{`
`355`		`- return connection.GetOptional(sql, parameters);`
	`355`	`+ return connection.Get(sql, parameters);`
`356`	`356`	`}`
`357`	`357`	`}`
Original file line number	Diff line number	Diff line change
`@@ -160,28 +160,28 @@ private static List<string> PrepareQueryString(ref string query, int parameterCo`
`160`	`160`	`return dynamicParamsList;`
`161`	`161`	`}`
`162`	`162`
`163`		`- public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)`
	`163`	`+ public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)`
`164`	`164`	`{`
`165`	`165`	`DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);`
`166`		`- return dynamicParams == null`
`167`		`- ? await Db.QueryFirstOrDefaultAsync<T>(query, commandType: CommandType.Text)`
`168`		`- : await Db.QueryFirstOrDefaultAsync<T>(query, dynamicParams, commandType: CommandType.Text);`
	`166`	`+ return [..dynamicParams == null`
	`167`	`+ ? await Db.QueryAsync<T>(query, commandType: CommandType.Text)`
	`168`	`+ : await Db.QueryAsync<T>(query, dynamicParams, commandType: CommandType.Text)];`
`169`	`169`	`}`
`170`	`170`
`171`		`- public async Task<T> Get<T>(string query, object?[]? parameters = null)`
	`171`	`+ public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)`
`172`	`172`	`{`
`173`	`173`	`DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);`
`174`		`- return dynamicParams == null`
`175`		`- ? await Db.QueryFirstAsync<T>(query, commandType: CommandType.Text)`
`176`		`- : await Db.QueryFirstAsync<T>(query, dynamicParams, commandType: CommandType.Text);`
	`174`	`+ return [..dynamicParams == null`
	`175`	`+ ? await Db.QueryAsync(query, commandType: CommandType.Text)`
	`176`	`+ : await Db.QueryAsync(query, dynamicParams, commandType: CommandType.Text)];`
`177`	`177`	`}`
`178`	`178`
`179`		`- public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)`
	`179`	`+ public async Task<T?> GetOptional<T>(string query, object?[]? parameters = null)`
`180`	`180`	`{`
`181`	`181`	`DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);`
`182`		`- return [..dynamicParams == null`
`183`		`- ? await Db.QueryAsync<T>(query, commandType: CommandType.Text)`
`184`		`- : await Db.QueryAsync<T>(query, dynamicParams, commandType: CommandType.Text)];`
	`182`	`+ return dynamicParams == null`
	`183`	`+ ? await Db.QueryFirstOrDefaultAsync<T>(query, commandType: CommandType.Text)`
	`184`	`+ : await Db.QueryFirstOrDefaultAsync<T>(query, dynamicParams, commandType: CommandType.Text);`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`public async Task<dynamic?> GetOptional(string query, object?[]? parameters = null)`
`@@ -192,20 +192,20 @@ public async Task<T[]> GetAll<T>(string query, object?[]? parameters = null)`
`192`	`192`	`: await Db.QueryFirstOrDefaultAsync(query, dynamicParams, commandType: CommandType.Text);`
`193`	`193`	`}`
`194`	`194`
`195`		`- public async Task<dynamic> Get(string query, object?[]? parameters = null)`
	`195`	`+ public async Task<T> Get<T>(string query, object?[]? parameters = null)`
`196`	`196`	`{`
`197`	`197`	`DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);`
`198`	`198`	`return dynamicParams == null`
`199`		`- ? await Db.QueryFirstAsync(query, commandType: CommandType.Text)`
`200`		`- : await Db.QueryFirstAsync(query, dynamicParams, commandType: CommandType.Text);`
	`199`	`+ ? await Db.QueryFirstAsync<T>(query, commandType: CommandType.Text)`
	`200`	`+ : await Db.QueryFirstAsync<T>(query, dynamicParams, commandType: CommandType.Text);`
`201`	`201`	`}`
`202`	`202`
`203`		`- public async Task<dynamic[]> GetAll(string query, object?[]? parameters = null)`
	`203`	`+ public async Task<dynamic> Get(string query, object?[]? parameters = null)`
`204`	`204`	`{`
`205`	`205`	`DynamicParameters? dynamicParams = PrepareQuery(ref query, parameters);`
`206`		`- return [..dynamicParams == null`
`207`		`- ? await Db.QueryAsync(query, commandType: CommandType.Text)`
`208`		`- : await Db.QueryAsync(query, dynamicParams, commandType: CommandType.Text)];`
	`206`	`+ return dynamicParams == null`
	`207`	`+ ? await Db.QueryFirstAsync(query, commandType: CommandType.Text)`
	`208`	`+ : await Db.QueryFirstAsync(query, dynamicParams, commandType: CommandType.Text);`
`209`	`209`	`}`
`210`	`210`
`211`	`211`	`public async Task<NonQueryResult> Execute(string query, object?[]? parameters = null)`