toyorm

package module
v0.6.1-alpha Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 13, 2019 License: MIT Imports: 13 Imported by: 3

README

Toyorm

this is powerful sql orm library for Golang, have some funny features

Build Status codecov Go Report Card GoDoc Join the chat

Support database

sqlite3 mysql postgresql

Go version

version go-1.9

A Simple Example

here

Website Example

here

Database connection

import database driver

// if database is mysql
_ "github.com/go-sql-driver/mysql"
// if database is sqlite3
_ "github.com/mattn/go-sqlite3"
// when database is postgres
_ "github.com/lib/pq"

create a toy

// if database is mysql, make sure your mysql have toyorm_example schema
toy, err = toyorm.Open("mysql", "root:@tcp(localhost:3306)/toyorm_example?charset=utf8&parseTime=True")
// if database is sqlite3
toy,err = toyorm.Open("sqlite3", "toyorm_test.db")
// when database is postgres
toy, err = toyorm.Open("postgres", "user=postgres dbname=toyorm sslmode=disable")
Model definition
example
type Extra map[string]interface{}

func (e Extra) Scan(value interface{}) error {
     switch v := value.(type) {
     case string:
          return json.Unmarshal([]byte(v), e)
     case []byte:
          return json.Unmarshal(v, e)
     default:
          return errors.New("not support type")
     }
}

func (e Extra) Value() (driver.Value, error) {
     return json.Marshal(e)
}

type UserDetail struct {
     ID       int  `toyorm:"primary key;auto_increment"`
     UserID   uint `toyorm:"index"`
     MainPage string
     Extra    Extra `toyorm:"type:VARCHAR(1024)"`
}

type Blog struct {
     toyorm.ModelDefault
     UserID  uint   `toyorm:"index"`
     Title   string `toyorm:"index"`
     Content string
}

type User struct {
     toyorm.ModelDefault
     Name    string `toyorm:"unique index"`
     Age     int
     Sex     string
     Detail  *UserDetail
     Friends []*User
     Blog    []Blog
}
type translate

if sql type is not match, toyorm will ignore it in Sql Operation

you can use <type:sql_type> field tag to specified their sql type

the following type will auto translate to sql type

Go Type sql type
bool BOOLEAN
int8,int16,int32,uint8,uint16,uint32 INTEGER
int64,uint64,int,uint BIGINT
float32,float64 FLOAT
string VARCHAR(255)
time.Time TIMESTAMP
[]byte VARCHAR(255)
sql.NullBool BOOLEAN
sql.NullInt64 BIGINT
sql.NullFloat64 FLOAT
sql.NullString VARCHAR(255)
sql.RawBytes VARCHAR(255)

special fields

  1. special fields have some process in handlers, do not try to change it type or set it value
Field Name Type Description
CreatedAt time.Time generate when element be create
UpdatedAt time.Time generate when element be update/create
DeletedAt *time.Time delete mode is soft
Cas int (not support for sqlite3)save operation will failure when it's value modified by third party e.g in postgres:cas=1 insert xxx conflict(id) update cas = 2 where cas = 1

field tags

  1. tag format can be <key:value> or <key>

  2. the following is special tag

Key Value Description
index void or string use for optimization when search condition have this field,if you want make a combined,just set same index name with fields
unique index void or string have unique limit index, other same as index
primary key void allow multiple primary key,but some operation not support
- void ignore this field in sql
type string sql type
column string sql column name
auto_increment void recommend, if your table primary key have auto_increment attribute must add it
autoincrement void same as auto_increment
foreign key void to add foreign key feature when create table
alias string change field name with toyorm
join string to select related field when call brick.Join
belong to string to select related field when call brick.Preload with BelongTo container
one to one string to select related field when call brick.Preload with OneToOne container
one to many string to select related field when call brick.Preload with OneToMany container
default srring default value in database

other custom TAG will append to end of CREATE TABLE field

Bind models

  1. model kind must be a struct or a point with struct

  2. the model is what information that toyorm know about the table

brick := toy.Model(&User{})
// or
brick := toy.Model(User{})
Sql Operation
create table
var err error
_, err = toy.Model(&User{}).Debug().CreateTable()
// CREATE TABLE user (id BIGINT AUTO_INCREMENT,created_at TIMESTAMP NULL,updated_at TIMESTAMP NULL,deleted_at TIMESTAMP NULL,name VARCHAR(255),age BIGINT ,sex VARCHAR(255) , PRIMARY KEY(id))
// CREATE INDEX idx_user_deletedat ON user(deleted_at)
// CREATE UNIQUE INDEX udx_user_name ON user(name)
_, err =toy.Model(&UserDetail{}).Debug().CreateTable()
// CREATE TABLE user_detail (id BIGINT AUTO_INCREMENT,user_id BIGINT,main_page Text,extra VARCHAR(1024), PRIMARY KEY(id))
// CREATE INDEX idx_user_detail_userid ON user_detail(user_id)
_, err =toy.Model(&Blog{}).Debug().CreateTable()
// CREATE TABLE blog (id BIGINT AUTO_INCREMENT,created_at TIMESTAMP NULL,updated_at TIMESTAMP NULL,deleted_at TIMESTAMP NULL,user_id BIGINT,title VARCHAR(255),content VARCHAR(255) , PRIMARY KEY(id))
// CREATE INDEX idx_blog_deletedat ON blog(deleted_at)
// CREATE INDEX idx_blog_userid ON blog(user_id)
// CREATE INDEX idx_blog_title ON blog(title)
drop table
var err error
_, err =toy.Model(&User{}).Debug().DropTable()
// DROP TABLE user
_, err =toy.Model(&UserDetail{}).Debug().DropTable()
// DROP TABLE user_detail
_, err =toy.Model(&Blog{}).Debug().DropTable()
// DROP TABLE blog
insert/save data

// insert with autoincrement will set id to source data

user := &User{
    Name: "bigpigeon",
    Age:  18,
    Sex:  "male",
}
_, err = toy.Model(&User{}).Debug().Insert(&user)
// INSERT INTO user(created_at,updated_at,name,age,sex) VALUES(?,?,?,?,?) , args:[]interface {}{time.Time{wall:0xbe8df5112e7f07c8, ext:210013499, loc:(*time.Location)(0x141af80)}, time.Time{wall:0xbe8df5112e7f1768, ext:210017044, loc:(*time.Location)(0x141af80)}, "bigpigeon", 18, "male"}
// print user format with json
/* {
  "ID": 1,
  "CreatedAt": "2018-01-11T20:47:00.780077+08:00",
  "UpdatedAt": "2018-01-11T20:47:00.780081+08:00",
  "DeletedAt": null,
  "Name": "bigpigeon",
  "Age": 18,
  "Sex": "male",
  "Detail": null,
  "Friends": null,
  "Blog": null
}*/

// save data use "REPLACE INTO" when primary key exist

users := []User{
    {
        ModelDefault: toyorm.ModelDefault{ID: 1},
        Name:         "bigpigeon",
        Age:          18,
        Sex:          "male",
    },
    {
        Name: "fatpigeon",
        Age:  27,
        Sex:  "male",
    },
}
_, err = toy.Model(&User{}).Debug().Save(&user)
// SELECT id,created_at FROM user WHERE id IN (?), args:[]interface {}{0x1}
// REPLACE INTO user(id,created_at,updated_at,name,age,sex) VALUES(?,?,?,?,?,?) , args:[]interface {}{0x1, time.Time{wall:0x0, ext:63651278036, loc:(*time.Location)(nil)}, time.Time{wall:0xbe8dfb5511465918, ext:302600558, loc:(*time.Location)(0x141af80)}, "bigpigeon", 18, "male"}
// INSERT INTO user(created_at,updated_at,name,age,sex) VALUES(?,?,?,?,?) , args:[]interface {}{time.Time{wall:0xbe8dfb551131b7d8, ext:301251230, loc:(*time.Location)(0x141af80)}, time.Time{wall:0xbe8dfb5511465918, ext:302600558, loc:(*time.Location)(0x141af80)}, "fatpigeon", 27, "male"}
update
toy.Model(&User{}).Debug().Update(&User{
    Age: 4,
})
// UPDATE user SET updated_at=?,age=? WHERE deleted_at IS NULL, args:[]interface {}{time.Time{wall:0xbe8df4eb81b6c050, ext:233425327, loc:(*time.Location)(0x141af80)}, 4}
find

find one

var user User
_, err = toy.Model(&User{}).Debug().Find(&user}
// SELECT id,created_at,updated_at,deleted_at,name,age,sex FROM user WHERE deleted_at IS NULL LIMIT 1, args:[]interface {}(nil)
// print user format with json
/* {
  "ID": 1,
  "CreatedAt": "2018-01-11T12:47:01Z",
  "UpdatedAt": "2018-01-11T12:47:01Z",
  "DeletedAt": null,
  "Name": "bigpigeon",
  "Age": 4,
  "Sex": "male",
  "Detail": null,
  "Friends": null,
  "Blog": null
}*/

find multiple

var users []User
_, err = brick.Debug().Find(&users)
fmt.Printf("find users %s\n", JsonEncode(&users))

// SELECT id,created_at,updated_at,deleted_at,name,age,sex FROM user WHERE deleted_at IS NULL, args:[]interface {}(nil)
delete

delete with primary key

_, err = brick.Debug().Delete(&user)
// UPDATE user SET deleted_at=? WHERE id IN (?), args:[]interface {}{(*time.Time)(0xc4200f0520), 0x1}

delete with condition

_, err = brick.Debug().Where(toyorm.ExprEqual, Offsetof(User{}.Name), "bigpigeon").DeleteWithConditions()
// UPDATE user SET deleted_at=? WHERE name = ?, args:[]interface {}{(*time.Time)(0xc4200dbfa0), "bigpigeon"}
ToyBrick

use toy.Model will create a ToyBrick, you need use it to build grammar and operate the database

Where condition

affective update/find/delete operation

usage

where will clean old conditions and make new one

brick.Where(<expr>, <Key>, [value])

whereGroup add multiple condition with same expr

brick.WhereGroup(<expr>, <group>)

conditions will copy conditions and clean old conditions

brick.Conditions(<toyorm.Search>)

or & and condition will use or/and to link new condition when current condition is not nil

brick.Or().Condition(<expr>, <Key>, [value])
brick.Or().ConditionGroup(<expr>, <group>)
brick.And().Condition(<expr>, <Key>, [value])

or & and conditions will use or/and to link new conditions

brick.Or().Conditions(<toyorm.Search>)
brick.And().Conditions(<toyorm.Search>)
SearchExpr
SearchExpr to sql example
ExprAnd AND brick.WhereGroup(ExprAnd, Product{Name:"food one", Count: 4}) // WHERE name = "food one" AND Count = 4
ExprOr OR brick.WhereGroup(ExprOr, Product{Name:"food one", Count: 4}) // WHERE name = "food one" OR Count = "4"
ExprEqual = brick.Where(ExprEqual, OffsetOf(Product{}.Name), "food one") // WHERE name = "find one"
ExprNotEqual <> brick.Where(ExprNotEqual, OffsetOf(Product{}.Name), "food one") // WHERE name <> "find one"
ExprGreater > brick.Where(ExprGreater, OffsetOf(Product{}.Count), 3) // WHERE count > 3
ExprGreaterEqual >= brick.Where(ExprGreaterEqual, OffsetOf(Product{}.Count), 3) // WHERE count >= 3
ExprLess < brick.Where(ExprLess, OffsetOf(Product{}.Count), 3) // WHERE count < 3
ExprLessEqual <= brick.Where(ExprLessEqual, OffsetOf(Product{}.Count), 3) // WHERE count <= 3
ExprBetween Between brick.Where(ExprBetween, OffsetOf(Product{}.Count), [2]int{2,3}) // WHERE count BETWEEN 2 AND 3
ExprNotBetween NOT Between brick.Where(ExprNotBetween, OffsetOf(Product{}.Count), [2]int{2,3}) // WHERE count NOT BETWEEN 2 AND 3
ExprIn IN brick.Where(ExprIn, OffsetOf(Product{}.Count), []int{1, 2, 3}) // WHERE count IN (1,2,3)
ExprNotIn NOT IN brick.Where(ExprNotIn, OffsetOf(Product{}.Count), []int{1, 2, 3}) // WHERE count NOT IN (1,2,3)
ExprLike LIKE brick.Where(ExprLike, OffsetOf(Product{}.Name), "one") // WHERE name LIKE "one"
ExprNotLike NOT LIKE brick.Where(ExprNotLike, OffsetOf(Product{}.Name), "one") // WHERE name NOT LIKE "one"
ExprNull IS NULL brick.Where(ExprNull, OffsetOf(Product{}.DeletedAt)) // WHERE DeletedAt IS NULL
ExprNotNull IS NOT NULL brick.Where(ExprNotNull, OffsetOf(Product{}.DeletedAt)) // WHERE DeletedAt IS NOT NULL
example

single condition

brick = brick.Where(toyorm.ExprEqual, Offsetof(Product{}.Tag), "food")
or use string
brick = brick.Where("=", Offsetof(Product{}.Tag), "food")
// WHERE tag = "food"

combination condition

brick = brick.Where(toyorm.ExprEqual, Offsetof(Product{}.Count), 2).And().
    Condition(toyorm.ExprGreater, Offsetof(Product{}.Price), 3).Or().
    Condition(toyorm.ExprEqual, Offsetof(Product{}.Count), 4)
or use string
brick = brick.Where("=", Offsetof(Product{}.Count), 2).And().
    Condition(">", Offsetof(Product{}.Price), 3).Or().
    Condition("=", Offsetof(Product{}.Count), 4)
// WHERE count = 2 and price > 3 or count = 4

priority condition

brick.Where(toyorm.ExprGreater, Offsetof(Product{}.Price), 3).And().Conditions(
    brick.Where(toyorm.ExprEqual, Offsetof(Product{}.Count), 2).Or().
    Condition(toyorm.ExprEqual, Offsetof(Product{}.Count), 1).Search
)
or use string
brick.Where(">", Offsetof(Product{}.Price), 3).And().Conditions(
    brick.Where("=", Offsetof(Product{}.Count), 2).Or().
    Condition("=", Offsetof(Product{}.Count), 1).Search
)
// WHERE price > 3 and (count = 2 or count = 1)

