module pg import orm import time import net.conv // sql expr pub fn (db DB) @select(config orm.SelectConfig, data orm.QueryData, where orm.QueryData) ![][]orm.Primitive { query := orm.orm_select_gen(config, '"', true, '$', 1, where) res := pg_stmt_worker(db, query, where, data)! mut ret := [][]orm.Primitive{} if config.is_count { } for row in res { mut row_data := []orm.Primitive{} for i, val in row.vals { field := str_to_primitive(val, config.types[i])! row_data << field } ret << row_data } return ret } // sql stmt pub fn (db DB) insert(table string, data orm.QueryData) ! { query, converted_data := orm.orm_stmt_gen(table, '"', .insert, true, '$', 1, data, orm.QueryData{}) pg_stmt_worker(db, query, converted_data, orm.QueryData{})! } pub fn (db DB) update(table string, data orm.QueryData, where orm.QueryData) ! { query, _ := orm.orm_stmt_gen(table, '"', .update, true, '$', 1, data, where) pg_stmt_worker(db, query, data, where)! } pub fn (db DB) delete(table string, where orm.QueryData) ! { query, _ := orm.orm_stmt_gen(table, '"', .delete, true, '$', 1, orm.QueryData{}, where) pg_stmt_worker(db, query, orm.QueryData{}, where)! } pub fn (db DB) last_id() orm.Primitive { query := 'SELECT LASTVAL();' id := db.q_int(query) or { 0 } return orm.Primitive(id) } // table pub fn (db DB) create(table string, fields []orm.TableField) ! { query := orm.orm_table_gen(table, '"', true, 0, fields, pg_type_from_v, false) or { return err } pg_stmt_worker(db, query, orm.QueryData{}, orm.QueryData{})! } pub fn (db DB) drop(table string) ! { query := 'DROP TABLE "${table}";' pg_stmt_worker(db, query, orm.QueryData{}, orm.QueryData{})! } // utils fn pg_stmt_worker(db DB, query string, data orm.QueryData, where orm.QueryData) ![]Row { mut param_types := []u32{} mut param_vals := []&char{} mut param_lens := []int{} mut param_formats := []int{} pg_stmt_binder(mut param_types, mut param_vals, mut param_lens, mut param_formats, data) pg_stmt_binder(mut param_types, mut param_vals, mut param_lens, mut param_formats, where) res := C.PQexecParams(db.conn, query.str, param_vals.len, param_types.data, param_vals.data, param_lens.data, param_formats.data, 0) return db.handle_error_or_result(res, 'orm_stmt_worker') } fn pg_stmt_binder(mut types []u32, mut vals []&char, mut lens []int, mut formats []int, d orm.QueryData) { for data in d.data { pg_stmt_match(mut types, mut vals, mut lens, mut formats, data) } } fn pg_stmt_match(mut types []u32, mut vals []&char, mut lens []int, mut formats []int, data orm.Primitive) { d := data match data { bool { types << u32(Oid.t_bool) vals << &char(&(d as bool)) lens << int(sizeof(bool)) formats << 1 } u8 { types << u32(Oid.t_char) vals << &char(&(d as u8)) lens << int(sizeof(u8)) formats << 1 } u16 { types << u32(Oid.t_int2) num := conv.htn16(&data) vals << &char(&num) lens << int(sizeof(u16)) formats << 1 } u32 { types << u32(Oid.t_int4) num := conv.htn32(&data) vals << &char(&num) lens << int(sizeof(u32)) formats << 1 } u64 { types << u32(Oid.t_int8) num := conv.htn64(&data) vals << &char(&num) lens << int(sizeof(u64)) formats << 1 } i8 { types << u32(Oid.t_char) vals << &char(&(d as i8)) lens << int(sizeof(i8)) formats << 1 } i16 { types << u32(Oid.t_int2) num := conv.htn16(unsafe { &u16(&data) }) vals << &char(&num) lens << int(sizeof(i16)) formats << 1 } int { types << u32(Oid.t_int4) num := conv.htn32(unsafe { &u32(&data) }) vals << &char(&num) lens << int(sizeof(int)) formats << 1 } i64 { types << u32(Oid.t_int8) num := conv.htn64(unsafe { &u64(&data) }) vals << &char(&num) lens << int(sizeof(i64)) formats << 1 } f32 { types << u32(Oid.t_float4) vals << &char(unsafe { &f32(&(d as f32)) }) lens << int(sizeof(f32)) formats << 1 } f64 { types << u32(Oid.t_float8) vals << &char(unsafe { &f64(&(d as f64)) }) lens << int(sizeof(f64)) formats << 1 } string { // If paramTypes is NULL, or any particular element in the array is zero, // the server infers a data type for the parameter symbol in the same way // it would do for an untyped literal string. types << &u8(0) vals << data.str lens << data.len formats << 0 } time.Time { datetime := ((d as time.Time).format_ss() as string) types << &u8(0) vals << datetime.str lens << datetime.len formats << 0 } orm.InfixType { pg_stmt_match(mut types, mut vals, mut lens, mut formats, data.right) } } } fn pg_type_from_v(typ int) !string { str := match typ { orm.type_idx['i8'], orm.type_idx['i16'], orm.type_idx['u8'], orm.type_idx['u16'] { 'SMALLINT' } orm.type_idx['bool'] { 'BOOLEAN' } orm.type_idx['int'], orm.type_idx['u32'] { 'INT' } orm.time { 'TIMESTAMP' } orm.type_idx['i64'], orm.type_idx['u64'] { 'BIGINT' } orm.float[0] { 'REAL' } orm.float[1] { 'DOUBLE PRECISION' } orm.string { 'TEXT' } orm.serial { 'SERIAL' } else { '' } } if str == '' { return error('Unknown type ${typ}') } return str } fn str_to_primitive(str string, typ int) !orm.Primitive { match typ { // bool orm.type_idx['bool'] { return orm.Primitive(str == 't') } // i8 orm.type_idx['i8'] { return orm.Primitive(str.i8()) } // i16 orm.type_idx['i16'] { return orm.Primitive(str.i16()) } // int orm.type_idx['int'] { return orm.Primitive(str.int()) } // i64 orm.type_idx['i64'] { return orm.Primitive(str.i64()) } // u8 orm.type_idx['u8'] { data := str.i8() return orm.Primitive(*unsafe { &u8(&data) }) } // u16 orm.type_idx['u16'] { data := str.i16() return orm.Primitive(*unsafe { &u16(&data) }) } // u32 orm.type_idx['u32'] { data := str.int() return orm.Primitive(*unsafe { &u32(&data) }) } // u64 orm.type_idx['u64'] { data := str.i64() return orm.Primitive(*unsafe { &u64(&data) }) } // f32 orm.type_idx['f32'] { return orm.Primitive(str.f32()) } // f64 orm.type_idx['f64'] { return orm.Primitive(str.f64()) } orm.string { return orm.Primitive(str) } orm.time { if str.contains_any(' /:-') { date_time_str := time.parse(str)! return orm.Primitive(date_time_str) } timestamp := str.int() return orm.Primitive(time.unix(timestamp)) } else {} } return error('Unknown field type ${typ}') }