Documentation

Index

Constants

This section is empty.

Variables

var ErrUnsupportedDataType = errors.New("unsupported data type")

ErrUnsupportedDataType unsupported data type


var TimeReflectType = reflect.TypeOf(time.Time{})

Functions

func GetIdentityFieldValuesMap

func GetIdentityFieldValuesMap(reflectValue reflect.Value, fields []*Field) (map[string][]reflect.Value, [][]interface{})

GetIdentityFieldValuesMap get identity map from fields

func GetIdentityFieldValuesMapFromValues

func GetIdentityFieldValuesMapFromValues(values []interface{}, fields []*Field) (map[string][]reflect.Value, [][]interface{})

GetIdentityFieldValuesMapFromValues get identity map from fields

func GetRelationsValues

func GetRelationsValues(reflectValue reflect.Value, rels []*Relationship) (reflectResults reflect.Value)

GetRelationsValues get relations's values from a reflect value

func ParseTagSetting

func ParseTagSetting(str string, sep string) map[string]string

func ToQueryValues

func ToQueryValues(table string, foreignKeys []string, foreignValues [][]interface{}) (interface{}, []interface{})

ToQueryValues to query values

Types

type Check

type Check struct {
	Name       string
	Constraint string // length(phone) >= 10
	*Field
}

type Constraint

type Constraint struct {
	Name            string
	Field           *Field
	Schema          *Schema
	ForeignKeys     []*Field
	ReferenceSchema *Schema
	References      []*Field
	OnDelete        string
	OnUpdate        string
}

type CreateClausesInterface

type CreateClausesInterface interface {
	CreateClauses(*Field) []clause.Interface
}

type DataType

type DataType string
const (
	Bool   DataType = "bool"
	Int    DataType = "int"
	Uint   DataType = "uint"
	Float  DataType = "float"
	String DataType = "string"
	Time   DataType = "time"
	Bytes  DataType = "bytes"
)

type DeleteClausesInterface

type DeleteClausesInterface interface {
	DeleteClauses(*Field) []clause.Interface
}

type Field

type Field struct {
	Name                  string
	DBName                string
	BindNames             []string
	DataType              DataType
	GORMDataType          DataType
	PrimaryKey            bool
	AutoIncrement         bool
	Creatable             bool
	Updatable             bool
	Readable              bool
	HasDefaultValue       bool
	AutoCreateTime        TimeType
	AutoUpdateTime        TimeType
	DefaultValue          string
	DefaultValueInterface interface{}
	NotNull               bool
	Unique                bool
	Comment               string
	Size                  int
	Precision             int
	Scale                 int
	FieldType             reflect.Type
	IndirectFieldType     reflect.Type
	StructField           reflect.StructField
	Tag                   reflect.StructTag
	TagSettings           map[string]string
	Schema                *Schema
	EmbeddedSchema        *Schema
	OwnerSchema           *Schema
	ReflectValueOf        func(reflect.Value) reflect.Value
	ValueOf               func(reflect.Value) (value interface{}, zero bool)
	Set                   func(reflect.Value, interface{}) error
}

type GormDataTypeInterface

type GormDataTypeInterface interface {
	GormDataType() string
}

type Index

type Index struct {
	Name    string
	Class   string // UNIQUE | FULLTEXT | SPATIAL
	Type    string // btree, hash, gist, spgist, gin, and brin
	Where   string
	Comment string
	Option  string // WITH PARSER parser_name
	Fields  []IndexOption
}

type IndexOption

type IndexOption struct {
	*Field
	Expression string
	Sort       string // DESC, ASC
	Collate    string
	Length     int
	// contains filtered or unexported fields
}

type Namer

type Namer interface {
	TableName(table string) string
	ColumnName(table, column string) string
	JoinTableName(joinTable string) string
	RelationshipFKName(Relationship) string
	CheckerName(table, column string) string
	IndexName(table, column string) string
}

Namer namer interface

type NamingStrategy

type NamingStrategy struct {
	TablePrefix   string
	SingularTable bool
}

NamingStrategy tables, columns naming strategy

func (NamingStrategy) CheckerName

func (ns NamingStrategy) CheckerName(table, column string) string

CheckerName generate checker name

func (NamingStrategy) ColumnName

func (ns NamingStrategy) ColumnName(table, column string) string