brick.Conditions(
    brick.Where(toyorm.ExprEqual, Offsetof(Product{}.Count), 2).Or().
        Condition(toyorm.ExprEqual, Offsetof(Product{}.Count), 1).Search,
).And().Conditions(
    brick.Where(toyorm.ExprEqual, Offsetof(Product{}.Price), 3).Or().
        Condition(toyorm.ExprEqual, Offsetof(Product{}.Price), 4).Search,
)
or use string
brick.Conditions(
    brick.Where("=", Offsetof(Product{}.Count), 2).Or().
        Condition("=", Offsetof(Product{}.Count), 1).Search,
).And().Conditions(
    brick.Where("=", Offsetof(Product{}.Price), 3).Or().
        Condition("=", Offsetof(Product{}.Price), 4).Search,
)
// WHERE (count = ? OR count = ?) AND (price = ? OR price = ?)

limit & offset

brick := brick.Offset(2).Limit(2)
// LIMIT 2 OFFSET 2

order by

brick = brick.OrderBy(Offsetof(Product{}.Name))
// ORDER BY name

order by desc

brick = brick.OrderBy(brick.ToDesc(Offsetof(Product{}.Name)))
// ORDER BY name DESC
Template Field

sometimes the condition of sql is not a normal field, use TempField to wrapper normal field

brick = brick.Where("=", brick.TempField(Offsetof(Product{}.Name), "LOWER(%s)"), "name")
// WHERE LOWER(name) = ?
Transaction

start a transaction

brick = brick.Begin()

rollback all sql action

err = brick.Rollback()

commit all sql action

err = brick.Commit()
Debug

if Set debug all sql action will have log

brick = brick.Debug()
IgnoreMode

when I Update or Search with struct that have some zero value, did I update it ?

use IgnoreMode to differentiate what zero value should update

brick = brick.IgnoreMode(toyorm.Mode("Update"), toyorm.IgnoreZero ^ toyorm.IgnoreZeroLen)
// ignore all zeor value but excloud zero len slice
// now field = []int(nil) will ignore when update
// but field = []int{} will update when update
// now field = map[int]int(nil) will ignore when update
// but field = map[int]int{} will update when update

In default

Operation Mode affect
Insert IgnoreNo brick.Insert()
Replace IgnoreNo brick.Replace()
Condition IgnoreZero brick.WhereGroup(ExprAnd/ExprOr, )
Update IgnoreZero brick.Update()

All of IgnoreMode

mode effective
IgnoreFalse ignore field type is bool and value is false
IgnoreZeroInt ignore field type is int/uint/uintptr(incloud their 16,32,64 bit type) and value is 0
IgnoreZeroFloat ignore field type is float32/float64 and value is 0.0
IgnoreZeroComplex ignore field type is complex64/complex128 and value is 0 + 0i
IgnoreNilString ignore field type is string and value is ""
IgnoreNilPoint ignore field type is point/map/slice and value is nil
IgnoreZeroLen ignore field type is map/array/slice and len = 0
IgnoreNullStruct ignore field type is struct and value is zero value struct e.g type A struct{A string,B int}, A{"", 0} will be ignore
IgnoreNil ignore with IgnoreNilPoint and IgnoreZeroLen
IgnoreZero ignore all of the above
BindFields

if bind a not null fields, the IgnoreMode will failure

{
    var p Product
    result, err := brick.BindDefaultFields(Offsetof(p.Price), Offsetof(p.UpdatedAt)).Update(&Product{
        Price: 0,
    })
   // process error
   ...
}
var products []Product
result, err = brick.Find(&products)
// process error
...

for _, p := range products {
    fmt.Printf("product name %s, price %v\n", p.Name, p.Price)
}
Scope

use scope to do some custom operation

// desc all order by fields
brick.Scope(func(t *ToyBrick) *ToyBrick{

    newOrderBy := make([]*ModelFields, len(t.orderBy))
    for i, f := range t.orderBy {
        newOrderBy = append(newOrderBy, t.ToDesc(f))
    }
    newt := *t
    newt.orderBy = newOrderBy
    return &newt
})
Template

use template exec to replace default exec

now template only support Insert/Save/Update/Find

Custom insert
data := Product{
    Name:  "bag",
    Price: 9999,
    Count: 2,
    Tag:   "container",
}
result, err := brick.Template("INSERT INTO $ModelName($Columns) Values($Values)").Insert(&data)
// INSERT INTO product(created_at,updated_at,deleted_at,name,price,count,tag) Values(?,?,?,?,?,?,?) args:["2018-04-01T17:05:48.927499+08:00","2018-04-01T17:05:48.927499+08:00",null,"bag",9999,2,"container"]
Custom find
var data Product
// if driver is mysql use "USE INDEX" replace "INDEXED BY"
result, err := brick.Template("SELECT $Columns FROM $ModelName INDEXED BY idx_product_name $Conditions").
    Where("=", Offsetof(Product{}.Name), "bag").Find(&data)
// SELECT id,created_at,updated_at,deleted_at,name,price,count,tag FROM product INDEXED BY idx_product_name  WHERE deleted_at IS NULL AND name = ? LIMIT 1  args:["bag"]
Custom update

set count = count + 2

result, err := brick.Template(fmt.Sprintf("UPDATE $ModelName SET $Values,$FN-Count = $0x%x + ? $Conditions", Offsetof(Product{}.Count)), 2).
	Where("=", Offsetof(Product{}.Name), "bag").Update(&Product{Price: 200})
// UPDATE product SET updated_at = ?,price = ?,count = count + ?  WHERE deleted_at IS NULL AND name = ?  args:["2018-04-01T17:50:35.205377+08:00",200,2,"bag"]
Placeholder

follower placeholder use in template example

two special placeholder

  1. $FN- will convert struct field name to table field name e.g $FN-Name => name
  2. $0x will convert struct field offset to table field name e.g $0x58 => Count
action \ placeholder $ModelName $Columns $Values $Conditions
Find product id,data,... - WHERE ... ORDER BY ... GROUP BY ... LIMIT ... OFFSET ...
Insert product id,data,... ?,?,... WHERE ... ORDER BY ... GROUP BY ... LIMIT ... OFFSET ...
Save product id,data,... ?,?,... WHERE ... ORDER BY ... GROUP BY ... LIMIT ... OFFSET ...
Update product id,data,... id = ?,data = ?,... WHERE ... ORDER BY ... GROUP BY ... LIMIT ... OFFSET ...
Thread safe

Thread safe if you comply with the following agreement

  1. make sure ToyBrick object is read only, if you want to change it, create a new one

  2. do not use append to change ToyBrick's slice data,use make and copy to clone new slice

Preload

preload need have relation field and container field

relations field is used to link the main record and sub record

container field is used to hold sub record

Preload example

here

One to one

relation field at sub model

relation field name must be main model type name + main model primary key name

type User struct {
    toyorm.ModelDefault
    // container field
    Detail  *UserDetail
}

type UserDetail struct {
    ID       int    `toyorm:"primary key;auto_increment"`
    // relation field
    UserID   uint   `toyorm:"index"`
    MainPage string `toyorm:"type:Text"`
}

// load preload
brick = toy.Model(&User{}).Debug().Preload(OffsetOf(User.Detail)).Enter()
Belong to

relation field at main model

relation field name must be container field name + sub model primary key name

type User struct {
    toyorm.ModelDefault
    // container field
    Detail   *UserDetail
    // relation field
    DetailID int `toyorm:"index"`
}

type UserDetail struct {
    ID       int    `toyorm:"primary key;auto_increment"`
    MainPage string `toyorm:"type:Text"`
}
One to many

relation field at sub model

relation field name must be main model type name + main model primary key name

type User struct {
    toyorm.ModelDefault
    // container field
    Blog    []Blog
}

type Blog struct {
    toyorm.ModelDefault
    // relation field
    UserID  uint   `toyorm:"index"`
    Title   string `toyorm:"index"`
    Content string
}
Many to many

many to many not need to specified the relation ship,it relation field at middle model

type User struct {
    toyorm.ModelDefault
    // container field
    Friends    []*User
}
Load preload

when you finish model definition, it time to load preload

// create a main brick
brick = toy.Model(&User{})
// create a sub brick
subBrick := brick.Preload(OffsetOf(User.Blog))
// you can editing any attribute what you want, just like editing it on main model
subBrick = subBrick.Where(ExprEqual, OffsetOf(Blog.Title), "my blog")
// finished change ,use Enter() go back the main brick
brick = subBrick.Enter()

if you not like relation field name rule,use custom module to create it

// one to one custom
brick.CustomOneToOnePreload(<main container>, <sub relation>, [sub model struct])
// belong to custom
brick.CustomBelongToPreload(<main container>, <main relation>, [sub model struct])
// one to many
brick.CustomOneToManyPreload(<main container>, <sub relation>, [sub model struct])
// many to many
brick.CustomManyToManyPreload(<middle model struct>, <main container>, <main relation>, <sub relation>, [sub model struct])

or use tag declaration

type UserDetail struct {
    ID       int    `toyorm:"primary key;auto_increment"`
    MainID   uint32 `toyorm:"index;one to one:Detail"` // declaration the container field
    MainPage string `toyorm:"type:Text"`
    Extra    Extra  `toyorm:"type:VARCHAR(1024)"`
}

type Blog struct {
    toyorm.ModelDefault
    MainID  uint32 `toyorm:"index;one to many:Blog"` // declaration the container field
    Title   string `toyorm:"index"`
    Content string
}

type User struct {
    toyorm.ModelDefault
    Name    string `toyorm:"unique index"`
    Age     int
    Sex     string
    Detail  *UserDetail
    Friends []*User
    Blog    []Blog
}

// now custom relation field is MainID
brick = brick.Preload(Offsetof(User{}.Blog)).Enter()
brick = brick.Preload(Offsetof(User{}.Detail)).Enter()
Join

different association query is join query

Join Example

here

Model Define

use join tag to association related field/ join tag value must same as container field name

type Extra map[string]interface{}

func (e *Extra) Scan(value interface{}) error {
	switch v := value.(type) {
	case string:
		return json.Unmarshal([]byte(v), e)
	case []byte:
		return json.Unmarshal(v, e)
	default:
		return errors.New("not support type")
	}
}

func (e Extra) Value() (driver.Value, error) {
	return json.Marshal(e)
}

type Color struct {
	Name string `toyorm:"primary key;join:ColorDetail"`
	Code int32
}

type Comment struct {
	toyorm.ModelDefault
	ProductDetailProductID uint32 `toyorm:"index"`
	Data                   string `toyorm:"type:VARCHAR(1024)"`
}

type ProductDetail struct {
	ProductID  uint32 `toyorm:"primary key;join:Detail"`
	Title      string
	CustomPage string `toyorm:"type:text"`
	Extra      Extra  `toyorm:"type:VARCHAR(2048)"`
	Color      string `toyorm:"join:ColorDetail"`
	ColorJoin  Color  `toyorm:"alias:ColorDetail"`
	Comment    []Comment
}

type Product struct {
	ID        uint32     `toyorm:"primary key;auto_increment;join:Detail"`
	CreatedAt time.Time  `toyorm:"NULL"`
	DeletedAt *time.Time `toyorm:"NULL"`
	Name      string
	Count     int
	Price     float64
	Detail    *ProductDetail
}
Join in Find

Swap on Join just like Enter on Preload, can back to previous data

brick := toy.Model(&tab).Debug().
    Join(Offsetof(tab.Detail)).
    Join(Offsetof(detailTab.ColorJoin)).Swap().Swap()
var scanData []Product
result, err = brick.Find(&scanData)
// SELECT m.id,m.created_at,m.deleted_at,m.name,m.count,m.price,m_0.product_id,m_0.title,m_0.custom_page,m_0.extra,m_0.color,m_0_0.name,m_0_0.code FROM `product` as `m` JOIN `product_detail` AS `m_0` ON m.id = m_0.product_id JOIN `color` AS `m_0_0` ON m_0.color = m_0_0.name   WHERE m.deleted_at IS NULL

use Join to switch current model and add conditions

// where Product.Name = "clean stick" or Color.Name = "black"
brick := toy.Model(&tab).Debug().Where("=", Offsetof(tab.Name), "clean stick").
    Join(Offsetof(tab.Detail)).
    Join(Offsetof(detailTab.ColorJoin)).Or().Condition("=", Offsetof(colorTab.Name), "black").
    Swap().Swap()
var scanData []Product
result, err = brick.Find(&scanData)
// SELECT m.id,m.created_at,m.deleted_at,m.name,m.count,m.price,m_0.product_id,m_0.title,m_0.custom_page,m_0.extra,m_0.color,m_0_0.name,m_0_0.code FROM `product` as `m` JOIN `product_detail` AS `m_0` ON m.id = m_0.product_id JOIN `color` AS `m_0_0` ON m_0.color = m_0_0.name   WHERE m.deleted_at IS NULL AND (m.name = ? OR m_0_0.name = ?)  args:["clean stick","black"]

set order just like add conditions

// where Product.Name = "clean stick" or Color.Name = "black"
brick := toy.Model(&tab).Debug().
    Join(Offsetof(tab.Detail)).
    Join(Offsetof(detailTab.ColorJoin)).OrderBy(Offsetof(colorTab.Name)).
    Swap().Swap()
var scanData []Product
result, err = brick.Find(&scanData)
// SELECT m.id,m.created_at,m.deleted_at,m.name,m.count,m.price,m_0.product_id,m_0.title,m_0.custom_page,m_0.extra,m_0.color,m_0_0.name,m_0_0.code FROM `product` as `m` JOIN `product_detail` AS `m_0` ON m.id = m_0.product_id JOIN `color` AS `m_0_0` ON m_0.color = m_0_0.name   WHERE m.deleted_at IS NULL ORDER BY m_0_0.name

also can set GroupBy but here not example

