v/vlib/db/mysql/result.v

module mysql

pub struct Result {
	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() &&u8 {
	return C.mysql_fetch_row(r.result)
}

// n_rows returns the number of rows from a result.
pub fn (r Result) n_rows() u64 {
	return C.mysql_num_rows(r.result)
}

// n_fields returns the number of columns from a result.
pub fn (r Result) n_fields() int {
	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 rows := []Row{}
	nr_cols := r.n_fields()
	for rr := r.fetch_row(); rr; rr = r.fetch_row() {
		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 fields := []Field{}
	nr_cols := r.n_fields()
	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() {
	C.mysql_free_result(r.result)
}