diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/misc/Expression.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/misc/Expression.kt
index 6ceca69..d7748b2 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/misc/Expression.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/misc/Expression.kt
@@ -1,7 +1,7 @@
 package ru.landgrafhomyak.serdha.api.v0.misc
 
-import ru.landgrafhomyak.serdha.api.v0.runtime.ParametersSetter
-import ru.landgrafhomyak.serdha.api.v0.runtime.Row
+import ru.landgrafhomyak.serdha.api.v0.runtime.InputRow
+import ru.landgrafhomyak.serdha.api.v0.runtime.OutputRow
 
 public interface Expression<ExpressionUserExtension : Any> {
 	public val userExtension: ExpressionUserExtension
@@ -36,6 +36,6 @@ public interface Expression<ExpressionUserExtension : Any> {
 	}
 
 	public interface Action<ExpressionUserExtension : Any> {
-		public fun calculate(input: Row<ExpressionUserExtension>, output: ParametersSetter<ExpressionUserExtension>)
+		public fun calculate(input: OutputRow<ExpressionUserExtension>, output: InputRow<ExpressionUserExtension>)
 	}
 }
\ No newline at end of file
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/DeleteQuery.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/DeleteQuery.kt
index 35de920..f91f73a 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/DeleteQuery.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/DeleteQuery.kt
@@ -4,7 +4,7 @@ import ru.landgrafhomyak.serdha.api.v0.misc.Column
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseType
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseTypesProvider
 import ru.landgrafhomyak.serdha.api.v0.misc.QueryParam