Preload On Join

Preload method also work on Join mode

brick := toy.Model(&tab).Debug().
    Join(Offsetof(tab.Detail)).Preload(Offsetof(detailTab.Comment)).Enter().
    Join(Offsetof(detailTab.ColorJoin)).Swap().Swap()
var scanData []Product
result, err = brick.Find(&scanData)
// SELECT m.id,m.created_at,m.deleted_at,m.name,m.count,m.price,m_0.product_id,m_0.title,m_0.custom_page,m_0.extra,m_0.color,m_0_0.name,m_0_0.code FROM `product` as `m` JOIN `product_detail` AS `m_0` ON m.id = m_0.product_id JOIN `color` AS `m_0_0` ON m_0.color = m_0_0.name   WHERE m.deleted_at IS NULL
// SELECT id,created_at,updated_at,deleted_at,product_detail_product_id,data FROM `comment`   WHERE deleted_at IS NULL AND product_detail_product_id IN (?,?,?)  args:[1,2,3]
Custom Table Name

custom your table name with different platform

type User struct {
    ID uint32 `toyorm:"primary key"`
    Name string `toyorm:"index"`
    Platform string `toyorm:"-"`
}
func (u *User) TableName() string {
    return "user_" + u.Platform
}

brick := toy.Model(&User{Platform:"p1"}).Debug()
brick.CreateTable()
// CREATE TABLE user_p1 (id BIGINT AUTO_INCREMENT,name VARCHAR(255), PRIMARY KEY(id))
brick := toy.Model(&User{Platform:"p2"}).Debug()
brick.CreateTable()
// CREATE TABLE user_p2 (id BIGINT AUTO_INCREMENT,name VARCHAR(255), PRIMARY KEY(id))

table name method also work on Preload and Join

type UserDetail struct {
    ID uint32 `toyorm:"primary key"`
    UserID uint32
    Data string
}
func (u *UserDetail) TableName() string {
    return "user_detail_" + u.Platform
}

type User struct {
    ID uint32 `toyorm:"primary key"`
    Name string `toyorm:"index"`
    Detail *UserDetail
    Platform string `toyorm:"-"`
}
func (u *User) TableName() string {
    return "user_" + u.Platform
}

brick := toy.Model(&User{Platform:"p1", Detail:&UserDetail{Platform:"p1"}}).Debug().
    Preload(Offsetof(User{}.UserDetail)).Enter()
brick.CreateTable()
// CREATE TABLE user_p1 (id BIGINT AUTO_INCREMENT,name VARCHAR(255), PRIMARY KEY(id))
// CREATE TABLE user_detail_p1 (id BIGINT AUTO_INCREMENT, user_id BIGINT, data VARCHAR(255), PRIMARY KEY(id))

in one to many or many to many mode , need to set it's first element val

type Address struct {
    ID uint32 `toyorm:"primary key"`
    UserID uint32
    Addr string
    Platform string `toyorm:"-"`
}
func (a *Address) TableName() string {
    return "address_" + a.Platform
}
type User struct {
    ID uint32 `toyorm:"primary key"`
    Name string `toyorm:"index"`
    Addresses []Address
    Platform string `toyorm:"-"`
}
func (u *User) TableName() string {
    return "user_" + u.Platform
}

brick := toy.Model(&User{Platform:"p1", Addresses:[]Address{{Platform:"p1"}}}).Debug().
    Preload(Offsetof(User{}.Addresses)).Enter()
brick.CreateTable()
// CREATE TABLE user_p1 (id BIGINT AUTO_INCREMENT,name VARCHAR(255), PRIMARY KEY(id))
// CREATE TABLE address_p1 (id BIGINT AUTO_INCREMENT, user_id BIGINT, addr VARCHAR(255), PRIMARY KEY(id))
Result

use Report to view sql action

report format

insert

user := User{
    Detail: &UserDetail{
        MainPage: "some html code with you page",
        Extra:    Extra{"title": "my blog"},
    },
    Blog: []Blog{
        {Title: "how to write a blog", Content: "first ..."},
        {Title: "blog introduction", Content: "..."},
    },
    Friends: []*User{
        {
            Detail: &UserDetail{
                MainPage: "some html code with you page",
                Extra:    Extra{},
            },
            Blog: []Blog{
                {Title: "some python tech", Content: "first ..."},
                {Title: "my eleme_union_meal usage", Content: "..."},
            },
            Name: "fatpigeon",
            Age:  18,
            Sex:  "male",
        },
    },
    Name: "bigpigeon",
    Age:  18,
    Sex:  "male",
}
result, err = brick.Save(&user)
// error process ...
fmt.Printf("report:\n%s\n", result.Report())

/*
// [0, ] means affected the 0 element
// [0-0, ] means affected the 0 element the 0 sub element
report:
[0, ] INSERT INTO user(created_at,updated_at,deleted_at,name,age,sex) VALUES(?,?,?,?,?,?)  args:["2018-02-28T17:31:20.012285+08:00","2018-02-28T17:31:20.012285+08:00",null,"bigpigeon",18,"male"]
	preload Detail
	[0-, ] INSERT INTO user_detail(user_id,main_page,extra) VALUES(?,?,?)  args:[1,"some html code with you page",{"title":"my blog"}]
	preload Blog
	[0-0, ] INSERT INTO blog(created_at,updated_at,deleted_at,user_id,title,content) VALUES(?,?,?,?,?,?)  args:["2018-02-28T17:31:20.013968+08:00","2018-02-28T17:31:20.013968+08:00",null,1,"how to write a blog","first ..."]
	[0-1, ] INSERT INTO blog(created_at,updated_at,deleted_at,user_id,title,content) VALUES(?,?,?,?,?,?)  args:["2018-02-28T17:31:20.013968+08:00","2018-02-28T17:31:20.013968+08:00",null,1,"blog introduction","..."]
	preload Friends
	[0-0, ] INSERT INTO user(created_at,updated_at,deleted_at,name,age,sex) VALUES(?,?,?,?,?,?)  args:["2018-02-28T17:31:20.015207+08:00","2018-02-28T17:31:20.015207+08:00",null,"fatpigeon",18,"male"]
		preload Detail
		[0-0-, ] INSERT INTO user_detail(user_id,main_page,extra) VALUES(?,?,?)  args:[2,"some html code with you page",{}]
		preload Blog
		[0-0-0, ] INSERT INTO blog(created_at,updated_at,deleted_at,user_id,title,content) VALUES(?,?,?,?,?,?)  args:["2018-02-28T17:31:20.016389+08:00","2018-02-28T17:31:20.016389+08:00",null,2,"some python tech","first ..."]
		[0-0-1, ] INSERT INTO blog(created_at,updated_at,deleted_at,user_id,title,content) VALUES(?,?,?,?,?,?)  args:["2018-02-28T17:31:20.016389+08:00","2018-02-28T17:31:20.016389+08:00",null,2,"my eleme_union_meal usage","..."]
*/

find

brick := brick.Preload(Offsetof(User{}.Friends)).
    Preload(Offsetof(User{}.Detail)).Enter().
    Preload(Offsetof(User{}.Blog)).Enter().
    Enter()
var users []User
result, err = brick.Find(&users)
// some error process
...
// print the report
fmt.Printf("report:\n%s\n", result.Report())

// report log
/*
report:
[0, 1, ] SELECT id,created_at,updated_at,deleted_at,name,age,sex FROM user WHERE deleted_at IS NULL  args:null
	preload Detail
	[0-, 1-, ] SELECT id,user_id,main_page,extra FROM user_detail WHERE user_id IN (?,?)  args:[2,1]
	preload Blog
	[0-0, 0-1, 1-0, 1-1, ] SELECT id,created_at,updated_at,deleted_at,user_id,title,content FROM blog WHERE deleted_at IS NULL AND user_id IN (?,?)  args:[1,2]
	preload Friends
	[0-0, ] SELECT id,created_at,updated_at,deleted_at,name,age,sex FROM user WHERE deleted_at IS NULL AND id IN (?)  args:[2]
		preload Detail
		[0-0-, ] SELECT id,user_id,main_page,extra FROM user_detail WHERE user_id IN (?)  args:[2]
		preload Blog
		[0-0-0, 0-0-1, ] SELECT id,created_at,updated_at,deleted_at,user_id,title,content FROM blog WHERE deleted_at IS NULL AND user_id IN (?)  args:[2]
*/

use Err to view sql action error

var users []struct {
    ID     uint32
    Age    bool
    Detail *UserDetail
    Blog   []Blog
}
result, err = brick.Find(&users)
if err != nil {
    panic(err)
}
if err := result.Err(); err != nil {
    fmt.Printf("error:\n%s\n", err)
}

/*
error:
SELECT id,age FROM user WHERE deleted_at IS NULL  args:null errors(
	[0]sql: Scan error on column index 1: sql/driver: couldn't convert "18" into type bool
	[1]sql: Scan error on column index 1: sql/driver: couldn't convert "18" into type bool
)
*/
Selector

toyorm support following selector

operation \ selector OffsetOf Name string map[OffsetOf]interface{} map[string]interface{} struct
Update no no yes yes yes
Insert no no yes yes yes
Save no no yes yes yes
Where & Conditions yes yes no no no
WhereGroup & ConditionGroup no no yes yes yes
BindFields yes yes no no no
Preload & Custom Preload yes yes no no no
OrderBy yes yes no no no
Find no no no no yes

Collection

collection provide multiple database operation

ToyCollection

ToyCollection is basic of the collection , it like Toy

toyCollection, err = toyorm.OpenCollection("sqlite3", []string{"", ""}...)
CollectionBrick

CollectionBrick use to build grammar and operate the database, like ToyBrick

brick := toyCollection.Model(&User{})
Selector

Selector use to select database when Insert/Save

CollectionBrick has default selector dbPrimaryKeySelector

you can custom db selector

func idSelector(n int, keys ...interface{}) int {
	sum := 0
	for _, k := range keys {
		switch val := k.(type) {
		case int:
			sum += val
		case int32:
			sum += int(val)
		case uint:
			sum += int(val)
		case uint32:
			sum += int(val)
		default:
			panic("primary key type not match")
		}
	}
	return sum % n
}

brick = brick.Selector(idSelector)
id generator

in this mode,Field tag auto_increment was invalid

you need create id generator

// a context id generator
type IDGenerator map[*toyorm.Model]chan int

func (g IDGenerator) CollectionIDGenerate(ctx *toyorm.CollectionContext) error {
	if g[ctx.Brick.Model] == nil {
		idGenerate := make(chan int)
		go func() {
			current := 1
			for {
				// if have redis, use redis-cli
				idGenerate <- current
				current++
			}

		}()
		g[ctx.Brick.Model] = idGenerate
	}
	primaryKey := ctx.Brick.Model.GetOnePrimary()
	for _, record := range ctx.Result.Records.GetRecords() {
		if field := record.Field(primaryKey.Name()); field.IsValid() == false || toyorm.IsZero(field) {
			v := <-g[ctx.Brick.Model]
			record.SetField(primaryKey.Name(), reflect.ValueOf(v))
		}
	}
	return nil

}

// set id genetor to model context
toy.SetModelHandlers("Save", brick.Model, toyorm.CollectionHandlersChain{idGenerate.CollectionIDGenerate})
// set id genetor to all preload models context
for _, pBrick := range brick.MapPreloadBrick {
		toy.SetModelHandlers("Save", pBrick.Model, toyorm.CollectionHandlersChain{idGenerate.CollectionIDGenerate})
}
sql action

toy collection sql action is same as Toy

insert

users := []User{
    {Name: "Turing"},
    {Name: "Shannon"},
    {Name: "Ritchie"},
    {Name: "Jobs"},
}
result, err = userBrick.Insert(&users)
// error process

// view report log
fmt.Printf("report:\n%s", result.Report())

find

var jobs User
result, err = userBrick.Where(toyorm.ExprEqual, Offsetof(User{}.Name), "Jobs").Find(&jobs)
// error process

// view report log
fmt.Printf("report:\n%s", result.Report())

delete

result, err = userBrick.Delete(&jobs)
// error process

// view report log
fmt.Printf("delete report:\n%s\n", result.Report())
collection example

here

toy-doctor

parameter check within ToyBrick method call

toy-doctor

Documentation

Index

Constants

View Source 
const (
	IgnoreNo    = IgnoreMode(0)
	IgnoreFalse = IgnoreMode(1 << iota)
	IgnoreZeroInt
	IgnoreZeroFloat
	IgnoreZeroComplex
	IgnoreNilString
	IgnoreNilPoint
	IgnoreZeroLen
	IgnoreNullStruct
	IgnoreNil  = IgnoreNilPoint | IgnoreZeroLen
	IgnoreZero = IgnoreFalse | IgnoreZeroInt | IgnoreZeroFloat | IgnoreZeroComplex | IgnoreNilString | IgnoreNilPoint | IgnoreZeroLen | IgnoreNullStruct
)
View Source 
const (
	ExprIgnore       = ""
	ExprAnd          = "AND"
	ExprOr           = "OR"
	ExprNot          = "NOT"
	ExprEqual        = "="
	ExprNotEqual     = "<>"
	ExprGreater      = ">"
	ExprGreaterEqual = ">="
	ExprLess         = "<"
	ExprLessEqual    = "<="
	ExprBetween      = "BETWEEN"
	ExprNotBetween   = "NOT BETWEEN"
	ExprIn           = "IN"
	ExprNotIn        = "NOT IN"
	ExprLike         = "LIKE"
	ExprNotLike      = "NOT LIKE"
	ExprNull         = "NULL"
	ExprNotNull      = "NOT NULL"
)

Variables

View Source 
var (
	ErrInvalidTag        = errors.New("invalid tag")
	ErrInvalidSearchTree = errors.New("invalid search tree")
	ErrNotMatchDialect   = errors.New("not match dialect")
)

Functions

func CollectionHandlerAssignToAllDb 

func CollectionHandlerAssignToAllDb(ctx *CollectionContext) error

assign after handlers to all db

func CollectionHandlerCreateTable 

