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
            	IgnoreMigration        bool
            }

            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  Replacer
              	NoLowerCase   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 Replacer

                              type Replacer interface {
                              	Replace(name string) string
                              }

                                Replacer replacer interface like strings.Replacer

                                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
                                      }