ColumnName convert string to column name

func (NamingStrategy) IndexName

func (ns NamingStrategy) IndexName(table, column string) string

IndexName generate index name

func (NamingStrategy) JoinTableName

func (ns NamingStrategy) JoinTableName(str string) string

JoinTableName convert string to join table name

func (NamingStrategy) RelationshipFKName

func (ns NamingStrategy) RelationshipFKName(rel Relationship) string

RelationshipFKName generate fk name for relation

func (NamingStrategy) TableName

func (ns NamingStrategy) TableName(str string) string

TableName convert string to table name

type Polymorphic

type Polymorphic struct {
	PolymorphicID   *Field
	PolymorphicType *Field
	Value           string
}

type QueryClausesInterface

type QueryClausesInterface interface {
	QueryClauses(*Field) []clause.Interface
}

type Reference

type Reference struct {
	PrimaryKey    *Field
	PrimaryValue  string
	ForeignKey    *Field
	OwnPrimaryKey bool
}

type Relationship

type Relationship struct {
	Name        string
	Type        RelationshipType
	Field       *Field
	Polymorphic *Polymorphic
	References  []*Reference
	Schema      *Schema
	FieldSchema *Schema
	JoinTable   *Schema
	// contains filtered or unexported fields
}

func (*Relationship) ParseConstraint

func (rel *Relationship) ParseConstraint() *Constraint

func (*Relationship) ToQueryConditions

func (rel *Relationship) ToQueryConditions(reflectValue reflect.Value) (conds []clause.Expression)

type RelationshipType

type RelationshipType string

RelationshipType relationship type

const (
	HasOne    RelationshipType = "has_one"      // HasOneRel has one relationship
	HasMany   RelationshipType = "has_many"     // HasManyRel has many relationship
	BelongsTo RelationshipType = "belongs_to"   // BelongsToRel belongs to relationship
	Many2Many RelationshipType = "many_to_many" // Many2ManyRel many to many relationship
)

type Relationships

type Relationships struct {
	HasOne    []*Relationship
	BelongsTo []*Relationship
	HasMany   []*Relationship
	Many2Many []*Relationship
	Relations map[string]*Relationship
}

type Schema

type Schema struct {
	Name                      string
	ModelType                 reflect.Type
	Table                     string
	PrioritizedPrimaryField   *Field
	DBNames                   []string
	PrimaryFields             []*Field
	PrimaryFieldDBNames       []string
	Fields                    []*Field
	FieldsByName              map[string]*Field
	FieldsByDBName            map[string]*Field
	FieldsWithDefaultDBValue  []*Field // fields with default value assigned by database
	Relationships             Relationships
	CreateClauses             []clause.Interface
	QueryClauses              []clause.Interface
	UpdateClauses             []clause.Interface
	DeleteClauses             []clause.Interface
	BeforeCreate, AfterCreate bool
	BeforeUpdate, AfterUpdate bool
	BeforeDelete, AfterDelete bool
	BeforeSave, AfterSave     bool
	AfterFind                 bool
	// contains filtered or unexported fields
}

func Parse

func Parse(dest interface{}, cacheStore *sync.Map, namer Namer) (*Schema, error)

get data type from dialector

func (*Schema) LookIndex

func (schema *Schema) LookIndex(name string) *Index

func (Schema) LookUpField

func (schema Schema) LookUpField(name string) *Field

func (Schema) MakeSlice

func (schema Schema) MakeSlice() reflect.Value

func (*Schema) ParseCheckConstraints

func (schema *Schema) ParseCheckConstraints() map[string]Check

ParseCheckConstraints parse schema check constraints

func (*Schema) ParseField

func (schema *Schema) ParseField(fieldStruct reflect.StructField) *Field

func (*Schema) ParseIndexes

func (schema *Schema) ParseIndexes() map[string]Index

ParseIndexes parse schema indexes

func (Schema) String

func (schema Schema) String() string

type Tabler

type Tabler interface {
	TableName() string
}

type TimeType

type TimeType int64
const (
	UnixSecond      TimeType = 1
	UnixMillisecond TimeType = 2
	UnixNanosecond  TimeType = 3
)

type UpdateClausesInterface

type UpdateClausesInterface interface {
	UpdateClauses(*Field) []clause.Interface
}