func CollectionHandlerCreateTable(ctx *CollectionContext) error

func CollectionHandlerDropTable 

func CollectionHandlerDropTable(ctx *CollectionContext) (err error)

func CollectionHandlerDropTablePreload 

func CollectionHandlerDropTablePreload(option string) func(ctx *CollectionContext) error

preload schedule oneToOne -> oneToMany -> current model -> manyToMany(sub -> middle) -> Next() -> belongTo

func CollectionHandlerExistTableAbort 

func CollectionHandlerExistTableAbort(ctx *CollectionContext) error

func CollectionHandlerFind 

func CollectionHandlerFind(ctx *CollectionContext) error

func CollectionHandlerFindOne 

func CollectionHandlerFindOne(ctx *CollectionContext) error

func CollectionHandlerFindOneAssignDbIndex 

func CollectionHandlerFindOneAssignDbIndex(ctx *CollectionContext) error

func CollectionHandlerInsert 

func CollectionHandlerInsert(ctx *CollectionContext) error

func CollectionHandlerInsertAssignDbIndex 

func CollectionHandlerInsertAssignDbIndex(ctx *CollectionContext) error

func CollectionHandlerInsertTimeGenerate 

func CollectionHandlerInsertTimeGenerate(ctx *CollectionContext) error

func CollectionHandlerNotExistTableAbort 

func CollectionHandlerNotExistTableAbort(ctx *CollectionContext) error

func CollectionHandlerPreloadContainerCheck 

func CollectionHandlerPreloadContainerCheck(ctx *CollectionContext) error

func CollectionHandlerPreloadFind 

func CollectionHandlerPreloadFind(ctx *CollectionContext) error

func CollectionHandlerPreloadInsertOrSave 

func CollectionHandlerPreloadInsertOrSave(option string) func(*CollectionContext) error

func CollectionHandlerSave 

func CollectionHandlerSave(ctx *CollectionContext) error

func CollectionHandlerSaveTimeGenerate 

func CollectionHandlerSaveTimeGenerate(ctx *CollectionContext) error

func CollectionHandlerSimplePreload 

func CollectionHandlerSimplePreload(option string) func(ctx *CollectionContext) error

preload schedule belongTo -> Next() -> oneToOne -> oneToMany -> manyToMany(sub -> middle)

func CollectionHandlerSoftDeleteCheck 

func CollectionHandlerSoftDeleteCheck(ctx *CollectionContext) error

func CollectionHandlerUSave 

func CollectionHandlerUSave(ctx *CollectionContext) error

func CollectionHandlerUpdate 

func CollectionHandlerUpdate(ctx *CollectionContext) error

func CollectionHandlerUpdateTimeGenerate 

func CollectionHandlerUpdateTimeGenerate(ctx *CollectionContext) error

func DefaultCollectionTemplateExec 

func DefaultCollectionTemplateExec(brick *CollectionBrick) map[string]BasicExec

func DefaultTemplateExec 

func DefaultTemplateExec(brick *ToyBrick) map[string]BasicExec

func GetBelongsIDFieldName 

func GetBelongsIDFieldName(subModel *Model, containerField Field) string

func GetRelationFieldName 

func GetRelationFieldName(subModel *Model) string

generate a default field name with relation model

func GetStructFields 

func GetStructFields(_type reflect.Type) []reflect.StructField

get all StructField with struct field and its embed field

func GetStructValueFields 

func GetStructValueFields(value reflect.Value) []reflect.Value

get all Value with struct field and its embed struct field

func GetTagKeyVal 

func GetTagKeyVal(tag string) []*tagKeyValue

func HandlerCasVersionPushOne 

func HandlerCasVersionPushOne(ctx *Context) error

func HandlerCollectionCasVersionPushOne 

func HandlerCollectionCasVersionPushOne(ctx *CollectionContext) error

func HandlerCollectionHardDelete 

func HandlerCollectionHardDelete(ctx *CollectionContext) error

func HandlerCollectionPreloadDelete 

func HandlerCollectionPreloadDelete(ctx *CollectionContext) error

func HandlerCollectionSearchWithPrimaryKey 

func HandlerCollectionSearchWithPrimaryKey(ctx *CollectionContext) error

func HandlerCollectionSoftDelete 

func HandlerCollectionSoftDelete(ctx *CollectionContext) error

func HandlerCollectionSoftDeleteCheck 

func HandlerCollectionSoftDeleteCheck(ctx *CollectionContext) error

func HandlerCreateTable 

func HandlerCreateTable(ctx *Context) error

func HandlerCreateTablePreload 

func HandlerCreateTablePreload(option string) func(ctx *Context) error

preload schedule belongTo -> Next() -> oneToOne -> oneToMany -> manyToMany(sub -> middle)

func HandlerDropTable 

func HandlerDropTable(ctx *Context) (err error)

func HandlerDropTablePreload 

func HandlerDropTablePreload(option string) func(ctx *Context) error

preload schedule oneToOne -> oneToMany -> current model -> manyToMany(sub -> middle) -> Next() -> belongTo

func HandlerExistTableAbort 

func HandlerExistTableAbort(ctx *Context) error

func HandlerFind 

func HandlerFind(ctx *Context) error

func HandlerHardDelete 

func HandlerHardDelete(ctx *Context) error

func HandlerInsert 

func HandlerInsert(ctx *Context) error

func HandlerInsertTimeGenerate 

func HandlerInsertTimeGenerate(ctx *Context) error

func HandlerNotExistTableAbort 

func HandlerNotExistTableAbort(ctx *Context) error

func HandlerPreloadContainerCheck 

func HandlerPreloadContainerCheck(ctx *Context) error

func HandlerPreloadDelete 

func HandlerPreloadDelete(ctx *Context) error

func HandlerPreloadFind 

func HandlerPreloadFind(ctx *Context) error

func HandlerPreloadInsertOrSave 

func HandlerPreloadInsertOrSave(option string) func(*Context) error

func HandlerPreloadOnJoinFind 

func HandlerPreloadOnJoinFind(ctx *Context) error

func HandlerSave 

func HandlerSave(ctx *Context) error

if have not primary ,try to insert else try to replace

func HandlerSaveTimeGenerate 

func HandlerSaveTimeGenerate(ctx *Context) error

func HandlerSearchWithPrimaryKey 

func HandlerSearchWithPrimaryKey(ctx *Context) error

func HandlerSoftDelete 

func HandlerSoftDelete(ctx *Context) error

func HandlerSoftDeleteCheck 

func HandlerSoftDeleteCheck(ctx *Context) error

func HandlerUSave 

func HandlerUSave(ctx *Context) error

func HandlerUSaveTimeGenerate 

func HandlerUSaveTimeGenerate(ctx *Context) error

func HandlerUpdate 

func HandlerUpdate(ctx *Context) error

func HandlerUpdateTimeGenerate 

func HandlerUpdateTimeGenerate(ctx *Context) error

func IntKind 

func IntKind(kind reflect.Kind) bool

func IsZero 

func IsZero(v reflect.Value) bool

to check value is zero

func LoopDivePtr 

func LoopDivePtr(vValue reflect.Value) reflect.Value

func LoopDiveSliceAndPtr 

func LoopDiveSliceAndPtr(vValue reflect.Value) reflect.Value

loop to get ptr value elem if its type is ptr, get it's elem if it's type is slice get it's first elem or zero value's elem type loop get will not change the source object

func LoopIndirect 

func LoopIndirect(vValue reflect.Value) reflect.Value

loop to get ptr value elem when its type is not ptr

func LoopIndirectAndNew 

func LoopIndirectAndNew(vValue reflect.Value) reflect.Value

loop to get ptr value elem when its type is not ptr and if value is zero, set a new one

func LoopTypeIndirect 

func LoopTypeIndirect(_type reflect.Type) reflect.Type

loop to get ptr type elem when its type is not ptr/slice

func LoopTypeIndirectSliceAndPtr 

func LoopTypeIndirectSliceAndPtr(_type reflect.Type) reflect.Type

loop to get ptr/slice type elem when its type is not ptr/slice

func ModelName 

func ModelName(val reflect.Value) string

get model name with type

func NewField 

func NewField(f *reflect.StructField, fieldVal reflect.Value, table_name string) *modelField

func SafeAppend 

func SafeAppend(l reflect.Value, x ...reflect.Value) reflect.Value

if value type is ptr to l elem type , try to get its elem and append to l if l elem type is ptr to x type , try to make x ptr and append to l

func SqlNameConvert 

func SqlNameConvert(name string) string

column convert rule: User => user UserName => user_name UserID => user_id OneToOne => one_to_one

func ToSqlType 

func ToSqlType(_type reflect.Type) (sqlType string)

Types

type AffectNode 

type AffectNode struct {
	Val    int
	Ignore bool
	Next   *AffectNode
}

func IgnoreAffectNode 

func IgnoreAffectNode(next *AffectNode) *AffectNode

func NewAffectNode 

func NewAffectNode(val int, next *AffectNode) *AffectNode

type AssociationType 

type AssociationType int
const (
	JoinWith AssociationType = iota
	BelongToWith
	OneToOneWith
	OneToManyWith
	AssociationTypeEnd
)

func (AssociationType) String 

func (i AssociationType) String() string

type BasicExec 

type BasicExec struct {
	// contains filtered or unexported fields
}

type BelongToPreload 

type BelongToPreload struct {
	Model         *Model
	SubModel      *Model
	RelationField Field
	// used to save other table value
	ContainerField Field
}

this is describe one to one relationship with table and its sub table e.g select * from sub_table where id = (table.RelationField).value

type BrickCommon 

type BrickCommon struct {
	Model             *Model
	BelongToPreload   map[string]*BelongToPreload
	OneToOnePreload   map[string]*OneToOnePreload
	OneToManyPreload  map[string]*OneToManyPreload
	ManyToManyPreload map[string]*ManyToManyPreload

	// use by find/scan/insert/update/replace/where ,if FieldsSelector[Mode] is set,then ignoreModeSelector will failure
	// FieldsSelector[ModeDefault] can work on all Mode when they specified Mode not set
	FieldsSelector [ModeEnd][]Field
	// contains filtered or unexported fields
}

func (*BrickCommon) CopyBelongToPreload 

func (t *BrickCommon) CopyBelongToPreload() map[string]*BelongToPreload

func (*BrickCommon) CopyManyToManyPreload 

func (t *BrickCommon) CopyManyToManyPreload() map[string]*ManyToManyPreload

func (*BrickCommon) CopyOneToManyPreload 

func (t *BrickCommon) CopyOneToManyPreload() map[string]*OneToManyPreload

func (*BrickCommon) CopyOneToOnePreload 

func (t *BrickCommon) CopyOneToOnePreload() map[string]*OneToOnePreload

func (*BrickCommon) TempField 

func (t *BrickCommon) TempField(v interface{}, temp string) Field

func (*BrickCommon) ToDesc 

func (t *BrickCommon) ToDesc(v interface{}) Field

use for order by

type CacheMeta 

type CacheMeta struct {
	TableName string
}

type CollectionBrick 

type CollectionBrick struct {
	Toy *ToyCollection

	MapPreloadBrick map[string]*CollectionBrick

	//orderBy []Column
	Search SearchList

	BrickCommon
	// contains filtered or unexported fields
}

func NewCollectionBrick 

func NewCollectionBrick(toy *ToyCollection, model *Model) *CollectionBrick

func (*CollectionBrick) And 

func (t *CollectionBrick) And() CollectionBrickAnd

func (*CollectionBrick) BindDefaultFields 

func (t *CollectionBrick) BindDefaultFields(args ...interface{}) *CollectionBrick

func (*CollectionBrick) BindFields 

func (t *CollectionBrick) BindFields(mode Mode, args ...interface{}) *CollectionBrick

func (*CollectionBrick) Clone 

func (t *CollectionBrick) Clone() *CollectionBrick

func (*CollectionBrick) ConditionExec 

func (t *CollectionBrick) ConditionExec() ExecValue

func (*CollectionBrick) Conditions 

func (t *CollectionBrick) Conditions(search SearchList) *CollectionBrick

func (*CollectionBrick) CopyMapPreloadBrick 

func (t *CollectionBrick) CopyMapPreloadBrick() map[string]*CollectionBrick

func (*CollectionBrick) CopyStatus 

func (t *CollectionBrick) CopyStatus(statusBrick *CollectionBrick) *CollectionBrick

func (*CollectionBrick) Count 

func (t *CollectionBrick) Count() (count int, err error)

func (*CollectionBrick) CountExec 

func (t *CollectionBrick) CountExec() (exec ExecValue)

func (*CollectionBrick) CreateTable 

func (t *CollectionBrick) CreateTable() (*Result, error)

func (*CollectionBrick) CreateTableIfNotExist 

func (t *CollectionBrick) CreateTableIfNotExist() (*Result, error)

func (*CollectionBrick) CustomBelongToPreload 

func (t *CollectionBrick) CustomBelongToPreload(container, relationship interface{}, args ...interface{}) *CollectionBrick

func (*CollectionBrick) CustomManyToManyPreload 

func (t *CollectionBrick) CustomManyToManyPreload(middleStruct, container, relation, subRelation interface{}, args ...interface{}) *CollectionBrick

func (*CollectionBrick) CustomOneToManyPreload 

func (t *CollectionBrick) CustomOneToManyPreload(container, relationship interface{}, args ...interface{}) *CollectionBrick

func (*CollectionBrick) CustomOneToOnePreload 

func (t *CollectionBrick) CustomOneToOnePreload(container, relationship interface{}, args ...interface{}) *CollectionBrick

func (*CollectionBrick) DBIndex 

func (t *CollectionBrick) DBIndex(i int) *CollectionBrick

func (*CollectionBrick) Debug 

func (t *CollectionBrick) Debug() *CollectionBrick

func (*CollectionBrick) Delete 

func (t *CollectionBrick) Delete(v interface{}) (*Result, error)

func (*CollectionBrick) DeleteExec 

func (t *CollectionBrick) DeleteExec() ExecValue

func (*CollectionBrick) DeleteWithConditions 

