Module orm stdlib

orm
Version:
0.3.3
License:
MIT
Dependencies from vmod:
0
Imports:
1
Imported by:
6
Repository:
OS-specific
Show selected OS-specific symbols.
Backend-specific
Show selected Backend-specific symbols.

Dependencies defined in v.mod

This section is empty.

Imports

  • Standard Library

Imported by

Overview

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
  • [nonull] set the field as not null
  • [skip] field will be skipped
  • [sql: type] where type is a V type such as int or f64, or special type serial
  • [sql: 'name'] sets a custom column name for the field
  • [sql_type: 'SQL TYPE'] sets the sql type which is used in sql
  • [default: 'sql defaults'] sets the default value or function when create a new table
  • [fkey: 'parent_id'] sets foreign key for an field which holds an array

Usage

struct Foo {
    id          int         [primary; sql: serial]
    name        string      [nonull]
    created_at  time.Time   [sql_type: 'DATETIME']
    updated_at  string      [sql_type: 'DATETIME']
    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

var := Foo{
    name:       'abc'
    created_at: time.now()
    updated_at: time.now().str()
    deleted_at: time.now()
    children: [
        Child{
            name: 'abc'
        },
        Child{
            name: 'def'
        },
    ]
}

sql db {
    insert var into Foo
}

Update

sql db {
    update Foo set name = 'cde', updated_at = time.now() where name == 'abc'
}

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'
    }) or {
        println(err)
        return
    }

    defer {
        db.close()
    }

    sql db {
        create table Member
    }

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

    sql db {
        insert new_member into Member
    }

    selected_member := sql db {
        select from Member where name == 'John Doe' limit 1
    }

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


Aliases

This section is empty.

Constants

#constant num64

num64       = [typeof[i64]().idx, typeof[u64]().idx]

#constant nums

nums        = [
	typeof[i8]().idx,
	typeof[i16]().idx,
	typeof[int]().idx,
	typeof[u8]().idx,
	typeof[u16]().idx,
	typeof[u32]().idx,
	typeof[bool]().idx,
]

#constant float

float       = [
	typeof[f32]().idx,
	typeof[f64]().idx,
]

#constant type_string

type_string = typeof[string]().idx

#constant time

time        = -2

#constant serial

serial      = -1

#constant type_idx

type_idx    = {
	'i8':     typeof[i8]().idx
	'i16':    typeof[i16]().idx
	'int':    typeof[int]().idx
	'i64':    typeof[i64]().idx
	'u8':     typeof[u8]().idx
	'u16':    typeof[u16]().idx
	'u32':    typeof[u32]().idx
	'u64':    typeof[u64]().idx
	'f32':    typeof[f32]().idx
	'f64':    typeof[f64]().idx
	'bool':   typeof[bool]().idx
	'string': typeof[string]().idx
}

#constant string_max_len

string_max_len = 2048

Sum types

#type Primitive

pub type Primitive = InfixType

Functions

#fn bool_to_primitive

fn bool_to_primitive(b bool) Primitive

#fn f32_to_primitive

fn f32_to_primitive(b f32) Primitive

#fn f64_to_primitive

fn f64_to_primitive(b f64) Primitive

#fn float_literal_to_primitive

fn float_literal_to_primitive(b f64) Primitive

float_literal_to_primitive handles float literal value

#fn i16_to_primitive

fn i16_to_primitive(b i16) Primitive

#fn i64_to_primitive

fn i64_to_primitive(b i64) Primitive

#fn i8_to_primitive

fn i8_to_primitive(b i8) Primitive

#fn infix_to_primitive

fn infix_to_primitive(b InfixType) Primitive

#fn int_literal_to_primitive

fn int_literal_to_primitive(b int) Primitive

int_literal_to_primitive handles int literal value

#fn int_to_primitive

fn int_to_primitive(b int) Primitive

#fn orm_select_gen

fn orm_select_gen(orm 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

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 because of quotation mark like in sqlite start_pos - When num is true, it's the start position of the counter

#fn orm_table_gen

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

#fn string_to_primitive

fn string_to_primitive(b string) Primitive

#fn time_to_primitive

fn time_to_primitive(b time.Time) Primitive

#fn u16_to_primitive

fn u16_to_primitive(b u16) Primitive

#fn u32_to_primitive

fn u32_to_primitive(b u32) Primitive

#fn u64_to_primitive

fn u64_to_primitive(b u64) Primitive

#fn u8_to_primitive

fn u8_to_primitive(b u8) Primitive

Structs

#struct QueryData

pub struct QueryData {
pub:
	fields      []string
	data        []Primitive
	types       []int
	parentheses [][]int
	kinds       []OperationKind
	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 ()

#struct InfixType

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

#struct TableField

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

#struct SelectConfig

pub 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

Interfaces

#interface Connection

pub 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

Enums

#enum OperationKind

pub enum OperationKind {
	neq // !=
	eq // ==
	gt // >
	lt // <
	ge // >=
	le // <=
	orm_like // LIKE
}

#fn (OperationKind) to_str

fn (kind OperationKind) to_str() string

#enum MathOperationKind

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

#enum StmtKind

pub enum StmtKind {
	insert
	update
	delete
}

#enum OrderType

pub enum OrderType {
	asc
	desc
}

#fn (OrderType) to_str

fn (kind OrderType) to_str() string

#enum SQLDialect

pub enum SQLDialect {
	default
	sqlite
}