schema

package
v1.1.5 Latest Latest
Warning

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

 Go to latest Published: Mar 3, 2023 License: MIT Imports: 20 Imported by: 0

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 EmbeddedNamer added in v1.0.12 

type EmbeddedNamer struct {
	Table string
	Namer
}

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(model reflect.Type) string
	ColumnName(table, column string) string
	JoinTableName(joinTable string) string
	RelationshipFKName(Relationship) string
	CheckerName(table, column string) string
	IndexName(table, column string) string
	IndexTableName(table 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) IndexTableName added in v1.1.5 

func (ns NamingStrategy) IndexTableName(table 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(model reflect.Type) 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, GormUpdating, 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
}

Source Files

View all Source files

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.