func (t *CollectionBrick) DeleteWithConditions() (*Result, error)

func (*CollectionBrick) DropTable 

func (t *CollectionBrick) DropTable() (*Result, error)

func (*CollectionBrick) DropTableIfExist 

func (t *CollectionBrick) DropTableIfExist() (*Result, error)

func (*CollectionBrick) Enter 

func (t *CollectionBrick) Enter() *CollectionBrick

return it parent CollectionBrick it will panic when the parent CollectionBrick is nil

func (*CollectionBrick) Exec 

func (t *CollectionBrick) Exec(exec ExecValue, i int) (sql.Result, error)

func (*CollectionBrick) Find 

func (t *CollectionBrick) Find(v interface{}) (*Result, error)

func (*CollectionBrick) FindExec 

func (t *CollectionBrick) FindExec(records ModelRecordFieldTypes) ExecValue

func (*CollectionBrick) GetContext 

func (t *CollectionBrick) GetContext(option string, records ModelRecords) *CollectionContext

func (*CollectionBrick) HasTable 

func (t *CollectionBrick) HasTable() ([]bool, error)

func (*CollectionBrick) IgnoreMode 

func (t *CollectionBrick) IgnoreMode(s Mode, ignore IgnoreMode) *CollectionBrick

func (*CollectionBrick) Insert 

func (t *CollectionBrick) Insert(v interface{}) (*Result, error)

insert can receive three type data struct map[offset]interface{} map[int]interface{} insert is difficult that have preload data

func (*CollectionBrick) InsertExec 

func (t *CollectionBrick) InsertExec(record ModelRecord) ExecValue

func (*CollectionBrick) Or 

func (t *CollectionBrick) Or() CollectionBrickOr

func (*CollectionBrick) Preload 

func (t *CollectionBrick) Preload(fv interface{}) *CollectionBrick

return

func (*CollectionBrick) Query 

func (t *CollectionBrick) Query(exec ExecValue, i int) (*sql.Rows, error)

func (*CollectionBrick) QueryRow 

func (t *CollectionBrick) QueryRow(exec ExecValue, i int) *sql.Row

func (*CollectionBrick) RightValuePreload 

func (t *CollectionBrick) RightValuePreload(fv interface{}) *CollectionBrick

this module is get preload which is right middle field name in many-to-many mode it only use for sub model type is same with main model type e.g 

User{
    ID int `toyorm:"primary key"`
    Friend []User
}

now the main model middle field name is L_UserID, sub model middle field name is R_UserID if you want to get preload with main model middle field name == R_UserID use RightValuePreload

func (*CollectionBrick) Save 

func (t *CollectionBrick) Save(v interface{}) (*Result, error)

func (*CollectionBrick) SaveExec 

func (t *CollectionBrick) SaveExec(record ModelRecord) ExecValue

func (*CollectionBrick) Scope 

func (t *CollectionBrick) Scope(fn func(*CollectionBrick) *CollectionBrick) *CollectionBrick

func (*CollectionBrick) Selector 

func (t *CollectionBrick) Selector(selector DBPrimarySelector) *CollectionBrick

func (*CollectionBrick) Template 

func (t *CollectionBrick) Template(temp string, args ...interface{}) *CollectionBrick

func (*CollectionBrick) USave 

func (t *CollectionBrick) USave(v interface{}) (*Result, error)

func (*CollectionBrick) Update 

func (t *CollectionBrick) Update(v interface{}) (*Result, error)

func (*CollectionBrick) UpdateExec 

func (t *CollectionBrick) UpdateExec(record ModelRecord) ExecValue

func (*CollectionBrick) Where 

func (t *CollectionBrick) Where(expr SearchExpr, key FieldSelection, v ...interface{}) *CollectionBrick

where will clean old condition

func (*CollectionBrick) WhereGroup 

func (t *CollectionBrick) WhereGroup(expr SearchExpr, group interface{}) *CollectionBrick

expr only support And/Or , group must be struct data or map[string]interface{}/map[uintptr]interface{}

type CollectionBrickAnd 

type CollectionBrickAnd struct {
	Brick *CollectionBrick
}

func (CollectionBrickAnd) Condition 

func (t CollectionBrickAnd) Condition(expr SearchExpr, key FieldSelection, v ...interface{}) *CollectionBrick

func (CollectionBrickAnd) ConditionGroup 

func (t CollectionBrickAnd) ConditionGroup(expr SearchExpr, group interface{}) *CollectionBrick

func (CollectionBrickAnd) Conditions 

func (t CollectionBrickAnd) Conditions(search SearchList) *CollectionBrick

type CollectionBrickOr 

type CollectionBrickOr struct {
	Brick *CollectionBrick
}

func (CollectionBrickOr) Condition 

func (t CollectionBrickOr) Condition(expr SearchExpr, key FieldSelection, v ...interface{}) *CollectionBrick

func (CollectionBrickOr) ConditionGroup 

func (t CollectionBrickOr) ConditionGroup(expr SearchExpr, group interface{}) *CollectionBrick

func (CollectionBrickOr) Conditions 

func (t CollectionBrickOr) Conditions(search SearchList) *CollectionBrick

type CollectionContext 

type CollectionContext struct {
	Brick  *CollectionBrick
	Result *Result
	// contains filtered or unexported fields
}

func NewCollectionContext 

func NewCollectionContext(handlers CollectionHandlersChain, brick *CollectionBrick, columns ModelRecords) *CollectionContext

func (*CollectionContext) Abort 

func (c *CollectionContext) Abort()

func (*CollectionContext) IsAborted 

func (c *CollectionContext) IsAborted() bool

func (*CollectionContext) Next 

func (c *CollectionContext) Next() error

func (*CollectionContext) Value 

func (c *CollectionContext) Value(v interface{}) interface{}

type CollectionExecAction 

type CollectionExecAction struct {
	//Type   ResultType
	Exec   ExecValue
	Result sql.Result

	Error error
	// contains filtered or unexported fields
}

func (CollectionExecAction) AffectData 

func (r CollectionExecAction) AffectData() []int

func (CollectionExecAction) Err 

func (r CollectionExecAction) Err() error

func (CollectionExecAction) SetAffectData 

func (r CollectionExecAction) SetAffectData(d []int)

func (CollectionExecAction) String 

func (r CollectionExecAction) String() string

type CollectionHandlerFunc 

type CollectionHandlerFunc func(c *CollectionContext) error

type CollectionHandlersChain 

type CollectionHandlersChain []CollectionHandlerFunc

type CollectionQueryAction 

type CollectionQueryAction struct {
	Exec ExecValue

	Error []error
	// contains filtered or unexported fields
}

func (CollectionQueryAction) AffectData 

func (r CollectionQueryAction) AffectData() []int

func (CollectionQueryAction) Err 

func (r CollectionQueryAction) Err() error

func (CollectionQueryAction) SetAffectData 

func (r CollectionQueryAction) SetAffectData(d []int)

func (CollectionQueryAction) String 

func (r CollectionQueryAction) String() string

type Column 

type Column interface {
	Column() string // sql column declaration
}

func FindColumnFactory 

func FindColumnFactory(fieldTypes ModelRecordFieldTypes, brick *ToyBrick) ([]Column, func(ModelRecord) []interface{})

get columns and scanner generator

type ColumnName 

type ColumnName interface {
	Column
	Name() string
}

type ColumnNameValue 

type ColumnNameValue interface {
	ColumnName
	Value() reflect.Value
}

type ColumnValue 

type ColumnValue interface {
	Column
	Value() reflect.Value
}

type Context 

type Context struct {
	Brick  *ToyBrick
	Result *Result
	// contains filtered or unexported fields
}

func NewContext 

func NewContext(handlers HandlersChain, brick *ToyBrick, columns ModelRecords) *Context

func (*Context) Abort 

func (c *Context) Abort()

func (*Context) Deadline 

func (c *Context) Deadline() (deadline time.Time, ok bool)

func (*Context) Done 

func (c *Context) Done() <-chan struct{}

func (*Context) Err 

func (c *Context) Err() error

func (*Context) IsAborted 

func (c *Context) IsAborted() bool

func (*Context) Next 

func (c *Context) Next() error

func (*Context) Value 

func (c *Context) Value(v interface{}) interface{}

type DBPrimarySelector 

type DBPrimarySelector func(n int, key ...interface{}) int

type DBValSelector 

type DBValSelector interface {
	Select(int) int
}

type DefaultDialect 

type DefaultDialect struct{}

func (DefaultDialect) AddForeignKey 

func (dia DefaultDialect) AddForeignKey(model, relationModel *Model, ForeignKeyField Field) ExecValue

func (DefaultDialect) ConditionExec 

func (dia DefaultDialect) ConditionExec(search SearchList, limit, offset int, orderBy []Column, groupBy []Column) ExecValue

func (DefaultDialect) CountExec 

func (dia DefaultDialect) CountExec(model *Model, alias string) ExecValue

func (DefaultDialect) CreateTable 

func (dia DefaultDialect) CreateTable(model *Model, foreign map[string]ForeignKey) (execlist []ExecValue)

use to test

func (DefaultDialect) DeleteExec 

func (dia DefaultDialect) DeleteExec(model *Model) (exec ExecValue)

func (DefaultDialect) DropForeignKey 

func (dia DefaultDialect) DropForeignKey(model *Model, ForeignKeyField Field) ExecValue

func (DefaultDialect) DropTable 

func (dia DefaultDialect) DropTable(m *Model) ExecValue

func (DefaultDialect) FindExec 

func (dia DefaultDialect) FindExec(model *Model, columns []Column, alias string) ExecValue

func (DefaultDialect) HasTable 

func (dia DefaultDialect) HasTable(model *Model) ExecValue

use to test

func (DefaultDialect) InsertExec 

func (dia DefaultDialect) InsertExec(model *Model, columnValues []ColumnNameValue) ExecValue

func (DefaultDialect) InsertExecutor 

func (dia DefaultDialect) InsertExecutor(db Executor, exec ExecValue, debugPrinter func(ExecValue, error)) (sql.Result, error)

func (DefaultDialect) JoinExec 

func (dia DefaultDialect) JoinExec(mainSwap *JoinSwap) ExecValue

func (DefaultDialect) SaveExec 

func (dia DefaultDialect) SaveExec(model *Model, columnValues []ColumnNameValue) ExecValue

func (DefaultDialect) SaveExecutor 

func (dia DefaultDialect) SaveExecutor(db Executor, exec ExecValue, debugPrinter func(ExecValue, error)) (sql.Result, error)

func (DefaultDialect) SearchExec 

func (dia DefaultDialect) SearchExec(s SearchList) ExecValue

func (DefaultDialect) TemplateExec 

func (dia DefaultDialect) TemplateExec(tExec BasicExec, execs map[string]BasicExec) (ExecValue, error)

func (DefaultDialect) UpdateExec 

func (dia DefaultDialect) UpdateExec(model *Model, columnValues []ColumnValue) ExecValue

type DefaultExec 

type DefaultExec struct {
	// contains filtered or unexported fields
}

not process source str, Source() == Query()

func (DefaultExec) Append 

func (e DefaultExec) Append(query string, args ...interface{}) ExecValue

func (DefaultExec) Args 

func (e DefaultExec) Args() []interface{}

func (DefaultExec) JsonArgs 

func (e DefaultExec) JsonArgs() string

func (DefaultExec) Query 

func (e DefaultExec) Query() string

func (DefaultExec) Source 

func (e DefaultExec) Source() string

type Dialect 

type Dialect interface {
	// some database like postgres not support LastInsertId, need QueryRow to get the return id
	InsertExecutor(Executor, ExecValue, func(ExecValue, error)) (sql.Result, error)
	// sqlite3/postgresql use RowsAffected to check success or failure, but mysql can't,
	// because it's RowsAffected is zero when update value not change
	SaveExecutor(Executor, ExecValue, func(ExecValue, error)) (sql.Result, error)
	HasTable(*Model) ExecValue
	CreateTable(*Model, map[string]ForeignKey) []ExecValue
	DropTable(*Model) ExecValue
	ConditionExec(search SearchList, limit, offset int, orderBy []Column, groupBy []Column) ExecValue
	FindExec(model *Model, columns []Column, alias string) ExecValue
	UpdateExec(*Model, []ColumnValue) ExecValue
	DeleteExec(*Model) ExecValue
	InsertExec(*Model, []ColumnNameValue) ExecValue
	SaveExec(*Model, []ColumnNameValue) ExecValue
	AddForeignKey(model, relationModel *Model, ForeignKeyField Field) ExecValue
	DropForeignKey(model *Model, ForeignKeyField Field) ExecValue
	CountExec(model *Model, alias string) ExecValue
	SearchExec(search SearchList) ExecValue
	TemplateExec(BasicExec, map[string]BasicExec) (ExecValue, error)
	JoinExec(*JoinSwap) ExecValue
}

type ErrCannotSet 

type ErrCannotSet struct {
	Operation string
}

func (ErrCannotSet) Error 

func (e ErrCannotSet) Error() string

type ErrCollectionClose 

type ErrCollectionClose map[int]error

func (ErrCollectionClose) Error 

func (e ErrCollectionClose) Error() string

type ErrCollectionDBSelectorNotFound 

type ErrCollectionDBSelectorNotFound struct {
}

func (ErrCollectionDBSelectorNotFound) Error 

func (e ErrCollectionDBSelectorNotFound) Error() string

type ErrCollectionExec 

type ErrCollectionExec map[int]error

func (ErrCollectionExec) Error 

func (e ErrCollectionExec) Error() string

type ErrCollectionQuery 

type ErrCollectionQuery map[int]error

func (ErrCollectionQuery) Error 

func (e ErrCollectionQuery) Error() string

type ErrCollectionQueryRow 

type ErrCollectionQueryRow map[int]error

func (ErrCollectionQueryRow) Error 

func (e ErrCollectionQueryRow) Error() string

type ErrDbIndexNotSet 

type ErrDbIndexNotSet struct{}

func (ErrDbIndexNotSet) Error 

func (e ErrDbIndexNotSet) Error() string