-import ru.landgrafhomyak.serdha.api.v0.runtime.ParametersSetter
+import ru.landgrafhomyak.serdha.api.v0.runtime.InputRow
 import ru.landgrafhomyak.serdha.api.v0.table.Table
 
 public interface DeleteQuery<QueryUserExtension : Any> : _Query<QueryUserExtension> {
@@ -16,7 +16,7 @@ public interface DeleteQuery<QueryUserExtension : Any> : _Query<QueryUserExtensi
 				public val types: DatabaseTypesProvider
 				public fun <RT, DT : DatabaseType<RT>> param(name: String, type: DT): QueryParam<RT, DT, QueryUserExtension>
 
-				public val selectorParams: ParametersSetter.WithRedirect<SelectorTableUserExtension, QueryUserExtension>
+				public val selectorParams: InputRow.WithRedirect<SelectorTableUserExtension, QueryUserExtension>
 				public var selectorColumn: Column<*, DatabaseType.ROW_ID<TargetTableUserExtension>, SelectorTableUserExtension>
 
 				public fun <RT, DT : DatabaseType<RT>> returnFromSubquery(name: String, column: Column<RT, DT, SelectorTableUserExtension>): Column<RT, DT, QueryUserExtension>
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/InsertQuery.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/InsertQuery.kt
index 0bbc142..6a5dddf 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/InsertQuery.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/InsertQuery.kt
@@ -5,7 +5,7 @@ import ru.landgrafhomyak.serdha.api.v0.table.Table
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseType
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseTypesProvider
 import ru.landgrafhomyak.serdha.api.v0.misc.QueryParam
-import ru.landgrafhomyak.serdha.api.v0.runtime.ParametersSetter
+import ru.landgrafhomyak.serdha.api.v0.runtime.InputRow
 import ru.landgrafhomyak.serdha.api.v0.table.UniqueIndex
 
 public interface InsertQuery<QueryUserExtension : Any> : _Query<QueryUserExtension> {
@@ -52,7 +52,7 @@ public interface InsertQuery<QueryUserExtension : Any> : _Query<QueryUserExtensi
 			public interface Scope<QueryUserExtension : Any, TargetTableUserExtension : Any, SourceQueryUserExtension : Any> : _CommonInsertCreatorScope<QueryUserExtension, TargetTableUserExtension> {
 				public fun <RT, DT : DatabaseType<RT>> queryParam(name: String, type: DT): QueryParam<RT, DT, QueryUserExtension>
 
-				public val sourceQueryParams: ParametersSetter.WithRedirect<SourceQueryUserExtension, QueryUserExtension>
+				public val sourceQueryParams: InputRow.WithRedirect<SourceQueryUserExtension, QueryUserExtension>
 
 				public fun <RT, DT : DatabaseType<RT>> insertConstant(dst: Column<RT, DT, TargetTableUserExtension>, src: QueryParam<RT, DT, QueryUserExtension>)
 				public fun <RT, DT : DatabaseType<RT>> insertFromSubquery(dst: Column<RT, DT, TargetTableUserExtension>, src: QueryParam<RT, DT, SourceQueryUserExtension>)
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/SelectQuery.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/SelectQuery.kt
index e3091c2..0d01f97 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/SelectQuery.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/SelectQuery.kt
@@ -6,7 +6,7 @@ import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseType
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseTypesProvider
 import ru.landgrafhomyak.serdha.api.v0.misc.Expression
 import ru.landgrafhomyak.serdha.api.v0.misc.QueryParam
-import ru.landgrafhomyak.serdha.api.v0.runtime.ParametersSetter
+import ru.landgrafhomyak.serdha.api.v0.runtime.InputRow
 
 public interface SelectQuery<QueryUserExtension : Any> : _Query<QueryUserExtension> {
 	public enum class Order {
@@ -40,8 +40,8 @@ public interface SelectQuery<QueryUserExtension : Any> : _Query<QueryUserExtensi
 			public fun createSelectWithJoin(creator: Scope<QueryUserExtension, LeftTableUserExtension, RightTableUserExtension>): QueryUserExtension
 
 			public interface Scope<QueryUserExtension : Any, LeftTableUserExtension : Any, RightTableUserExtension : Any> {
-				public val leftSubqueryParams: ParametersSetter.WithRedirect<LeftTableUserExtension, QueryUserExtension>
-				public val rightSubqueryParams: ParametersSetter.WithRedirect<RightTableUserExtension, QueryUserExtension>
+				public val leftSubqueryParams: InputRow.WithRedirect<LeftTableUserExtension, QueryUserExtension>
+				public val rightSubqueryParams: InputRow.WithRedirect<RightTableUserExtension, QueryUserExtension>
 
 				public fun <RT, DT : DatabaseType<RT>> selectColumnFromLeft(column: Column<RT, DT, LeftTableUserExtension>): IntermediateColumn<RT, DT, QueryUserExtension>
 				public fun <RT, DT : DatabaseType<RT>> selectColumnFromRight(column: Column<RT, DT, RightTableUserExtension>): IntermediateColumn<RT, DT, QueryUserExtension>
@@ -54,7 +54,7 @@ public interface SelectQuery<QueryUserExtension : Any> : _Query<QueryUserExtensi
 			public fun createSelect(creator: Scope<QueryUserExtension, TableUserExtension>): QueryUserExtension
 
 			public interface Scope<QueryUserExtension : Any, TableUserExtension : Any> : _CommonSelectCreatorScope<QueryUserExtension> {
-				public val subqueryParams: ParametersSetter.WithRedirect<TableUserExtension, QueryUserExtension>
+				public val subqueryParams: InputRow.WithRedirect<TableUserExtension, QueryUserExtension>
 
 				public fun <RT, DT : DatabaseType<RT>> selectColumnFromSubquery(param: Column<RT, DT, TableUserExtension>): IntermediateColumn<RT, DT, QueryUserExtension>
 			}
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/UpdateQuery.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/UpdateQuery.kt
index 33ee673..a76515e 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/UpdateQuery.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/queries/UpdateQuery.kt
@@ -5,7 +5,7 @@ import ru.landgrafhomyak.serdha.api.v0.table.Table
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseType
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseTypesProvider
 import ru.landgrafhomyak.serdha.api.v0.misc.QueryParam
-import ru.landgrafhomyak.serdha.api.v0.runtime.ParametersSetter
+import ru.landgrafhomyak.serdha.api.v0.runtime.InputRow
 
 public interface UpdateQuery<QueryUserExtension : Any> : _Query<QueryUserExtension> {
 	public interface FromSubquery<QueryUserExtension : Any> : UpdateQuery<QueryUserExtension>, _Query.Params2Table<QueryUserExtension> {
@@ -16,7 +16,7 @@ public interface UpdateQuery<QueryUserExtension : Any> : _Query<QueryUserExtensi
 				public val types: DatabaseTypesProvider
 				public fun <RT, DT : DatabaseType<RT>> param(name: String, type: DT): QueryParam<RT, DT, QueryUserExtension>
 
-				public val selectorParams: ParametersSetter.WithRedirect<SelectorTableUserExtension, QueryUserExtension>
+				public val selectorParams: InputRow.WithRedirect<SelectorTableUserExtension, QueryUserExtension>
 				public var selectorColumn: Column<*, DatabaseType.ROW_ID<TargetTableUserExtension>, SelectorTableUserExtension>
 
 				public fun <RT, DT : DatabaseType<RT>> updateColumnWithSubquery(dst: Column<RT, DT, TargetTableUserExtension>, src: Column<RT, DT, SelectorTableUserExtension>)
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/ParametersSetter.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/InputRow.kt
similarity index 70%
rename from src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/ParametersSetter.kt
rename to src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/InputRow.kt
index be0a9a1..540864a 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/ParametersSetter.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/InputRow.kt
@@ -1,9 +1,10 @@
 package ru.landgrafhomyak.serdha.api.v0.runtime
 
+import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
 import ru.landgrafhomyak.serdha.api.v0.misc.DatabaseType
 import ru.landgrafhomyak.serdha.api.v0.misc.QueryParam
 
-public interface ParametersSetter<QueryUserExtension : Any/* todo*/> {
+public interface InputRow<QueryUserExtension : Any/* todo*/> {
 	public operator fun <RuntimeType> set(c: QueryParam<RuntimeType, *, QueryUserExtension>, value: RuntimeType)
 
 	public operator fun set(c: QueryParam<Byte, *, QueryUserExtension>, value: Byte): Unit = this.set<Byte>(c, value)
@@ -17,7 +18,28 @@ public interface ParametersSetter<QueryUserExtension : Any/* todo*/> {
 	public operator fun set(c: QueryParam<Char, *, QueryUserExtension>, value: Char): Unit = this.set<Char>(c, value)
 	public operator fun set(c: QueryParam<Boolean, *, QueryUserExtension>, value: Boolean): Unit = this.set<Boolean>(c, value)
 
-	public interface WithRedirect<QueryUserExtension : Any, ParentQueryUserExtension : Any> : ParametersSetter<QueryUserExtension> {
+	public interface WithRedirect<QueryUserExtension : Any, ParentQueryUserExtension : Any> : InputRow<QueryUserExtension> {
 		public fun <RT, DT : DatabaseType<RT>> redirect(c: QueryParam<RT, DT, QueryUserExtension>, value: QueryParam<RT, DT, ParentQueryUserExtension>)
 	}
+
+	@Suppress("ClassName")
+	@LowLevelApi
+	public interface _Scope<QueryUserExtension : Any, out Next> : InputRow<QueryUserExtension> {
+		@Suppress("FunctionName")
+		@LowLevelApi
+		public suspend fun _finish(): Next
+
+		@Suppress("FunctionName")
+		@LowLevelApi
+		public suspend fun _abort()
+	}
+
+
+	@Suppress("ClassName")
+	@LowLevelApi
+	public interface _Iterator<QueryUserExtension : Any, out Next> : _Scope<QueryUserExtension, Next> {
+		@Suppress("FunctionName")
+		@LowLevelApi
+		public fun _next(): Boolean
+	}
 }
\ No newline at end of file
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Row.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/OutputRow.kt
similarity index 70%
rename from src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Row.kt
rename to src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/OutputRow.kt
index 773b1e8..c912678 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Row.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/OutputRow.kt
@@ -1,8 +1,9 @@
 package ru.landgrafhomyak.serdha.api.v0.runtime
 
+import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
 import ru.landgrafhomyak.serdha.api.v0.misc.Column
 
-public interface Row<QueryUserExtension : Any> {
+public interface OutputRow<QueryUserExtension : Any> {
 	public operator fun <RuntimeType> get(c: Column<RuntimeType, *, QueryUserExtension>): RuntimeType
 
 	public operator fun get(c: Column<Byte, *, QueryUserExtension>): Byte = this.get<Byte>(c)
@@ -15,4 +16,20 @@ public interface Row<QueryUserExtension : Any> {
 	public operator fun get(c: Column<ULong, *, QueryUserExtension>): ULong = this.get<ULong>(c)
 	public operator fun get(c: Column<Char, *, QueryUserExtension>): Char = this.get<Char>(c)
 	public operator fun get(c: Column<Boolean, *, QueryUserExtension>): Boolean = this.get<Boolean>(c)
+
+	@Suppress("ClassName")
+	@LowLevelApi
+	public interface _Iterator<QueryUserExtension : Any, out Next> : OutputRow<QueryUserExtension> {
+		@Suppress("FunctionName")
+		@LowLevelApi
+		public suspend fun _next(): Boolean
+
+		@Suppress("FunctionName")
+		@LowLevelApi
+		public suspend fun _abort()
+
+		@Suppress("FunctionName")
+		@LowLevelApi
+		public suspend fun _finish(): Next
+	}
 }
\ No newline at end of file
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/SynchronizedDatabase.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/SynchronizedDatabase.kt
index 4c0cb1d..7677b9d 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/SynchronizedDatabase.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/SynchronizedDatabase.kt
@@ -4,11 +4,7 @@ import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
 import ru.landgrafhomyak.serdha.api.v0.module.Module
 import ru.landgrafhomyak.serdha.api.v0.table.RowId
 import ru.landgrafhomyak.serdha.api.v0.table.Table
-import ru.landgrafhomyak.serdha.api.v0.queries.CopyQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.DeleteQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.InsertQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.SelectQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.UpdateQuery
+import ru.landgrafhomyak.serdha.api.v0.queries._Query
 
 public interface SynchronizedDatabase<DatabaseUserExtension : Any> : Module<DatabaseUserExtension> {
 	@Suppress("FunctionName")
@@ -17,23 +13,19 @@ public interface SynchronizedDatabase<DatabaseUserExtension : Any> : Module<Data
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public suspend fun <QueryUserWrapper : Any> _autoTransactedSelect(query: SelectQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>>
+	public suspend fun <QueryUserExtension : Any> _executeAutoTransactedQuery(compiledQuery: _Query.Void2Table<QueryUserExtension>): OutputRow._Iterator<QueryUserExtension, Unit>
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public suspend fun <QueryUserWrapper : Any> _autoTransactedInsert(query: InsertQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ParametersSetter._Multi<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>, _ResultSet<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>>?>>
+	public suspend fun <QueryUserExtension : Any> _executeAutoTransactedQuery(compiledQuery: _Query.Params2Table<QueryUserExtension>): InputRow._Scope<QueryUserExtension, OutputRow._Iterator<QueryUserExtension, Unit>>
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public suspend fun <QueryUserWrapper : Any> _autoTransactedCopy(query: CopyQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>>?>
+	public suspend fun <QueryUserExtension : Any> _executeAutoTransactedQuery(compiledQuery: _Query.Table2Void<QueryUserExtension>): InputRow._Iterator<QueryUserExtension, Unit>
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public suspend fun <QueryUserWrapper : Any> _autoTransactedUpdate(query: UpdateQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>?>
-
-	@Suppress("FunctionName")
-	@LowLevelApi
-	public suspend fun <QueryUserWrapper : Any> _autoTransactedDelete(query: DeleteQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>?>
+	public suspend fun <QueryUserExtension : Any> _executeAutoTransactedQuery(compiledQuery: _Query.Params2Void<QueryUserExtension>): InputRow._Scope<QueryUserExtension, Unit>
 
 	public interface AtomicScript<C, A, R> {
 		public suspend fun executeTransaction(transaction: Transaction, context: C, args: A): R
@@ -47,7 +39,7 @@ public interface SynchronizedDatabase<DatabaseUserExtension : Any> : Module<Data
 
 	public fun <TableUserException : Any, V> mapOfRowIds(
 		table: Table<TableUserException, *>,
-		builder: (MutableMap<Row<TableUserException>, V>) -> Unit
+		builder: (MutableMap<OutputRow<TableUserException>, V>) -> Unit
 	): Map<RowId<TableUserException>, V>
 
 	public fun <TableUserException : Any, V> mutableMapOfRowIds(table: Table<TableUserException, *>): MutableMap<RowId<TableUserException>, V>
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Transaction.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Transaction.kt
index 636e2c7..85b2c99 100644
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Transaction.kt
+++ b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/Transaction.kt
@@ -1,32 +1,24 @@
 package ru.landgrafhomyak.serdha.api.v0.runtime
 
 import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
-import ru.landgrafhomyak.serdha.api.v0.queries.CopyQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.DeleteQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.InsertQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.SelectQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.UpdateQuery
+import ru.landgrafhomyak.serdha.api.v0.queries._Query
 
 public interface Transaction {
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public fun <QueryUserWrapper : Any> _select(compiledQuery: SelectQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>>
+	public suspend fun <QueryUserExtension : Any> _executeQuery(compiledQuery: _Query.Void2Table<QueryUserExtension>): OutputRow._Iterator<QueryUserExtension, Unit>
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public fun <QueryUserWrapper : Any> _insert(compiledQuery: InsertQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ParametersSetter._Multi<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>, _ResultSet<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>>?>>
+	public suspend fun <QueryUserExtension : Any> _executeQuery(compiledQuery: _Query.Params2Table<QueryUserExtension>): InputRow._Scope<QueryUserExtension, OutputRow._Iterator<QueryUserExtension, Unit>>
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public fun <QueryUserWrapper : Any> _copy(compiledQuery: CopyQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>>?>
+	public suspend fun <QueryUserExtension : Any> _executeQuery(compiledQuery: _Query.Table2Void<QueryUserExtension>): InputRow._Iterator<QueryUserExtension, Unit>
 
 	@Suppress("FunctionName")
 	@LowLevelApi
-	public fun <QueryUserWrapper : Any> _update(compiledQuery: UpdateQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>?>
-
-	@Suppress("FunctionName")
-	@LowLevelApi
-	public fun <QueryUserWrapper : Any> _delete(compiledQuery: DeleteQuery<QueryUserWrapper>): _ParametersSetter<QueryUserWrapper, _ResultSet<QueryUserWrapper, Unit>?>
+	public suspend fun <QueryUserExtension : Any> _executeQuery(compiledQuery: _Query.Params2Void<QueryUserExtension>): InputRow._Scope<QueryUserExtension, Unit>
 
 	public suspend fun rollback()
 
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/_ParametersSetter.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/_ParametersSetter.kt
deleted file mode 100644
index 393d8d0..0000000
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/_ParametersSetter.kt
+++ /dev/null
@@ -1,19 +0,0 @@
-package ru.landgrafhomyak.serdha.api.v0.runtime
-
-import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
-
-@Suppress("ClassName", "FunctionName")
-@LowLevelApi
-public interface _ParametersSetter<QueryUserExtension : Any, out Result> : ParametersSetter<QueryUserExtension> {
-	@LowLevelApi
-	public suspend fun _execute(): Result
-
-	@LowLevelApi
-	public suspend fun _abort()
-
-	@LowLevelApi
-	public interface _Multi<QueryUserExtension : Any, out Result> : _ParametersSetter<QueryUserExtension, Result> {
-		@LowLevelApi
-		public fun _next(): Boolean
-	}
-}
\ No newline at end of file
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/_ResultSet.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/_ResultSet.kt
deleted file mode 100644
index cea86d5..0000000
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/_ResultSet.kt
+++ /dev/null
@@ -1,19 +0,0 @@
-package ru.landgrafhomyak.serdha.api.v0.runtime
-
-import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
-
-@Suppress("ClassName")
-@LowLevelApi
-public interface _ResultSet<QueryUserExtension : Any, out Next> : Row<QueryUserExtension> {
-	@Suppress("FunctionName")
-	@LowLevelApi
-	public suspend fun _next(): Boolean
-
-	@Suppress("FunctionName")
-	@LowLevelApi
-	public suspend fun _abort()
-
-	@Suppress("FunctionName")
-	@LowLevelApi
-	public suspend fun _close(): Next
-}
\ No newline at end of file
diff --git a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/transaction_methods.kt b/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/transaction_methods.kt
deleted file mode 100644
index d41632a..0000000
--- a/src/commonMain/kotlin/ru/landgrafhomyak/serdha/api/v0/runtime/transaction_methods.kt
+++ /dev/null
@@ -1,1121 +0,0 @@
-@file:JvmName("TransactionMethodsKt")
-
-package ru.landgrafhomyak.serdha.api.v0.runtime
-
-import kotlin.contracts.InvocationKind
-import kotlin.contracts.contract
-import kotlin.jvm.JvmName
-import ru.landgrafhomyak.serdha.api.v0.LowLevelApi
-import ru.landgrafhomyak.serdha.api.v0.queries.CopyQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.DeleteQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.InsertQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.SelectQuery
-import ru.landgrafhomyak.serdha.api.v0.queries.UpdateQuery
-
-
-@Suppress("FunctionName")
-@PublishedApi
-internal inline fun <R> _safeAutoClose(onAbort: () -> Unit = {}, onSuccess: () -> Unit = {}, action: () -> R): R {
-	contract {
-		callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(onAbort, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(onSuccess, InvocationKind.AT_MOST_ONCE)
-	}
-	val ret: R
-	try {
-		ret = action()
-	} catch (e1: Throwable) {
-		try {
-			onAbort()
-		} catch (e2: Throwable) {
-			e1.addSuppressed(e2)
-		}
-		throw e1
-	}
-	onSuccess()
-	return ret
-}
-
-@Suppress("FunctionName")
-@PublishedApi
-internal inline fun <R> _safeAutoClose(finally: () -> Unit, action: () -> R): R {
-	contract {
-		callsInPlace(action, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(finally, InvocationKind.EXACTLY_ONCE)
-	}
-	return _safeAutoClose(finally, finally, action)
-}
-
-public class QueryWithoutReturnError(message: String, public val query: Any) : Error(message)
-
-@Suppress("FunctionName", "DuplicatedCode")
-@PublishedApi
-@OptIn(LowLevelApi::class)
-internal suspend inline fun <Q : Any> _wrapWithLambdas(
-	compiledQuery: Any,
-	queryGetter: () -> _ParametersSetter<Q, _ResultSet<Q, Unit>?>,
-	parameters: (ParametersSetter<Q>) -> Unit,
-	hasReturning: Boolean,
-	returning: (_ResultSet<Q, *>) -> Unit,
-	queryWithoutErrorMessage: String
-) {
-	contract {
-		callsInPlace(queryGetter, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(returning, InvocationKind.AT_MOST_ONCE)
-	}
-	val paramsSetter = queryGetter()
-
-	_safeAutoClose(onAbort = { paramsSetter._abort() }) {
-		parameters(paramsSetter)
-	}
-
-	val rows = paramsSetter._execute()
-	if (rows == null) {
-		if (hasReturning)
-			throw QueryWithoutReturnError(queryWithoutErrorMessage, compiledQuery)
-		return
-	}
-
-	_safeAutoClose(onAbort = { rows._abort() }, onSuccess = { rows._close() }) {
-		returning(rows)
-	}
-}
-
-public class ResultNotSingleError : Error()
-
-@Suppress("FunctionName")
-@PublishedApi
-@OptIn(LowLevelApi::class)
-internal suspend inline fun <Q : Any, R> _wrapWithLambdasSingleOrNull(
-	compiledQuery: Any,
-	queryGetter: () -> _ParametersSetter<Q, _ResultSet<Q, Unit>?>,
-	parameters: (ParametersSetter<Q>) -> Unit,
-	hasReturning: Boolean,
-	returning: (Row<Q>) -> R,
-	queryWithoutErrorMessage: String
-): R? {
-	contract {
-		callsInPlace(queryGetter, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(returning, InvocationKind.AT_MOST_ONCE)
-	}
-
-	_wrapWithLambdas(
-		compiledQuery, queryGetter, parameters, hasReturning,
-		{ rs ->
-			if (!rs._next())
-				return@_wrapWithLambdasSingleOrNull null
-			val ret = returning(rs)
-			if (rs._next())
-				throw ResultNotSingleError()
-			return@_wrapWithLambdasSingleOrNull ret
-		},
-		queryWithoutErrorMessage
-	)
-	throw QueryWithoutReturnError(queryWithoutErrorMessage, compiledQuery)
-}
-
-
-@Suppress("FunctionName")
-@PublishedApi
-@OptIn(LowLevelApi::class)
-internal suspend inline fun <Q : Any> _wrapWithLambdasIterate(
-	compiledQuery: Any,
-	queryGetter: () -> _ParametersSetter<Q, _ResultSet<Q, Unit>?>,
-	parameters: (ParametersSetter<Q>) -> Unit,
-	hasReturning: Boolean,
-	returning: (Row<Q>) -> Unit,
-	queryWithoutErrorMessage: String
-) {
-	contract {
-		callsInPlace(queryGetter, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(returning, InvocationKind.UNKNOWN)
-	}
-
-	return _wrapWithLambdas(compiledQuery, queryGetter, parameters, hasReturning, { rs -> while (rs._next()) returning(rs) }, queryWithoutErrorMessage)
-}
-
-@Suppress("FunctionName")
-@PublishedApi
-@OptIn(LowLevelApi::class)
-internal suspend inline fun <Q : Any, R> _wrapWithLambdasMap(
-	compiledQuery: Any,
-	queryGetter: () -> _ParametersSetter<Q, _ResultSet<Q, Unit>?>,
-	parameters: (ParametersSetter<Q>) -> Unit,
-	hasReturning: Boolean,
-	returning: (Row<Q>) -> R,
-	queryWithoutErrorMessage: String
-): List<R> {
-	contract {
-		callsInPlace(queryGetter, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(returning, InvocationKind.UNKNOWN)
-	}
-
-	_wrapWithLambdas(
-		compiledQuery, queryGetter, parameters, hasReturning,
-		{ rs ->
-			val out = ArrayList<R>()
-			while (rs._next())
-				out.add(returning(rs))
-			return@_wrapWithLambdasMap out
-		},
-		queryWithoutErrorMessage
-	)
-	throw QueryWithoutReturnError(queryWithoutErrorMessage, compiledQuery)
-}
-
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedSelectSingleOrNull(
-	compiledQuery: SelectQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.AT_MOST_ONCE)
-	}
-	return _wrapWithLambdasSingleOrNull(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedSelect(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.selectSingleOrNull(
-	compiledQuery: SelectQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.AT_MOST_ONCE)
-	}
-	return _wrapWithLambdasSingleOrNull(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._select(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.selectThenIterate(
-	compiledQuery: SelectQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	_wrapWithLambdasIterate(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._select(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedSelectThenIterate(
-	compiledQuery: SelectQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	_wrapWithLambdasIterate(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedSelect(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.selectThenMap(
-	compiledQuery: SelectQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): List<R> {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	return _wrapWithLambdasMap(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._select(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedSelectThenMap(
-	compiledQuery: SelectQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): List<R> {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	return _wrapWithLambdasMap(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedSelect(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@Suppress("FunctionName", "DuplicatedCode")
-@PublishedApi
-@OptIn(LowLevelApi::class)
-internal suspend inline fun <Q : Any, T> _wrapInsertWithLambdas(
-	compiledQuery: InsertQuery<Q>,
-	queryGetter: () -> _ParametersSetter<Q, _ParametersSetter._Multi<InsertQuery.Creator.Scope.DataParam<Q>, _ResultSet<Q, _ResultSet<Q, Unit>>?>>,
-	parameters: (ParametersSetter<Q>) -> Unit,
-	data: Iterable<T>,
-	rowFormatter: (T, ParametersSetter<InsertQuery.Creator.Scope.DataParam<Q>>) -> Unit,
-	hasReturning: Boolean,
-	returningInserted: (_ResultSet<Q, *>) -> Unit,
-	returningUpdated: (_ResultSet<Q, *>) -> Unit,
-	queryWithoutErrorMessage: String
-) {
-	contract {
-		callsInPlace(queryGetter, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowFormatter, InvocationKind.UNKNOWN)
-		callsInPlace(returningInserted, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(returningUpdated, InvocationKind.AT_MOST_ONCE)
-	}
-	val paramsSetter = queryGetter()
-
-	_safeAutoClose(onAbort = { paramsSetter._abort() }) {
-		parameters(paramsSetter)
-	}
-
-	val insertableValues = paramsSetter._execute()
-	_safeAutoClose(onAbort = { insertableValues._abort() }) {
-		for (e in data) {
-			insertableValues._next()
-			rowFormatter(e, insertableValues)
-		}
-	}
-
-	val insertedRows = insertableValues._execute()
-	if (insertedRows == null) {
-		if (hasReturning)
-			throw QueryWithoutReturnError(queryWithoutErrorMessage, compiledQuery)
-		return
-	}
-
-	_safeAutoClose(onAbort = { insertedRows._abort() }) {
-		returningInserted(insertedRows)
-	}
-	val updatedRows = insertedRows._close()
-	_safeAutoClose(onAbort = { insertedRows._abort() }, onSuccess = { updatedRows._abort() }) {
-		returningInserted(insertedRows)
-	}
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, T> Transaction.insert(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	data: Iterable<T>,
-	rowFormatter: (T, ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit,
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowFormatter, InvocationKind.UNKNOWN)
-	}
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._insert(compiledQuery) },
-		parameters = parameters,
-		data = data,
-		rowFormatter = rowFormatter,
-		hasReturning = false,
-		returningInserted = {},
-		returningUpdated = {},
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, T> SynchronizedDatabase<*>.autoTransactedInsert(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	data: Iterable<T>,
-	rowFormatter: (T, ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit,
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowFormatter, InvocationKind.UNKNOWN)
-	}
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedInsert(compiledQuery) },
-		parameters = parameters,
-		data = data,
-		rowFormatter = rowFormatter,
-		hasReturning = false,
-		returningInserted = {},
-		returningUpdated = {},
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, T> Transaction.insertReturningIterate(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	data: Iterable<T>,
-	rowFormatter: (T, ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit,
-	insertedRows: (Row<QueryUserWrapper>) -> Unit,
-	updatedRows: (Row<QueryUserWrapper>) -> Unit,
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowFormatter, InvocationKind.UNKNOWN)
-	}
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._insert(compiledQuery) },
-		parameters = parameters,
-		data = data,
-		rowFormatter = rowFormatter,
-		hasReturning = true,
-		returningInserted = { rs -> while (rs._next()) insertedRows(rs) },
-		returningUpdated = { rs -> while (rs._next()) updatedRows(rs) },
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, T> SynchronizedDatabase<*>.autoTransactedInsertReturningIterate(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	data: Iterable<T>,
-	rowFormatter: (T, ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit,
-	insertedRows: (Row<QueryUserWrapper>) -> Unit,
-	updatedRows: (Row<QueryUserWrapper>) -> Unit,
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowFormatter, InvocationKind.UNKNOWN)
-	}
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedInsert(compiledQuery) },
-		parameters = parameters,
-		data = data,
-		rowFormatter = rowFormatter,
-		hasReturning = true,
-		returningInserted = { rs -> while (rs._next()) insertedRows(rs) },
-		returningUpdated = { rs -> while (rs._next()) updatedRows(rs) },
-		queryWithoutErrorMessage = ""
-	)
-}
-
-
-@PublishedApi
-internal object SingleIterable : Iterable<Unit>, Iterator<Unit> {
-	private var isReturned = false
-
-	override fun iterator(): Iterator<Unit> = this
-
-	override fun hasNext(): Boolean = !this.isReturned
-
-	override fun next(): Unit {
-		if (this.isReturned) throw IllegalStateException()
-		this.isReturned = true
-	}
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.insertSingle(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowData: (ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit,
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowData, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._insert(compiledQuery) },
-		parameters = parameters,
-		data = SingleIterable,
-		rowFormatter = { _, r -> rowData(r) },
-		hasReturning = false,
-		returningInserted = {},
-		returningUpdated = {},
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedInsertSingle(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowData: (ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit,
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowData, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedInsert(compiledQuery) },
-		parameters = parameters,
-		data = SingleIterable,
-		rowFormatter = { _, r -> rowData(r) },
-		hasReturning = false,
-		returningInserted = {},
-		returningUpdated = {},
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@Suppress("DuplicatedCode")
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.insertSingleReturning(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowData: (ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit = {},
-	insertedRows: (Row<QueryUserWrapper>) -> R,
-	updatedRows: (Row<QueryUserWrapper>) -> R
-): R {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowData, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(insertedRows, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(updatedRows, InvocationKind.AT_MOST_ONCE)
-	}
-	var isReturned = false
-	var ret: R? = null
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._insert(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		data = SingleIterable,
-		rowFormatter = { _, r -> rowData(r) },
-		returningInserted = returningInserted@{ rs ->
-			if (!rs._next()) return@returningInserted
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		returningUpdated = returningUpdated@{ rs ->
-			if (!rs._next()) return@returningUpdated
-			if (isReturned) throw ResultNotSingleError()
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		queryWithoutErrorMessage = ""
-	)
-	if (!isReturned)
-		throw QueryWithoutReturnError("", compiledQuery)
-	@Suppress("UNCHECKED_CAST")
-	return ret as R
-}
-
-@Suppress("DuplicatedCode")
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedInsertSingleReturning(
-	compiledQuery: InsertQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowData: (ParametersSetter<InsertQuery.Creator.Scope.DataParam<QueryUserWrapper>>) -> Unit = {},
-	insertedRows: (Row<QueryUserWrapper>) -> R,
-	updatedRows: (Row<QueryUserWrapper>) -> R
-): R {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowData, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(insertedRows, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(updatedRows, InvocationKind.AT_MOST_ONCE)
-	}
-	var isReturned = false
-	var ret: R? = null
-	_wrapInsertWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedInsert(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		data = SingleIterable,
-		rowFormatter = { _, r -> rowData(r) },
-		returningInserted = returningInserted@{ rs ->
-			if (!rs._next()) return@returningInserted
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		returningUpdated = returningUpdated@{ rs ->
-			if (!rs._next()) return@returningUpdated
-			if (isReturned) throw ResultNotSingleError()
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		queryWithoutErrorMessage = ""
-	)
-	if (!isReturned)
-		throw QueryWithoutReturnError("", compiledQuery)
-	@Suppress("UNCHECKED_CAST")
-	return ret as R
-}
-
-@Suppress("FunctionName", "DuplicatedCode")
-@PublishedApi
-@OptIn(LowLevelApi::class)
-internal suspend inline fun <Q : Any> _wrapCopyWithLambdas(
-	compiledQuery: CopyQuery<Q>,
-	queryGetter: () -> _ParametersSetter<Q, _ResultSet<Q, _ResultSet<Q, Unit>>?>,
-	parameters: (ParametersSetter<Q>) -> Unit,
-	hasReturning: Boolean,
-	returningInserted: (_ResultSet<Q, *>) -> Unit,
-	returningUpdated: (_ResultSet<Q, *>) -> Unit,
-	queryWithoutErrorMessage: String
-) {
-	contract {
-		callsInPlace(queryGetter, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(returningInserted, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(returningUpdated, InvocationKind.AT_MOST_ONCE)
-	}
-	val paramsSetter = queryGetter()
-
-	_safeAutoClose(onAbort = { paramsSetter._abort() }) {
-		parameters(paramsSetter)
-	}
-
-	val insertedRows = paramsSetter._execute()
-	if (insertedRows == null) {
-		if (hasReturning)
-			throw QueryWithoutReturnError(queryWithoutErrorMessage, compiledQuery)
-		return
-	}
-
-	_safeAutoClose(onAbort = { insertedRows._abort() }) {
-		returningInserted(insertedRows)
-	}
-	val updatedRows = insertedRows._close()
-	_safeAutoClose(onAbort = { insertedRows._abort() }, onSuccess = { updatedRows._abort() }) {
-		returningInserted(insertedRows)
-	}
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.copy(
-	compiledQuery: CopyQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapCopyWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._copy(compiledQuery) },
-		parameters = parameters,
-		hasReturning = false,
-		returningInserted = {},
-		returningUpdated = {},
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedCopy(
-	compiledQuery: CopyQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapCopyWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedCopy(compiledQuery) },
-		parameters = parameters,
-		hasReturning = false,
-		returningInserted = {},
-		returningUpdated = {},
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.copyReturningIterate(
-	compiledQuery: CopyQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	insertedRows: (Row<QueryUserWrapper>) -> Unit,
-	updatedRows: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(insertedRows, InvocationKind.UNKNOWN)
-		callsInPlace(updatedRows, InvocationKind.UNKNOWN)
-	}
-	_wrapCopyWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._copy(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returningInserted = { rs -> while (rs._next()) insertedRows(rs) },
-		returningUpdated = { rs -> while (rs._next()) updatedRows(rs) },
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedCopyReturningIterate(
-	compiledQuery: CopyQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	insertedRows: (Row<QueryUserWrapper>) -> Unit,
-	updatedRows: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(insertedRows, InvocationKind.UNKNOWN)
-		callsInPlace(updatedRows, InvocationKind.UNKNOWN)
-	}
-	_wrapCopyWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedCopy(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returningInserted = { rs -> while (rs._next()) insertedRows(rs) },
-		returningUpdated = { rs -> while (rs._next()) updatedRows(rs) },
-		queryWithoutErrorMessage = ""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.copyReturningSingleOrNull(
-	compiledQuery: CopyQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	insertedRows: (Row<QueryUserWrapper>) -> R,
-	updatedRows: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(insertedRows, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(updatedRows, InvocationKind.AT_MOST_ONCE)
-	}
-	var isReturned = false
-	var ret: R? = null
-	_wrapCopyWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._copy(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returningInserted = returningInserted@{ rs ->
-			if (!rs._next()) return@returningInserted
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		returningUpdated = returningUpdated@{ rs ->
-			if (!rs._next()) return@returningUpdated
-			if (isReturned) throw ResultNotSingleError()
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		queryWithoutErrorMessage = ""
-	)
-	if (!isReturned)
-		return null
-	return ret
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedCopyReturningSingleOrNull(
-	compiledQuery: CopyQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	insertedRows: (Row<QueryUserWrapper>) -> R,
-	updatedRows: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(insertedRows, InvocationKind.AT_MOST_ONCE)
-		callsInPlace(updatedRows, InvocationKind.AT_MOST_ONCE)
-	}
-	var isReturned = false
-	var ret: R? = null
-	_wrapCopyWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedCopy(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returningInserted = returningInserted@{ rs ->
-			if (!rs._next()) return@returningInserted
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		returningUpdated = returningUpdated@{ rs ->
-			if (!rs._next()) return@returningUpdated
-			if (isReturned) throw ResultNotSingleError()
-			isReturned = true
-			ret = insertedRows(rs)
-			if (rs._next()) throw ResultNotSingleError()
-		},
-		queryWithoutErrorMessage = ""
-	)
-	if (!isReturned)
-		return null
-	return ret
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.update(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._update(compiledQuery) },
-		parameters = parameters,
-		hasReturning = false,
-		returning = {},
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedUpdate(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedUpdate(compiledQuery) },
-		parameters = parameters,
-		hasReturning = false,
-		returning = {},
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.updateReturningSingleOrNull(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.AT_MOST_ONCE)
-	}
-	return _wrapWithLambdasSingleOrNull(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._update(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedUpdateReturningSingleOrNull(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.AT_MOST_ONCE)
-	}
-	return _wrapWithLambdasSingleOrNull(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedUpdate(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.updateReturningIterate(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	_wrapWithLambdasIterate(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._update(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedUpdateReturningIterate(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	_wrapWithLambdasIterate(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedUpdate(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.updateReturningMap(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): List<R> {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	return _wrapWithLambdasMap(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._update(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedUpdateReturningMap(
-	compiledQuery: UpdateQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): List<R> {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	return _wrapWithLambdasMap(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedUpdate(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.delete(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._delete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = false,
-		returning = {},
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedDelete(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-	}
-	_wrapWithLambdas(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedDelete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = false,
-		returning = {},
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.deleteReturningSingleOrNull(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.AT_MOST_ONCE)
-	}
-	return _wrapWithLambdasSingleOrNull(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._delete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedDeleteReturningSingleOrNull(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): R? {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.AT_MOST_ONCE)
-	}
-	return _wrapWithLambdasSingleOrNull(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedDelete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> Transaction.deleteReturningIterate(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	_wrapWithLambdasIterate(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._delete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any> SynchronizedDatabase<*>.autoTransactedDeleteReturningIterate(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> Unit
-) {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	_wrapWithLambdasIterate(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedDelete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> Transaction.deleteReturningMap(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): List<R> {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	return _wrapWithLambdasMap(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._delete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend inline fun <QueryUserWrapper : Any, R> SynchronizedDatabase<*>.autoTransactedDeleteReturningMap(
-	compiledQuery: DeleteQuery<QueryUserWrapper>,
-	parameters: (ParametersSetter<QueryUserWrapper>) -> Unit = {},
-	rowsConsumer: (Row<QueryUserWrapper>) -> R
-): List<R> {
-	contract {
-		callsInPlace(parameters, InvocationKind.EXACTLY_ONCE)
-		callsInPlace(rowsConsumer, InvocationKind.UNKNOWN)
-	}
-	return _wrapWithLambdasMap(
-		compiledQuery = compiledQuery,
-		queryGetter = { this._autoTransactedDelete(compiledQuery) },
-		parameters = parameters,
-		hasReturning = true,
-		returning = rowsConsumer,
-		""
-	)
-}
-
-@OptIn(LowLevelApi::class)
-public suspend fun <R> SynchronizedDatabase<*>.transaction(body: (Transaction) -> R): R {
-	contract {
-		callsInPlace(body, InvocationKind.EXACTLY_ONCE)
-	}
-
-	val tr = this._startTransaction()
-	_safeAutoClose(onAbort = { tr.rollback(); tr._assertTransactionFinishedAndReleaseResources() }, onSuccess = { tr._assertTransactionFinishedAndReleaseResources() }) {
-		return@transaction body(tr)
-	}
-}
\ No newline at end of file