1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/pg/orm.v

292 lines
6.3 KiB
V
Raw Normal View History

2021-07-24 20:49:40 +03:00
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 {
2021-07-24 20:49:40 +03:00
query := orm.orm_select_gen(config, '"', true, '$', 1, where)
2022-05-26 22:53:09 +03:00
res := pg_stmt_worker(db, query, where, data)!
2022-05-26 22:53:09 +03:00
2021-07-24 20:49:40 +03:00
mut ret := [][]orm.Primitive{}
2022-05-26 22:53:09 +03:00
if config.is_count {
}
2021-07-24 20:49:40 +03:00
for row in res {
mut row_data := []orm.Primitive{}
for i, val in row.vals {
field := str_to_primitive(val, config.types[i])!
2021-07-24 20:49:40 +03:00
row_data << field
}
ret << row_data
}
return ret
}
// sql stmt
pub fn (db DB) insert(table string, data orm.QueryData) ! {
2022-07-27 00:59:32 +03:00
query, converted_data := orm.orm_stmt_gen(table, '"', .insert, true, '$', 1, data,
orm.QueryData{})
pg_stmt_worker(db, query, converted_data, orm.QueryData{})!
2021-07-24 20:49:40 +03:00
}
pub fn (db DB) update(table string, data orm.QueryData, where orm.QueryData) ! {
2022-07-27 00:59:32 +03:00
query, _ := orm.orm_stmt_gen(table, '"', .update, true, '$', 1, data, where)
pg_stmt_worker(db, query, data, where)!
2021-07-24 20:49:40 +03:00
}
pub fn (db DB) delete(table string, where orm.QueryData) ! {
2022-07-27 00:59:32 +03:00
query, _ := orm.orm_stmt_gen(table, '"', .delete, true, '$', 1, orm.QueryData{}, where)
pg_stmt_worker(db, query, orm.QueryData{}, where)!
2021-07-24 20:49:40 +03:00
}
pub fn (db DB) last_id() int {
2021-07-24 20:49:40 +03:00
query := 'SELECT LASTVAL();'
return db.q_int(query) or { 0 }
2021-07-24 20:49:40 +03:00
}
// table
pub fn (db DB) create(table string, fields []orm.TableField) ! {
2021-07-24 20:49:40 +03:00
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{})!
2021-07-24 20:49:40 +03:00
}
pub fn (db DB) drop(table string) ! {
query := 'DROP TABLE "${table}";'
pg_stmt_worker(db, query, orm.QueryData{}, orm.QueryData{})!
2021-07-24 20:49:40 +03:00
}
// utils
fn pg_stmt_worker(db DB, query string, data orm.QueryData, where orm.QueryData) ![]Row {
2021-07-24 20:49:40 +03:00
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, &char(query.str), param_vals.len, param_types.data,
param_vals.data, param_lens.data, param_formats.data, 0) // here, the last 0 means require text results, 1 - binary results
2021-07-24 20:49:40 +03:00
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) {
match data {
bool {
types << u32(Oid.t_bool)
vals << &char(&data)
2021-07-24 20:49:40 +03:00
lens << int(sizeof(bool))
formats << 1
}
2022-04-15 15:55:39 +03:00
u8 {
2021-07-24 20:49:40 +03:00
types << u32(Oid.t_char)
vals << &char(&data)
2022-04-15 15:55:39 +03:00
lens << int(sizeof(u8))
2021-07-24 20:49:40 +03:00
formats << 1
}
u16 {
types << u32(Oid.t_int2)
num := conv.htn16(data)
2021-07-24 20:49:40 +03:00
vals << &char(&num)
lens << int(sizeof(u16))
formats << 1
}
u32 {
types << u32(Oid.t_int4)
num := conv.htn32(data)
2021-07-24 20:49:40 +03:00
vals << &char(&num)
lens << int(sizeof(u32))
formats << 1
}
u64 {
types << u32(Oid.t_int8)
num := conv.htn64(data)
2021-07-24 20:49:40 +03:00
vals << &char(&num)
lens << int(sizeof(u64))
formats << 1
}
i8 {
types << u32(Oid.t_char)
vals << &char(&data)
2021-07-24 20:49:40 +03:00
lens << int(sizeof(i8))
formats << 1
}
i16 {
types << u32(Oid.t_int2)
num := conv.htn16(u16(data))
2021-07-24 20:49:40 +03:00
vals << &char(&num)
lens << int(sizeof(i16))
formats << 1
}
int {
types << u32(Oid.t_int4)
num := conv.htn32(u32(data))
2021-07-24 20:49:40 +03:00
vals << &char(&num)
lens << int(sizeof(int))
formats << 1
}
i64 {
types << u32(Oid.t_int8)
num := conv.htn64(u64(data))
2021-07-24 20:49:40 +03:00
vals << &char(&num)
lens << int(sizeof(i64))
formats << 1
}
f32 {
types << u32(Oid.t_float4)
vals << &char(&data)
2021-07-24 20:49:40 +03:00
lens << int(sizeof(f32))
formats << 1
}
f64 {
types << u32(Oid.t_float8)
vals << &char(&data)
2021-07-24 20:49:40 +03:00
lens << int(sizeof(f64))
formats << 1
}
string {
2022-07-27 00:59:32 +03:00
// 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 << u32(0)
vals << &char(data.str)
2021-07-24 20:49:40 +03:00
lens << data.len
formats << 0
}
time.Time {
datetime := data.format_ss()
types << u32(0)
vals << &char(datetime.str)
2022-07-27 00:59:32 +03:00
lens << datetime.len
formats << 0
2021-07-24 20:49:40 +03:00
}
orm.InfixType {
pg_stmt_match(mut types, mut vals, mut lens, mut formats, data.right)
}
}
}
fn pg_type_from_v(typ int) !string {
2021-07-24 20:49:40 +03:00
str := match typ {
orm.type_idx['i8'], orm.type_idx['i16'], orm.type_idx['u8'], orm.type_idx['u16'] {
2021-07-24 20:49:40 +03:00
'SMALLINT'
}
2022-05-26 22:53:09 +03:00
orm.type_idx['bool'] {
'BOOLEAN'
}
2022-07-27 00:59:32 +03:00
orm.type_idx['int'], orm.type_idx['u32'] {
2021-07-24 20:49:40 +03:00
'INT'
}
2022-07-27 00:59:32 +03:00
orm.time {
'TIMESTAMP'
}
2022-05-26 22:53:09 +03:00
orm.type_idx['i64'], orm.type_idx['u64'] {
2021-07-24 20:49:40 +03:00
'BIGINT'
}
2022-05-26 22:53:09 +03:00
orm.float[0] {
2021-07-24 20:49:40 +03:00
'REAL'
}
2022-05-26 22:53:09 +03:00
orm.float[1] {
2021-07-24 20:49:40 +03:00
'DOUBLE PRECISION'
}
orm.type_string {
2021-07-24 20:49:40 +03:00
'TEXT'
}
2022-06-16 20:19:49 +03:00
orm.serial {
2021-07-24 20:49:40 +03:00
'SERIAL'
}
else {
''
}
}
if str == '' {
return error('Unknown type ${typ}')
2021-07-24 20:49:40 +03:00
}
return str
}
fn str_to_primitive(str string, typ int) !orm.Primitive {
2021-07-24 20:49:40 +03:00
match typ {
// bool
2022-05-26 22:53:09 +03:00
orm.type_idx['bool'] {
return orm.Primitive(str == 't')
}
2021-07-24 20:49:40 +03:00
// i8
2022-05-26 22:53:09 +03:00
orm.type_idx['i8'] {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str.i8())
}
// i16
2022-05-26 22:53:09 +03:00
orm.type_idx['i16'] {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str.i16())
}
// int
2022-05-26 22:53:09 +03:00
orm.type_idx['int'] {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str.int())
}
// i64
2022-05-26 22:53:09 +03:00
orm.type_idx['i64'] {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str.i64())
}
// u8
orm.type_idx['u8'] {
2021-07-24 20:49:40 +03:00
data := str.i8()
2022-04-15 14:58:56 +03:00
return orm.Primitive(*unsafe { &u8(&data) })
2021-07-24 20:49:40 +03:00
}
// u16
2022-05-26 22:53:09 +03:00
orm.type_idx['u16'] {
2021-07-24 20:49:40 +03:00
data := str.i16()
return orm.Primitive(*unsafe { &u16(&data) })
}
// u32
2022-05-26 22:53:09 +03:00
orm.type_idx['u32'] {
2021-07-24 20:49:40 +03:00
data := str.int()
return orm.Primitive(*unsafe { &u32(&data) })
}
// u64
2022-05-26 22:53:09 +03:00
orm.type_idx['u64'] {
2021-07-24 20:49:40 +03:00
data := str.i64()
return orm.Primitive(*unsafe { &u64(&data) })
}
// f32
2022-05-26 22:53:09 +03:00
orm.type_idx['f32'] {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str.f32())
}
// f64
2022-05-26 22:53:09 +03:00
orm.type_idx['f64'] {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str.f64())
}
orm.type_string {
2021-07-24 20:49:40 +03:00
return orm.Primitive(str)
}
orm.time {
if str.contains_any(' /:-') {
date_time_str := time.parse(str)!
return orm.Primitive(date_time_str)
}
2021-07-24 20:49:40 +03:00
timestamp := str.int()
return orm.Primitive(time.unix(timestamp))
}
else {}
}
return error('Unknown field type ${typ}')
2021-07-24 20:49:40 +03:00
}