type ErrInvalidModelName 

type ErrInvalidModelName struct{}

func (ErrInvalidModelName) Error 

func (e ErrInvalidModelName) Error() string

type ErrInvalidModelType 

type ErrInvalidModelType string

func (ErrInvalidModelType) Error 

func (e ErrInvalidModelType) Error() string

type ErrInvalidPreloadField 

type ErrInvalidPreloadField struct {
	ModelName string
	FieldName string
}

func (ErrInvalidPreloadField) Error 

func (e ErrInvalidPreloadField) Error() string

type ErrInvalidRecordType 

type ErrInvalidRecordType struct {
}

func (ErrInvalidRecordType) Error 

func (e ErrInvalidRecordType) Error() string

type ErrLastInsertId 

type ErrLastInsertId struct{}

func (ErrLastInsertId) Error 

func (e ErrLastInsertId) Error() string

type ErrModelDuplicateAssociation 

type ErrModelDuplicateAssociation struct {
	Model string
	Type  AssociationType
	Name  string
}

func (ErrModelDuplicateAssociation) Error 

func (e ErrModelDuplicateAssociation) Error() string

type ErrNilPrimaryKey 

type ErrNilPrimaryKey struct{}

func (ErrNilPrimaryKey) Error 

func (e ErrNilPrimaryKey) Error() string

type ErrNotSupportRowsAffected 

type ErrNotSupportRowsAffected struct{}

func (ErrNotSupportRowsAffected) Error 

func (e ErrNotSupportRowsAffected) Error() string

type ErrRepeatField 

type ErrRepeatField struct {
	ModelName string
	FieldName string
}

func (ErrRepeatField) Error 

func (e ErrRepeatField) Error() string

type ErrSameColumnName 

type ErrSameColumnName struct {
	ModelName    string
	Same         string
	OldFieldName string
	NewFieldName string
}

func (ErrSameColumnName) Error 

func (e ErrSameColumnName) Error() string

type ErrSaveFailure 

type ErrSaveFailure struct{}

func (ErrSaveFailure) Error 

func (e ErrSaveFailure) Error() string

type ErrTemplateExecInvalidWord 

type ErrTemplateExecInvalidWord struct {
	Word string
}

func (ErrTemplateExecInvalidWord) Error 

func (e ErrTemplateExecInvalidWord) Error() string

type ErrZeroPrimaryKey 

type ErrZeroPrimaryKey struct{ Model *Model }

func (ErrZeroPrimaryKey) Error 

func (e ErrZeroPrimaryKey) Error() string

type ExecAction 

type ExecAction struct {
	//Type   ResultType
	Exec   ExecValue
	Result sql.Result

	Error error
	// contains filtered or unexported fields
}

func (ExecAction) AffectData 

func (r ExecAction) AffectData() []int

func (ExecAction) Err 

func (r ExecAction) Err() error

func (ExecAction) SetAffectData 

func (r ExecAction) SetAffectData(d []int)

func (ExecAction) String 

func (r ExecAction) String() string

type ExecValue 

type ExecValue interface {
	Source() string // exec source code
	Query() string  // exec encode code
	Args() []interface{}
	Append(query string, args ...interface{}) ExecValue
	JsonArgs() string
}

type Executor 

type Executor interface {
	Exec(query string, args ...interface{}) (sql.Result, error)
	QueryRow(query string, args ...interface{}) *sql.Row
	Query(query string, args ...interface{}) (*sql.Rows, error)
}

type Field 

type Field interface {
	Column                            // sql column declaration
	Name() string                     // get field name
	Offset() uintptr                  // relation position by model struct
	IsPrimary() bool                  // primary key declaration
	AutoIncrement() bool              // auto increment declaration
	Index() string                    // sql index declaration
	UniqueIndex() string              // sql unique index declaration
	IsForeign() bool                  // sql foreign declaration
	Attr(string) string               // extension attribute declaration
	Attrs() map[string]string         // get all extension attribute
	SqlType() string                  // sql type declaration
	StructField() reflect.StructField // model struct attribute
	FieldValue() reflect.Value        // model meta field value
	JoinWith() string                 // join with specified container field declaration,when call ToyBrick.Preload(<container field>) will automatic association this field
	BelongToWith() string             // BelongTo with specified container field declaration,ToyBrick.Preload(<container field>) will automatic association this field
	OneToOneWith() string             // OneToOne with specified container field declaration,ToyBrick.Preload(<container field>) will automatic association this field
	OneToManyWith() string            // OneToMany with specified container field declaration,ToyBrick.Preload(<container field>) will automatic association this field
	Default() string                  // default value in database
	Source() Field
	ToColumnAlias(alias string) Field
	ToFieldValue(value reflect.Value) FieldValue
}

func GetMiddleField 

func GetMiddleField(model, middleModel *Model, leftOrRight bool) Field

type FieldList 

type FieldList []Field

func (FieldList) ToColumnList 

func (l FieldList) ToColumnList() []Column

type FieldSelection 

type FieldSelection interface{}

type FieldValue 

type FieldValue interface {
	Field
	Value() reflect.Value
}

type FieldValueList 

type FieldValueList []FieldValue

func (FieldValueList) ToNameValueList 

func (l FieldValueList) ToNameValueList() []ColumnNameValue

func (FieldValueList) ToValueList 

func (l FieldValueList) ToValueList() []ColumnValue

type ForeignKey 

type ForeignKey struct {
	Model *Model
	Field Field
}

type HandlerFunc 

type HandlerFunc func(c *Context) error

type HandlersChain 

type HandlersChain []HandlerFunc

type IgnoreMode 

type IgnoreMode int

func (IgnoreMode) Ignore 

func (ignoreMode IgnoreMode) Ignore(v reflect.Value) (ignore bool)

type Join 

type Join struct {
	Model     *Model
	SubModel  *Model
	Container Field
	OnMain    Field
	OnSub     Field
}

type JoinSwap 

type JoinSwap struct {
	OwnOrderBy        []int
	OwnGroupBy        []int
	OwnSearch         []int
	Alias             string
	FieldsSelector    [ModeEnd][]Field
	SwapMap           map[string]*JoinSwap
	JoinMap           map[string]*Join
	MapPreloadBrick   map[string]*ToyBrick
	BelongToPreload   map[string]*BelongToPreload
	OneToOnePreload   map[string]*OneToOnePreload
	OneToManyPreload  map[string]*OneToManyPreload
	ManyToManyPreload map[string]*ManyToManyPreload
}

join will replace attribute

func NewJoinSwap 

func NewJoinSwap(alias string) *JoinSwap

func (*JoinSwap) Copy 

func (m *JoinSwap) Copy() *JoinSwap

type ManyToManyPreload 

type ManyToManyPreload struct {
	MiddleModel      *Model
	Model            *Model
	SubModel         *Model
	ContainerField   Field
	RelationField    Field
	SubRelationField Field
}

this is describe many to many relationship with table and its sub table e.g select * from middle_table where table.id = table.id and sub_table.id = (table.RelationField).value

type Mode 

type Mode int8
const (
	ModeDefault Mode = iota
	ModeInsert
	ModeSave
	ModeUpdate
	ModeScan
	ModeSelect
	ModeCondition
	ModePreload
	ModeEnd
)

type Model 

type Model struct {
	Name              string
	ReflectType       reflect.Type
	AllFields         []*modelField
	SqlFields         []*modelField
	OffsetFields      map[uintptr]*modelField
	NameFields        map[string]*modelField
	SqlFieldMap       map[string]*modelField
	PrimaryFields     []*modelField
	IndexFields       map[string][]*modelField
	UniqueIndexFields map[string][]*modelField
	StructFieldFields map[reflect.Type][]*modelField
	Association       [AssociationTypeEnd]map[string]*modelField
}

table struct used to save all sql attribute with struct column is table name attribute AllFields is all struct field and it's Anonymous struct SqlFields is all about sql field OffsetFields is map field offset NameFields is map field name PrimaryFields is all about primary key field IndexFields is all about index fields UniqueIndexFields is all about unique index fields StructFieldFields is map unknown struct type or slice struct type

func NewMiddleModel 

func NewMiddleModel(model, subModel *Model) *Model

func NewModel 

func NewModel(val reflect.Value) *Model

func (*Model) GetFieldWithName 

func (m *Model) GetFieldWithName(name string) Field

func (*Model) GetIndexMap 

func (m *Model) GetIndexMap() map[string][]Field

func (*Model) GetNameFieldMap 

func (m *Model) GetNameFieldMap() map[string]Field

func (*Model) GetOffsetField 

func (m *Model) GetOffsetField(offset uintptr) Field

func (*Model) GetOffsetFieldMap 

func (m *Model) GetOffsetFieldMap() map[uintptr]Field

func (*Model) GetOnePrimary 

func (m *Model) GetOnePrimary() Field

func (*Model) GetPosField 

func (m *Model) GetPosField(pos int) Field

func (*Model) GetPosFields 

func (m *Model) GetPosFields(pos []int) []Field

func (*Model) GetPrimary 

func (m *Model) GetPrimary() []Field

func (*Model) GetSqlFields 

func (m *Model) GetSqlFields() []Field

func (*Model) GetUniqueIndexMap 

func (m *Model) GetUniqueIndexMap() map[string][]Field

type ModelDefault 

type ModelDefault struct {
	ID        uint32     `toyorm:"primary key;auto_increment"`
	CreatedAt time.Time  `toyorm:"NULL"`
	UpdatedAt time.Time  `toyorm:"NULL"`
	DeletedAt *time.Time `toyorm:"index;NULL"`
}

type ModelGroupBy 

type ModelGroupBy map[interface{}][]ModelIndexRecord

func (ModelGroupBy) Keys 

func (m ModelGroupBy) Keys() []interface{}

type ModelIndexRecord 

type ModelIndexRecord struct {
	ModelRecord
	Index int
}

type ModelNameMapRecord 

type ModelNameMapRecord struct {
	FieldValues map[string]reflect.Value
	// contains filtered or unexported fields
}

func NewNameMapRecord 

func NewNameMapRecord(model *Model, v reflect.Value) *ModelNameMapRecord

func (*ModelNameMapRecord) AllField 

func (m *ModelNameMapRecord) AllField() map[string]reflect.Value

func (*ModelNameMapRecord) DeleteField 

func (m *ModelNameMapRecord) DeleteField(name string)

func (*ModelNameMapRecord) Field 

func (m *ModelNameMapRecord) Field(name string) reflect.Value

func (*ModelNameMapRecord) FieldAddress 

func (m *ModelNameMapRecord) FieldAddress(name string) reflect.Value

func (*ModelNameMapRecord) GetFieldType 

func (m *ModelNameMapRecord) GetFieldType(name string) reflect.Type

func (*ModelNameMapRecord) IsVariableContainer 

func (m *ModelNameMapRecord) IsVariableContainer() bool

func (*ModelNameMapRecord) SetField 

func (m *ModelNameMapRecord) SetField(name string, value reflect.Value)

func (*ModelNameMapRecord) Source 

func (m *ModelNameMapRecord) Source() reflect.Value

type ModelNameMapRecords 

type ModelNameMapRecords struct {
	FieldValuesList []map[string]reflect.Value
	// contains filtered or unexported fields
}

func NewNameMapRecords 

func NewNameMapRecords(model *Model, v reflect.Value) *ModelNameMapRecords

func (*ModelNameMapRecords) Add 

func (m *ModelNameMapRecords) Add(v reflect.Value) ModelRecord

func (*ModelNameMapRecords) ElemType 

func (m *ModelNameMapRecords) ElemType() reflect.Type

func (*ModelNameMapRecords) GetFieldAddressType 

func (m *ModelNameMapRecords) GetFieldAddressType(name string) reflect.Type

func (*ModelNameMapRecords) GetFieldType 

func (m *ModelNameMapRecords) GetFieldType(name string) reflect.Type

func (*ModelNameMapRecords) GetRecord 

func (m *ModelNameMapRecords) GetRecord(i int) ModelRecord

func (*ModelNameMapRecords) GetRecords 

func (m *ModelNameMapRecords) GetRecords() []ModelRecord

func (*ModelNameMapRecords) GroupBy 

func (m *ModelNameMapRecords) GroupBy(key string) ModelGroupBy

func (*ModelNameMapRecords) GroupByFunc 

func (m *ModelNameMapRecords) GroupByFunc(key string, fn func(int, ModelRecord))

func (*ModelNameMapRecords) IsVariableContainer 

func (m *ModelNameMapRecords) IsVariableContainer() bool

func (*ModelNameMapRecords) Len 

func (m *ModelNameMapRecords) Len() int

func (*ModelNameMapRecords) Source 

func (m *ModelNameMapRecords) Source() reflect.Value

type ModelOffsetMapRecord 

type ModelOffsetMapRecord struct {
	FieldValues map[string]reflect.Value
	// contains filtered or unexported fields
}

func NewOffsetMapRecord 

func NewOffsetMapRecord(model *Model, v reflect.Value) *ModelOffsetMapRecord

func (*ModelOffsetMapRecord) AllField 

func (m *ModelOffsetMapRecord) AllField() map[string]reflect.Value

func (*ModelOffsetMapRecord) DeleteField 

func (m *ModelOffsetMapRecord) DeleteField(name string)

func (*ModelOffsetMapRecord) Field 

func (m *ModelOffsetMapRecord) Field(name string) reflect.Value

func (*ModelOffsetMapRecord) FieldAddress 

func (m *ModelOffsetMapRecord) FieldAddress(name string) reflect.Value

func (*ModelOffsetMapRecord) GetFieldType 

func (m *ModelOffsetMapRecord) GetFieldType(name string) reflect.Type

func (*ModelOffsetMapRecord) IsVariableContainer 

func (m *ModelOffsetMapRecord) IsVariableContainer() bool

func (*ModelOffsetMapRecord) SetField 

func (m *ModelOffsetMapRecord) SetField(name string, value reflect.Value)

func (*ModelOffsetMapRecord) Source 

func (m *ModelOffsetMapRecord) Source() reflect.Value

type ModelOffsetMapRecords 

