ORM

Null

Use option fields in V structs for fields which can be NULL. Regular, non-option fields are defied as NOT NULL when creating tables.

Attributes

Structs

• [table: 'name'] sets a custom table name

Fields

• [primary] sets the field as the primary key
• [unique] sets the field as unique
• [unique: 'foo'] adds the field to a unique group
• [skip] or [sql: '-'] field will be skipped
• [sql: type] where type is a V type such as int or f64
• [sql: serial] lets the DB backend choose a column type for a auto-increment field
• [sql: 'name'] sets a custom column name for the field
• [sql_type: 'SQL TYPE'] sets the sql type which is used in sql
• [default: 'raw_sql] inserts raw_sql verbatim in a "DEFAULT" clause whencreate a new table, allowing for values like CURRENT_TIME- [fkey: 'parent_id'] sets foreign key for an field which holds an array

Usage

import time

@[table: 'foos']
struct Foo {
id          int         [primary; sql: serial]
name        string
created_at  time.Time   [default: 'CURRENT_TIME]
updated_at  ?string     [sql_type: 'TIMESTAMP]
deleted_at  ?time.Time
children    []Child     [fkey: 'parent_id']
}

struct Child {
id        int    [primary; sql: serial]
parent_id int
name      string
}

Create

sql db {
create table Foo
}!

Drop

sql db {
drop table Foo
}!

Insert

foo := Foo{
name:       'abc'
created_at: time.now()
// updated_at defaults to none
// deleted_at defaults to none
children: [
Child{
name: 'abc'
},
Child{
name: 'def'
},
]
}

sql db {
insert foo into Foo
}!

When inserting, [sql: serial] fields, and fields with a [default: 'raw_sql']attribute are not sent to the database when the value being sent is the defaultfor the V struct field (e.g., 0 int, or an empty string). This allows thedatabase to insert default values for auto-increment fields and where you havespecified a default.

Update

sql db {
update Foo set updated_at = time.now() where name == 'abc' && updated_at is none
}!

Note that is none and !is none can be used to select for NULL fields.

Delete

sql db {
delete from Foo where id > 10
}!

Select

result := sql db {
select from Foo where id == 1
}!

result := sql db {
select from Foo where id > 1 && name != 'lasanha' limit 5
}!

result := sql db {
select from Foo where id > 1 order by id
}!

Example

import db.pg

struct Member {
id         string [default: 'gen_random_uuid()'; primary; sql_type: 'uuid']
name       string
created_at string [default: 'CURRENT_TIMESTAMP'; sql_type: 'TIMESTAMP']
}

fn main() {
db := pg.connect(pg.Config{
host: 'localhost'
port: 5432
user: 'user'
password: 'password'
dbname: 'dbname'
})!

defer {
db.close()
}

sql db {
create table Member
}!

new_member := Member{
name: 'John Doe'
}

sql db {
insert new_member into Member
}!

selected_members := sql db {
select from Member where name == 'John Doe' limit 1
}!
john_doe := selected_members.first()

sql db {
update Member set name = 'Hitalo' where id == john_doe.id
}!
}

fn orm_select_gen(cfg SelectConfig, q string, num bool, qm string, start_pos int, where QueryData) string

Generates an sql select stmt, from universal parameter orm - See SelectConfig q, num, qm, start_pos - see orm_stmt_gen where - See QueryData

fn orm_stmt_gen(sql_dialect SQLDialect, table string, q string, kind StmtKind, num bool, qm string, start_pos int, data QueryData, where QueryData) (string, QueryData)

Generates an sql stmt, from universal parameter q - The quotes character, which can be different in every type, so it's variable num - Stmt uses nums at prepared statements (? or ?1) qm - Character for prepared statement (qm for question mark, as in sqlite) start_pos - When num is true, it's the start position of the counter

fn orm_table_gen(table string, q string, defaults bool, def_unique_len int, fields []TableField, sql_from_v fn (int) !string, alternative bool) !string

Generates an sql table stmt, from universal parameter table - Table name q - see orm_stmt_gen defaults - enables default values in stmt def_unique_len - sets default unique length for texts fields - See TableField sql_from_v - Function which maps type indices to sql type names alternative - Needed for msdb

interface Connection {
	@select(config SelectConfig, data QueryData, where QueryData) ![][]Primitive
	insert(table string, data QueryData) !
	update(table string, data QueryData, where QueryData) !
	delete(table string, where QueryData) !
	create(table string, fields []TableField) !
	drop(table string) !
	last_id() int
}

Interfaces gets called from the backend and can be implemented Since the orm supports arrays aswell, they have to be returned too. A row is represented as []Primitive, where the data is connected to the fields of the struct by their index. The indices are mapped with the SelectConfig.field array. This is the mapping for a struct. To have an array, there has to be an array of structs, basically [][]Primitive

Every function without last_id() returns an optional, which returns an error if present last_id returns the last inserted id of the db

type Primitive = InfixType
	| Null
	| bool
	| f32
	| f64
	| i16
	| i64
	| i8
	| int
	| string
	| time.Time
	| u16
	| u32
	| u64
	| u8

enum MathOperationKind {
	add // +
	sub // -
	mul // *
	div // /
}

enum OperationKind {
	neq // !=
	eq // ==
	gt // >
	lt // <
	ge // >=
	le // <=
	orm_like // LIKE
	is_null // IS NULL
	is_not_null // IS NOT NULL
}

enum OrderType {
	asc
	desc
}

enum SQLDialect {
	default
	sqlite
}

enum StmtKind {
	insert
	update
	delete
}

struct InfixType {
pub:
	name     string
	operator MathOperationKind
	right    Primitive
}

struct Null {}

struct QueryData {
pub:
	fields      []string
	data        []Primitive
	types       []int
	parentheses [][]int
	kinds       []OperationKind
	auto_fields []int
	is_and      []bool
}

Examples for QueryData in SQL: abc == 3 && b == 'test' => fields[abc, b]; data[3, 'test']; types[index of int, index of string]; kinds[.eq, .eq]; is_and[true]; Every field, data, type & kind of operation in the expr share the same index in the arrays is_and defines how they're addicted to each other either and or or parentheses defines which fields will be inside () auto_fields are indexes of fields where db should generate a value when absent in an insert

struct SelectConfig {
pub:
	table      string
	is_count   bool
	has_where  bool
	has_order  bool
	order      string
	order_type OrderType
	has_limit  bool
	primary    string = 'id' // should be set if primary is different than 'id' and 'has_limit' is false
	has_offset bool
	fields     []string
	types      []int
}

table - Table name is_count - Either the data will be returned or an integer with the count has_where - Select all or use a where expr has_order - Order the results order - Name of the column which will be ordered order_type - Type of order (asc, desc) has_limit - Limits the output data primary - Name of the primary field has_offset - Add an offset to the result fields - Fields to select types - Types to select

struct TableField {
pub:
	name        string
	typ         int
	nullable    bool
	default_val string
	attrs       []StructAttribute
	is_arr      bool
}