Documentation

Index

Constants

This section is empty.

Variables

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

    ErrUnsupportedDataType unsupported data type

    View Source
    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
            	AutoIncrementIncrement int64
            	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
              	NameReplacer  *strings.Replacer
              }

                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
                                    }