type ModelOffsetMapRecords struct {
	FieldValuesList []map[string]reflect.Value
	// contains filtered or unexported fields
}

func NewOffsetMapRecords 

func NewOffsetMapRecords(model *Model, m reflect.Value) *ModelOffsetMapRecords

func (*ModelOffsetMapRecords) Add 

func (m *ModelOffsetMapRecords) Add(v reflect.Value) ModelRecord

func (*ModelOffsetMapRecords) ElemType 

func (m *ModelOffsetMapRecords) ElemType() reflect.Type

func (*ModelOffsetMapRecords) GetFieldAddressType 

func (m *ModelOffsetMapRecords) GetFieldAddressType(name string) reflect.Type

func (*ModelOffsetMapRecords) GetFieldType 

func (m *ModelOffsetMapRecords) GetFieldType(name string) reflect.Type

func (*ModelOffsetMapRecords) GetRecord 

func (m *ModelOffsetMapRecords) GetRecord(i int) ModelRecord

func (*ModelOffsetMapRecords) GetRecords 

func (m *ModelOffsetMapRecords) GetRecords() []ModelRecord

func (*ModelOffsetMapRecords) GroupBy 

func (m *ModelOffsetMapRecords) GroupBy(key string) ModelGroupBy

func (*ModelOffsetMapRecords) IsVariableContainer 

func (m *ModelOffsetMapRecords) IsVariableContainer() bool

func (*ModelOffsetMapRecords) Len 

func (m *ModelOffsetMapRecords) Len() int

func (*ModelOffsetMapRecords) Source 

func (m *ModelOffsetMapRecords) Source() reflect.Value

type ModelRecord 

type ModelRecord interface {
	AllField() map[string]reflect.Value
	SetField(field string, v reflect.Value)
	DeleteField(string)
	Field(field string) reflect.Value
	FieldAddress(field string) reflect.Value
	IsVariableContainer() bool
	Source() reflect.Value
	GetFieldType(string) reflect.Type
}

func MakeRecord 

func MakeRecord(model *Model, _type reflect.Type) ModelRecord

func NewRecord 

func NewRecord(model *Model, value reflect.Value) ModelRecord

func NewStructRecord 

func NewStructRecord(model *Model, value reflect.Value) ModelRecord

type ModelRecordFieldTypes 

type ModelRecordFieldTypes interface {
	GetFieldType(field string) reflect.Type
}

type ModelRecords 

type ModelRecords interface {
	GetRecord(int) ModelRecord
	GetRecords() []ModelRecord
	Add(v reflect.Value) ModelRecord
	GetFieldType(string) reflect.Type
	GetFieldAddressType(string) reflect.Type
	IsVariableContainer() bool
	ElemType() reflect.Type
	Len() int
	Source() reflect.Value
	GroupBy(key string) ModelGroupBy
}

func MakeRecords 

func MakeRecords(model *Model, _type reflect.Type) ModelRecords

func MakeRecordsWithElem 

func MakeRecordsWithElem(model *Model, _type reflect.Type) ModelRecords

use element type to create ModelRecords

func NewRecords 

func NewRecords(model *Model, value reflect.Value) ModelRecords

type ModelStructRecord 

type ModelStructRecord struct {
	FieldValues        map[string]reflect.Value
	VirtualFieldValues map[string]reflect.Value
	// contains filtered or unexported fields
}

func (*ModelStructRecord) AllField 

func (m *ModelStructRecord) AllField() map[string]reflect.Value

func (*ModelStructRecord) DeleteField 

func (m *ModelStructRecord) DeleteField(name string)

func (*ModelStructRecord) Field 

func (m *ModelStructRecord) Field(name string) reflect.Value

func (*ModelStructRecord) FieldAddress 

func (m *ModelStructRecord) FieldAddress(name string) reflect.Value

func (*ModelStructRecord) GetFieldType 

func (m *ModelStructRecord) GetFieldType(name string) reflect.Type

func (*ModelStructRecord) IsVariableContainer 

func (m *ModelStructRecord) IsVariableContainer() bool

func (*ModelStructRecord) SetField 

func (m *ModelStructRecord) SetField(name string, value reflect.Value)

set field to field value map or virtual field value map but if value is invalid delete it on map

func (*ModelStructRecord) Source 

func (m *ModelStructRecord) Source() reflect.Value

type ModelStructRecords 

type ModelStructRecords struct {
	Type reflect.Type

	RelationFieldPos       map[string]int
	FieldTypes             map[string]reflect.Type
	FieldValuesList        []map[string]reflect.Value
	VirtualFieldValuesList []map[string]reflect.Value
	// contains filtered or unexported fields
}

func NewStructRecords 

func NewStructRecords(model *Model, value reflect.Value) *ModelStructRecords

func (*ModelStructRecords) Add 

func (m *ModelStructRecords) Add(v reflect.Value) ModelRecord

func (*ModelStructRecords) ElemType 

func (m *ModelStructRecords) ElemType() reflect.Type

func (*ModelStructRecords) GetFieldAddressType 

func (m *ModelStructRecords) GetFieldAddressType(field string) reflect.Type

func (*ModelStructRecords) GetFieldType 

func (m *ModelStructRecords) GetFieldType(field string) reflect.Type

func (*ModelStructRecords) GetRecord 

func (m *ModelStructRecords) GetRecord(i int) ModelRecord

func (*ModelStructRecords) GetRecords 

func (m *ModelStructRecords) GetRecords() []ModelRecord

func (*ModelStructRecords) GroupBy 

func (m *ModelStructRecords) GroupBy(key string) ModelGroupBy

func (*ModelStructRecords) IsVariableContainer 

func (m *ModelStructRecords) IsVariableContainer() bool

func (*ModelStructRecords) Len 

func (m *ModelStructRecords) Len() int

func (*ModelStructRecords) Source 

func (m *ModelStructRecords) Source() reflect.Value

type MySqlDialect 

type MySqlDialect struct {
	DefaultDialect
}

func (MySqlDialect) CreateTable 

func (dia MySqlDialect) CreateTable(model *Model, foreign map[string]ForeignKey) (execlist []ExecValue)

func (MySqlDialect) HasTable 

func (dia MySqlDialect) HasTable(model *Model) ExecValue

func (MySqlDialect) SaveExec 

func (dia MySqlDialect) SaveExec(model *Model, columnValues []ColumnNameValue) ExecValue

replace will failure when have foreign key

func (MySqlDialect) SaveExecutor 

func (dia MySqlDialect) SaveExecutor(db Executor, exec ExecValue, debugPrinter func(ExecValue, error)) (sql.Result, error)

type OneToManyPreload 

type OneToManyPreload struct {
	Model          *Model
	SubModel       *Model
	RelationField  Field
	ContainerField Field
}

this is describe one to many relationship with table and its sub table e.g select * from sub_table where sub_table.RelationField = table.id

type OneToOnePreload 

type OneToOnePreload struct {
	Model         *Model
	SubModel      *Model
	RelationField Field
	// used to save other table value
	ContainerField Field
}

this is describe one to one relationship with table and its sub table e.g select * from sub_table where sub_table.RelationField = table.id;

type Pair 

type Pair struct {
	Main int
	Sub  int
}

type PostgreSqlDialect 

type PostgreSqlDialect struct {
	DefaultDialect
}

func (PostgreSqlDialect) AddForeignKey 

func (dia PostgreSqlDialect) AddForeignKey(model, relationModel *Model, ForeignKeyField Field) ExecValue

func (PostgreSqlDialect) ConditionExec 

func (dia PostgreSqlDialect) ConditionExec(search SearchList, limit, offset int, orderBy []Column, groupBy []Column) ExecValue

func (PostgreSqlDialect) CountExec 

func (dia PostgreSqlDialect) CountExec(model *Model, alias string) ExecValue

func (PostgreSqlDialect) CreateTable 

func (dia PostgreSqlDialect) CreateTable(model *Model, foreign map[string]ForeignKey) (execlist []ExecValue)

func (PostgreSqlDialect) DeleteExec 

func (dia PostgreSqlDialect) DeleteExec(model *Model) (exec ExecValue)

func (PostgreSqlDialect) DropForeignKey 

func (dia PostgreSqlDialect) DropForeignKey(model *Model, ForeignKeyField Field) ExecValue

func (PostgreSqlDialect) DropTable 

func (dia PostgreSqlDialect) DropTable(m *Model) ExecValue

func (PostgreSqlDialect) FindExec 

func (dia PostgreSqlDialect) FindExec(model *Model, columns []Column, alias string) ExecValue

func (PostgreSqlDialect) HasTable 

func (dia PostgreSqlDialect) HasTable(model *Model) ExecValue

func (PostgreSqlDialect) InsertExec 

func (dia PostgreSqlDialect) InsertExec(model *Model, columnValues []ColumnNameValue) ExecValue

func (PostgreSqlDialect) InsertExecutor 

func (dia PostgreSqlDialect) InsertExecutor(db Executor, exec ExecValue, debugPrinter func(ExecValue, error)) (sql.Result, error)

func (PostgreSqlDialect) JoinExec 

func (dia PostgreSqlDialect) JoinExec(mainSwap *JoinSwap) ExecValue

func (PostgreSqlDialect) SaveExec 

func (dia PostgreSqlDialect) SaveExec(model *Model, columnNameValues []ColumnNameValue) ExecValue

postgres have not replace use ON CONFLICT(%s) replace

func (PostgreSqlDialect) SearchExec 

func (dia PostgreSqlDialect) SearchExec(s SearchList) ExecValue

func (PostgreSqlDialect) TemplateExec 

func (dia PostgreSqlDialect) TemplateExec(tExec BasicExec, execs map[string]BasicExec) (ExecValue, error)

func (PostgreSqlDialect) UpdateExec 

func (dia PostgreSqlDialect) UpdateExec(model *Model, columnValues []ColumnValue) ExecValue

type PreCollectionBrick 

type PreCollectionBrick struct {
	Parent *CollectionBrick
	Field  Field
}

type PreJoinSwap 

type PreJoinSwap struct {
	Swap    *JoinSwap
	PreSwap *PreJoinSwap
	Model   *Model
	Field   Field
}

type PreToyBrick 

type PreToyBrick struct {
	Parent *ToyBrick
	Field  Field
}

type QToSExec 

type QToSExec struct {
	DefaultExec
}

when call Query() method, all '?' in query will replace to '$1','$2'...

func (QToSExec) Append 

func (e QToSExec) Append(query string, args ...interface{}) ExecValue

go-bug DefaultExec will return ExecValue(DefaultExec), so must to implement this func

func (QToSExec) Query 

func (e QToSExec) Query() string

type QueryAction 

type QueryAction struct {
	Exec ExecValue

	Error []error
	// contains filtered or unexported fields
}

func (QueryAction) AffectData 

func (r QueryAction) AffectData() []int

func (QueryAction) Err 

func (r QueryAction) Err() error

func (QueryAction) SetAffectData 

func (r QueryAction) SetAffectData(d []int)

func (QueryAction) String 

func (r QueryAction) String() string

type RawResult 

type RawResult struct {
	ID  int64
	Err error
}

func (RawResult) LastInsertId 

func (t RawResult) LastInsertId() (int64, error)

func (RawResult) RowsAffected 

func (t RawResult) RowsAffected() (int64, error)

type ReportData 

type ReportData struct {
	Depth      int
	AffectData []*AffectNode
	Str        string
}

type Result 

type Result struct {
	Records        ModelRecords
	ActionFlow     []SqlAction
	RecordsActions map[int][]int
	Preload        map[string]*Result
	// container is simple object
	SimpleRelation map[string]map[int]int
	// container is slice object
	MultipleRelation map[string]map[int]Pair

	// in many-to-many model, have a middle model query need to record
	MiddleModelPreload map[string]*Result
}

func (*Result) AddRecord 

func (r *Result) AddRecord(q SqlAction)

func (*Result) Err 

func (r *Result) Err() error

func (*Result) Report 

func (r *Result) Report() string

Rename to Log

type SearchCell 

type SearchCell struct {
	Type SearchExpr
	Val  FieldValue
}

func NewSearchBranch 

func NewSearchBranch(op SearchExpr) SearchCell

func NewSearchLeaf 

func NewSearchLeaf(op SearchExpr, columnValue FieldValue) SearchCell

type SearchExpr 

type SearchExpr string

func (SearchExpr) IsBranch 

func (op SearchExpr) IsBranch() bool

type SearchList 

type SearchList []SearchCell

func (SearchList) Condition 

func (s SearchList) Condition(columnValue FieldValue, expr, linkExpr SearchExpr) SearchList

type SearchTree 

type SearchTree struct {
	Val   SearchCell
	Left  *SearchTree
	Right *SearchTree
}

func NewSearchTree 

func NewSearchTree(val SearchCell) *SearchTree

func (*SearchTree) Fill 

func (s *SearchTree) Fill(left, right *SearchTree) *SearchTree

func (*SearchTree) ToStack 

func (s *SearchTree) ToStack() SearchList

type SqlAction 

type SqlAction interface {
	String() string
	AffectData() []int
	SetAffectData([]int)
	Err() error
}

type Sqlite3Dialect 

type Sqlite3Dialect struct {
	DefaultDialect
}

func (Sqlite3Dialect) CreateTable 

func (dia Sqlite3Dialect) CreateTable(model *Model, foreign map[string]ForeignKey) (execlist []ExecValue)

func (Sqlite3Dialect) HasTable 

func (dia Sqlite3Dialect) HasTable(model *Model) ExecValue

func (Sqlite3Dialect) SaveExec 

func (dia Sqlite3Dialect) SaveExec(model *Model, columnValues []ColumnNameValue) ExecValue

type Toy 

type Toy struct {
	DefaultHandlerChain      map[string]HandlersChain
	DefaultModelHandlerChain map[reflect.Type]map[string]HandlersChain
	ToyKernel
	// contains filtered or unexported fields
}

func Open 

func Open(driverName, dataSourceName string) (*Toy, error)

func (*Toy) BelongToBind 

