Initial project import

tools/v/vlib/db/mysql/result.c.v

@@ -0,0 +1,178 @@
+module mysql
+
+pub struct Result {
+pub:
+	result &C.MYSQL_RES = unsafe { nil }
+}
+
+pub struct Row {
+pub mut:
+	vals []string
+}
+
+pub struct Field {
+	name             string
+	org_name         string
+	table            string
+	org_table        string
+	db               string
+	catalog          string
+	def              string
+	length           int
+	max_length       int
+	name_length      u32
+	org_name_length  u32
+	table_length     u32
+	org_table_length u32
+	db_length        u32
+	catalog_length   u32
+	def_length       u32
+	flags            u32
+	decimals         u32
+	charsetnr        u32
+	type             FieldType
+}
+
+// fetch_row fetches the next row from a result.
+pub fn (r Result) fetch_row() &charptr {
+	mut thread_guard := mysql_thread_guard() or { return unsafe { nil } }
+	defer {
+		thread_guard.release()
+	}
+	return C.mysql_fetch_row(r.result)
+}
+
+// n_rows returns the number of rows from a result.
+pub fn (r Result) n_rows() u64 {
+	mut thread_guard := mysql_thread_guard() or { return 0 }
+	defer {
+		thread_guard.release()
+	}
+	return C.mysql_num_rows(r.result)
+}
+
+// n_fields returns the number of columns from a result.
+pub fn (r Result) n_fields() int {
+	mut thread_guard := mysql_thread_guard() or { return 0 }
+	defer {
+		thread_guard.release()
+	}
+	return C.mysql_num_fields(r.result)
+}
+
+// rows returns array of rows, each containing an array of values,
+// one for each column.
+pub fn (r Result) rows() []Row {
+	mut thread_guard := mysql_thread_guard() or { return []Row{} }
+	defer {
+		thread_guard.release()
+	}
+	mut rows := []Row{}
+	nr_cols := C.mysql_num_fields(r.result)
+	for rr := C.mysql_fetch_row(r.result); rr; rr = C.mysql_fetch_row(r.result) {
+		mut row := Row{}
+		for i in 0 .. nr_cols {
+			if unsafe { rr[i] == 0 } {
+				row.vals << ''
+			} else {
+				row.vals << mystring(unsafe { &u8(rr[i]) })
+			}
+		}
+		rows << row
+	}
+	return rows
+}
+
+// maps returns an array of maps, each containing a set of
+// field name: field value pairs.
+pub fn (r Result) maps() []map[string]string {
+	mut array_map := []map[string]string{}
+	rows := r.rows()
+	fields := r.fields()
+	for i in 0 .. rows.len {
+		mut map_val := map[string]string{}
+		for j in 0 .. fields.len {
+			map_val[fields[j].name] = rows[i].vals[j]
+		}
+		array_map << map_val
+	}
+	return array_map
+}
+
+// fields returns an array of fields/columns.
+// The definitions apply primarily for columns of results,
+// such as those produced by `SELECT` statements.
+pub fn (r Result) fields() []Field {
+	mut thread_guard := mysql_thread_guard() or { return []Field{} }
+	defer {
+		thread_guard.release()
+	}
+	mut fields := []Field{}
+	nr_cols := C.mysql_num_fields(r.result)
+	orig_fields := C.mysql_fetch_fields(r.result)
+	for i in 0 .. nr_cols {
+		unsafe {
+			fields << Field{
+				name:             mystring(orig_fields[i].name)
+				org_name:         mystring(orig_fields[i].org_name)
+				table:            mystring(orig_fields[i].table)
+				org_table:        mystring(orig_fields[i].org_table)
+				db:               mystring(orig_fields[i].db)
+				catalog:          mystring(orig_fields[i].catalog)
+				def:              resolve_nil_str(orig_fields[i].def)
+				length:           orig_fields.length
+				max_length:       orig_fields.max_length
+				name_length:      orig_fields.name_length
+				org_name_length:  orig_fields.org_name_length
+				table_length:     orig_fields.table_length
+				org_table_length: orig_fields.org_table_length
+				db_length:        orig_fields.db_length
+				catalog_length:   orig_fields.catalog_length
+				def_length:       orig_fields.def_length
+				flags:            orig_fields.flags
+				decimals:         orig_fields.decimals
+				charsetnr:        orig_fields.charsetnr
+				type:             FieldType(orig_fields.type)
+			}
+		}
+	}
+	return fields
+}
+
+// str serializes the field.
+pub fn (f Field) str() string {
+	return '
+{
+	name: "${f.name}"
+	org_name: "${f.org_name}"
+	table: "${f.table}"
+	org_table: "${f.org_table}"
+	db: "${f.db}"
+	catalog: "${f.catalog}"
+	def: "${f.def}"
+	length: ${f.length}
+	max_length: ${f.max_length}
+	name_length: ${f.name_length}
+	org_name_length: ${f.org_name_length}
+	table_length: ${f.table_length}
+	org_table_length: ${f.org_table_length}
+	db_length: ${f.db_length}
+	catalog_length: ${f.catalog_length}
+	def_length: ${f.def_length}
+	flags: ${f.flags}
+	decimals: ${f.decimals}
+	charsetnr: ${f.charsetnr}
+	type: ${f.type.str()}
+}
+'
+}
+
+// free frees the memory used by a result.
+@[unsafe]
+pub fn (r &Result) free() {
+	mut thread_guard := mysql_thread_guard() or { return }
+	defer {
+		thread_guard.release()
+	}
+	C.mysql_free_result(r.result)
+}