Initial project import

tools/v/vlib/db/pg/tx.v

@@ -0,0 +1,167 @@
+module pg
+
+import io
+
+// Tx is a database transaction. It pins a single `Conn` from the pool for
+// the lifetime of the transaction, so all queries run on the same physical
+// connection. The pinned conn is returned to the pool when `commit()` or
+// `rollback()` is called; failing to call either leaks the conn.
+@[heap]
+pub struct Tx {
+mut:
+	conn &Conn = unsafe { nil }
+	done bool
+}
+
+fn (tx &Tx) ensure_active() ! {
+	if tx.done {
+		return error('pg: transaction is already finished')
+	}
+	if isnil(tx.conn) {
+		return error('pg: transaction has no connection')
+	}
+}
+
+fn (mut tx Tx) finish() {
+	if tx.done {
+		return
+	}
+	tx.done = true
+	if !isnil(tx.conn) {
+		mut c := tx.conn
+		c.close() or {}
+		tx.conn = unsafe { nil }
+	}
+}
+
+// commit commits the transaction and returns the pinned conn to the pool.
+pub fn (mut tx Tx) commit() ! {
+	tx.ensure_active()!
+	defer {
+		tx.finish()
+	}
+	tx.conn.commit()!
+}
+
+// rollback rolls back the transaction and returns the pinned conn to the pool.
+pub fn (mut tx Tx) rollback() ! {
+	tx.ensure_active()!
+	defer {
+		tx.finish()
+	}
+	tx.conn.rollback()!
+}
+
+// savepoint creates a savepoint named `name`.
+pub fn (mut tx Tx) savepoint(name string) ! {
+	tx.ensure_active()!
+	tx.conn.savepoint(name)!
+}
+
+// rollback_to rolls the transaction back to the savepoint named `name`.
+pub fn (mut tx Tx) rollback_to(name string) ! {
+	tx.ensure_active()!
+	tx.conn.rollback_to(name)!
+}
+
+// release_savepoint releases the savepoint named `name`.
+pub fn (mut tx Tx) release_savepoint(name string) ! {
+	tx.ensure_active()!
+	tx.conn.release_savepoint(name)!
+}
+
+// raw returns the pinned conn for advanced use cases. The caller MUST NOT
+// call `close()` on it; the conn is owned by the transaction.
+pub fn (mut tx Tx) raw() !&Conn {
+	tx.ensure_active()!
+	return tx.conn
+}
+
+// ---- exec/query helpers ----
+
+// exec runs `query` on the pinned conn.
+pub fn (mut tx Tx) exec(query string) ![]Row {
+	tx.ensure_active()!
+	return tx.conn.exec(query)
+}
+
+// exec_no_null runs `query` and returns rows with no nullable fields.
+pub fn (mut tx Tx) exec_no_null(query string) ![]RowNoNull {
+	tx.ensure_active()!
+	return tx.conn.exec_no_null(query)
+}
+
+// exec_result runs `query` and returns a `Result`.
+pub fn (mut tx Tx) exec_result(query string) !Result {
+	tx.ensure_active()!
+	return tx.conn.exec_result(query)
+}
+
+// exec_one runs `query` and returns its first row.
+pub fn (mut tx Tx) exec_one(query string) !Row {
+	tx.ensure_active()!
+	return tx.conn.exec_one(query)
+}
+
+// exec_param_many runs `query` with the given parameters.
+pub fn (mut tx Tx) exec_param_many(query string, params []string) ![]Row {
+	tx.ensure_active()!
+	return tx.conn.exec_param_many(query, params)
+}
+
+// exec_param_many_result runs `query` with parameters and returns a `Result`.
+pub fn (mut tx Tx) exec_param_many_result(query string, params []string) !Result {
+	tx.ensure_active()!
+	return tx.conn.exec_param_many_result(query, params)
+}
+
+// exec_param runs `query` with one `$1` parameter.
+pub fn (mut tx Tx) exec_param(query string, param string) ![]Row {
+	return tx.exec_param_many(query, [param])
+}
+
+// exec_param2 runs `query` with two parameters.
+pub fn (mut tx Tx) exec_param2(query string, param string, param2 string) ![]Row {
+	return tx.exec_param_many(query, [param, param2])
+}
+
+// q_int runs `query` and returns the first column of the first row as int.
+pub fn (mut tx Tx) q_int(query string) !int {
+	tx.ensure_active()!
+	return tx.conn.q_int(query)
+}
+
+// q_string runs `query` and returns the first column of the first row as string.
+pub fn (mut tx Tx) q_string(query string) !string {
+	tx.ensure_active()!
+	return tx.conn.q_string(query)
+}
+
+// q_strings runs `query` and returns the full row set (alias of `exec`).
+pub fn (mut tx Tx) q_strings(query string) ![]Row {
+	return tx.exec(query)
+}
+
+// prepare registers a prepared statement on the pinned conn.
+pub fn (mut tx Tx) prepare(name string, query string, num_params int) ! {
+	tx.ensure_active()!
+	return tx.conn.prepare(name, query, num_params)
+}
+
+// exec_prepared runs a previously-prepared statement on the pinned conn.
+pub fn (mut tx Tx) exec_prepared(name string, params []string) ![]Row {
+	tx.ensure_active()!
+	return tx.conn.exec_prepared(name, params)
+}
+
+// exec_prepared_result runs a previously-prepared statement on the pinned conn.
+pub fn (mut tx Tx) exec_prepared_result(name string, params []string) !Result {
+	tx.ensure_active()!
+	return tx.conn.exec_prepared_result(name, params)
+}
+
+// copy_expert runs a COPY command on the pinned conn.
+pub fn (mut tx Tx) copy_expert(query string, mut file io.ReaderWriter) !int {
+	tx.ensure_active()!
+	return tx.conn.copy_expert(query, mut file)
+}