func (t *Toy) BelongToBind(model, subModel *Model, containerField, relationField Field) *BelongToPreload

func (*Toy) BelongToPreload 

func (t *Toy) BelongToPreload(model *Model, field Field) *BelongToPreload

func (*Toy) Close 

func (t *Toy) Close() error

func (*Toy) DB 

func (t *Toy) DB() *sql.DB

func (*Toy) Join 

func (t *Toy) Join(model *Model, field Field) *Join

func (*Toy) ManyToManyPreload 

func (t *Toy) ManyToManyPreload(model *Model, field Field, isRight bool) *ManyToManyPreload

func (*Toy) ManyToManyPreloadBind 

func (t *Toy) ManyToManyPreloadBind(model, subModel, middleModel *Model, containerField, relationField, subRelationField Field) *ManyToManyPreload

func (*Toy) MiddleModel 

func (t *Toy) MiddleModel(v, sv interface{}) *ToyBrick

func (*Toy) Model 

func (t *Toy) Model(v interface{}) *ToyBrick

func (*Toy) ModelHandlers 

func (t *Toy) ModelHandlers(option string, model *Model) HandlersChain

func (*Toy) MustAddr 

func (t *Toy) MustAddr(b bool)

required object in Toy.Model TODO Brick.[Insert,Find,Update,Save,USave,Delete] method's parameter must be point object

func (*Toy) OneToManyBind 

func (t *Toy) OneToManyBind(model, subModel *Model, containerField, relationField Field) *OneToManyPreload

func (*Toy) OneToManyPreload 

func (t *Toy) OneToManyPreload(model *Model, field Field) *OneToManyPreload

func (*Toy) OneToOneBind 

func (t *Toy) OneToOneBind(model, subModel *Model, containerField, relationField Field) *OneToOnePreload

func (*Toy) OneToOnePreload 

func (t *Toy) OneToOnePreload(model *Model, field Field) *OneToOnePreload

type ToyBrick 

type ToyBrick struct {
	Toy *Toy

	MapPreloadBrick map[string]*ToyBrick

	Search SearchList

	OwnOrderBy []int
	OwnGroupBy []int
	OwnSearch  []int

	SwapMap map[string]*JoinSwap
	JoinMap map[string]*Join

	BrickCommon
	// contains filtered or unexported fields
}

func NewToyBrick 

func NewToyBrick(toy *Toy, model *Model) *ToyBrick

func (*ToyBrick) Alias 

func (t *ToyBrick) Alias(alias string) *ToyBrick

func (*ToyBrick) And 

func (t *ToyBrick) And() ToyBrickAnd

func (*ToyBrick) Begin 

func (t *ToyBrick) Begin() *ToyBrick

func (*ToyBrick) BindDefaultFields 

func (t *ToyBrick) BindDefaultFields(args ...FieldSelection) *ToyBrick

func (*ToyBrick) BindFields 

func (t *ToyBrick) BindFields(mode Mode, args ...interface{}) *ToyBrick

func (*ToyBrick) CleanOwnGroupBy 

func (t *ToyBrick) CleanOwnGroupBy() *ToyBrick

func (*ToyBrick) CleanOwnOrderBy 

func (t *ToyBrick) CleanOwnOrderBy() *ToyBrick

func (*ToyBrick) CleanOwnSearch 

func (t *ToyBrick) CleanOwnSearch() *ToyBrick

func (*ToyBrick) Commit 

func (t *ToyBrick) Commit() error

func (*ToyBrick) ConditionExec 

func (t *ToyBrick) ConditionExec() ExecValue

func (*ToyBrick) Conditions 

func (t *ToyBrick) Conditions(search SearchList) *ToyBrick

func (*ToyBrick) CopyJoin 

func (t *ToyBrick) CopyJoin() map[string]*Join

func (*ToyBrick) CopyJoinSwap 

func (t *ToyBrick) CopyJoinSwap() map[string]*JoinSwap

func (*ToyBrick) CopyMapPreloadBrick 

func (t *ToyBrick) CopyMapPreloadBrick() map[string]*ToyBrick

func (*ToyBrick) CopyStatus 

func (t *ToyBrick) CopyStatus(statusBrick *ToyBrick) *ToyBrick

func (*ToyBrick) Count 

func (t *ToyBrick) Count() (count int, err error)

func (*ToyBrick) CountExec 

func (t *ToyBrick) CountExec() (exec ExecValue)

func (*ToyBrick) CreateTable 

func (t *ToyBrick) CreateTable() (*Result, error)

func (*ToyBrick) CreateTableIfNotExist 

func (t *ToyBrick) CreateTableIfNotExist() (*Result, error)

func (*ToyBrick) CustomBelongToPreload 

func (t *ToyBrick) CustomBelongToPreload(container, relationship FieldSelection, args ...interface{}) *ToyBrick

func (*ToyBrick) CustomManyToManyPreload 

func (t *ToyBrick) CustomManyToManyPreload(middleStruct interface{}, container FieldSelection, relation, subRelation interface{}, args ...interface{}) *ToyBrick

func (*ToyBrick) CustomOneToManyPreload 

func (t *ToyBrick) CustomOneToManyPreload(container FieldSelection, relationship interface{}, args ...interface{}) *ToyBrick

func (*ToyBrick) CustomOneToOnePreload 

func (t *ToyBrick) CustomOneToOnePreload(container FieldSelection, relationship interface{}, args ...interface{}) *ToyBrick

func (*ToyBrick) Debug 

func (t *ToyBrick) Debug() *ToyBrick

func (*ToyBrick) Delete 

func (t *ToyBrick) Delete(v interface{}) (*Result, error)

func (*ToyBrick) DeleteExec 

func (t *ToyBrick) DeleteExec() ExecValue

func (*ToyBrick) DeleteWithConditions 

func (t *ToyBrick) DeleteWithConditions() (*Result, error)

func (*ToyBrick) DropTable 

func (t *ToyBrick) DropTable() (*Result, error)

func (*ToyBrick) DropTableIfExist 

func (t *ToyBrick) DropTableIfExist() (*Result, error)

func (*ToyBrick) Enter 

func (t *ToyBrick) Enter() *ToyBrick

return it parent ToyBrick it will panic when the parent ToyBrick is nil

func (*ToyBrick) Exec 

func (t *ToyBrick) Exec(exec ExecValue) (result sql.Result, err error)

func (*ToyBrick) Find 

func (t *ToyBrick) Find(v interface{}) (*Result, error)

func (*ToyBrick) FindExec 

func (t *ToyBrick) FindExec(columns []Column) ExecValue

func (*ToyBrick) GetContext 

func (t *ToyBrick) GetContext(option string, records ModelRecords) *Context

func (*ToyBrick) GroupBy 

func (t *ToyBrick) GroupBy(vList ...FieldSelection) *ToyBrick

func (*ToyBrick) HasTable 

func (t *ToyBrick) HasTable() (b bool, err error)

func (*ToyBrick) IgnoreMode 

func (t *ToyBrick) IgnoreMode(s Mode, ignore IgnoreMode) *ToyBrick

func (*ToyBrick) Insert 

func (t *ToyBrick) Insert(v interface{}) (*Result, error)

insert can receive three type data struct map[offset]interface{} map[int]interface{} insert is difficult that have preload data

func (*ToyBrick) InsertExec 

func (t *ToyBrick) InsertExec(record ModelRecord) ExecValue

func (*ToyBrick) Join 

func (t *ToyBrick) Join(fv FieldSelection) *ToyBrick

use join to association query

func (*ToyBrick) Limit 

func (t *ToyBrick) Limit(i int) *ToyBrick

func (*ToyBrick) Offset 

func (t *ToyBrick) Offset(i int) *ToyBrick

func (*ToyBrick) Or 

func (t *ToyBrick) Or() ToyBrickOr

func (*ToyBrick) OrderBy 

func (t *ToyBrick) OrderBy(vList ...FieldSelection) *ToyBrick

func (*ToyBrick) Preload 

func (t *ToyBrick) Preload(fv FieldSelection) *ToyBrick

return

func (*ToyBrick) Prepare 

func (t *ToyBrick) Prepare(query string) (*sql.Stmt, error)

func (*ToyBrick) Query 

func (t *ToyBrick) Query(exec ExecValue) (rows *sql.Rows, err error)

func (*ToyBrick) QueryRow 

func (t *ToyBrick) QueryRow(exec ExecValue) (row *sql.Row)

func (*ToyBrick) RightValuePreload 

func (t *ToyBrick) RightValuePreload(fv FieldSelection) *ToyBrick

this module is get preload which is right middle field name in many-to-many mode it only use for sub model type is same with main model type e.g 

User{
    ID int `toyorm:"primary key"`
    Friend []User
}

now the main model middle field name is L_UserID, sub model middle field name is R_UserID if you want to get preload with main model middle field name == R_UserID use RightValuePreload

func (*ToyBrick) Rollback 

func (t *ToyBrick) Rollback() error

func (*ToyBrick) Save 

func (t *ToyBrick) Save(v interface{}) (*Result, error)

func (*ToyBrick) SaveExec 

func (t *ToyBrick) SaveExec(record ModelRecord) ExecValue

func (*ToyBrick) Scope 

func (t *ToyBrick) Scope(fn func(*ToyBrick) *ToyBrick) *ToyBrick

func (*ToyBrick) Swap 

func (t *ToyBrick) Swap() *ToyBrick

func (*ToyBrick) Template 

func (t *ToyBrick) Template(temp string, args ...interface{}) *ToyBrick

func (*ToyBrick) USave 

func (t *ToyBrick) USave(v interface{}) (*Result, error)

save with exist data

func (*ToyBrick) Update 

func (t *ToyBrick) Update(v interface{}) (*Result, error)

func (*ToyBrick) UpdateExec 

func (t *ToyBrick) UpdateExec(record ModelRecord) ExecValue

func (*ToyBrick) Where 

func (t *ToyBrick) Where(expr SearchExpr, key FieldSelection, v ...interface{}) *ToyBrick

where will clean old condition

func (*ToyBrick) WhereGroup 

func (t *ToyBrick) WhereGroup(expr SearchExpr, group interface{}) *ToyBrick

expr only support And/Or , group must be struct data or map[string]interface{}/map[uintptr]interface{}

type ToyBrickAnd 

type ToyBrickAnd struct {
	Brick *ToyBrick
}

func (ToyBrickAnd) Condition 

func (t ToyBrickAnd) Condition(expr SearchExpr, key FieldSelection, v ...interface{}) *ToyBrick

func (ToyBrickAnd) ConditionGroup 

func (t ToyBrickAnd) ConditionGroup(expr SearchExpr, group interface{}) *ToyBrick

func (ToyBrickAnd) Conditions 

func (t ToyBrickAnd) Conditions(search SearchList) *ToyBrick

type ToyBrickOr 

type ToyBrickOr struct {
	Brick *ToyBrick
}

func (ToyBrickOr) Condition 

func (t ToyBrickOr) Condition(expr SearchExpr, key FieldSelection, v ...interface{}) *ToyBrick

func (ToyBrickOr) ConditionGroup 

func (t ToyBrickOr) ConditionGroup(expr SearchExpr, group interface{}) *ToyBrick

func (ToyBrickOr) Conditions 

func (t ToyBrickOr) Conditions(search SearchList) *ToyBrick

type ToyCollection 

type ToyCollection struct {
	DefaultHandlerChain      map[string]CollectionHandlersChain
	DefaultModelHandlerChain map[reflect.Type]map[string]CollectionHandlersChain
	ToyKernel
	// contains filtered or unexported fields
}

func OpenCollection 

func OpenCollection(driverName string, dataSourceName ...string) (*ToyCollection, error)

func (*ToyCollection) BelongToBind 

func (t *ToyCollection) BelongToBind(model, subModel *Model, containerField, relationField Field) *BelongToPreload

func (*ToyCollection) BelongToPreload 

func (t *ToyCollection) BelongToPreload(model *Model, field Field) *BelongToPreload

func (*ToyCollection) Close 

func (t *ToyCollection) Close() error

func (*ToyCollection) ManyToManyPreload 

func (t *ToyCollection) ManyToManyPreload(model *Model, field Field, isRight bool) *ManyToManyPreload

func (*ToyCollection) ManyToManyPreloadBind 

func (t *ToyCollection) ManyToManyPreloadBind(model, subModel, middleModel *Model, containerField, relationField, subRelationField Field) *ManyToManyPreload

func (*ToyCollection) MiddleModel 

func (t *ToyCollection) MiddleModel(v, sv interface{}) *CollectionBrick

func (*ToyCollection) Model 

func (t *ToyCollection) Model(v interface{}) *CollectionBrick

func (*ToyCollection) ModelHandlers 

func (t *ToyCollection) ModelHandlers(option string, model *Model) CollectionHandlersChain

func (*ToyCollection) OneToManyBind 

func (t *ToyCollection) OneToManyBind(model, subModel *Model, containerField, relationField Field) *OneToManyPreload

func (*ToyCollection) OneToManyPreload 

func (t *ToyCollection) OneToManyPreload(model *Model, field Field) *OneToManyPreload

func (*ToyCollection) OneToOneBind 

func (t *ToyCollection) OneToOneBind(model, subModel *Model, containerField, relationField Field) *OneToOnePreload

func (*ToyCollection) OneToOnePreload 

func (t *ToyCollection) OneToOnePreload(model *Model, field Field) *OneToOnePreload

func (*ToyCollection) SetModelHandlers 

func (t *ToyCollection) SetModelHandlers(option string, model *Model, handlers CollectionHandlersChain)

type ToyKernel 

type ToyKernel struct {

	// map[model][container_field_name]
	Dialect Dialect
	Logger  io.Writer
	// contains filtered or unexported fields
}

func (*ToyKernel) GetModel 

func (t *ToyKernel) GetModel(val reflect.Value) *Model

TODO testing thread safe? if not add lock

func (*ToyKernel) SetDebug 

func (t *ToyKernel) SetDebug(debug bool)

Source Files

View all Source files

Directories

Path Synopsis
examples
collection_example
join_example
preload_example
quick_start
simple_example
website

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.