package schema

Import Path
	gorm.io/gorm/schema (on go.dev)

Dependency Relation
	imports 24 packages, and imported by 5 packages

Involved Source Files

	    check.go
	    field.go
	    index.go
	    interfaces.go
	    naming.go
	    pool.go
	    relationship.go
	    schema.go
	    serializer.go
	    utils.go
Package-Level Type Names (total 29)

	/* sort by: alphabet | popularity */
	 type Check (struct)

		Fields (total 38)
			Constraint string
				// length(phone) >= 10

			Field *Field
			Field.AutoCreateTime TimeType
			Field.AutoIncrement bool
			Field.AutoIncrementIncrement int64
			Field.AutoUpdateTime TimeType
			Field.BindNames []string
			Field.Comment string
			Field.Creatable bool
			Field.DBName string
			Field.DataType DataType
			Field.DefaultValue string
			Field.DefaultValueInterface interface{}
			Field.EmbeddedSchema *Schema
			Field.FieldType reflect.Type
			Field.GORMDataType DataType
			Field.HasDefaultValue bool
			Field.IgnoreMigration bool
			Field.IndirectFieldType reflect.Type
			Field.NewValuePool FieldNewValuePool
			Field.NotNull bool
			Field.OwnerSchema *Schema
			Field.Precision int
			Field.PrimaryKey bool
			Field.Readable bool
			Field.ReflectValueOf func(context.Context, reflect.Value) reflect.Value
			Field.Scale int
			Field.Schema *Schema
			Field.Serializer SerializerInterface
			Field.Set func(context.Context, reflect.Value, interface{}) error
			Field.Size int
			Field.StructField reflect.StructField
			Field.Tag reflect.StructTag
			Field.TagSettings map[string]string
			Field.Unique bool
			Field.Updatable bool
			Field.ValueOf func(context.Context, reflect.Value) (value interface{}, zero bool)
			Name string
		Methods (only one)
			( Check) BindName() string
		As Outputs Of (at least 2)
			func (*Schema).ParseCheckConstraints() map[string]Check
			func gorm.io/gorm/migrator.Migrator.GuessConstraintAndTable(stmt *gorm.Statement, name string) (_ *Constraint, _ *Check, table string)

	 type Constraint (struct)

		Fields (total 8)
			Field *Field
			ForeignKeys []*Field
			Name string
			OnDelete string
			OnUpdate string
			ReferenceSchema *Schema
			References []*Field
			Schema *Schema
		As Outputs Of (at least 2)
			func (*Relationship).ParseConstraint() *Constraint
			func gorm.io/gorm/migrator.Migrator.GuessConstraintAndTable(stmt *gorm.Statement, name string) (_ *Constraint, _ *Check, table string)

	 type CreateClausesInterface (interface)
		CreateClausesInterface create clauses interface

		Methods (only one)
			( CreateClausesInterface) CreateClauses(*Field) []clause.Interface

	 type DataType string (basic type)
		DataType GORM data type

		As Types Of (total 7)
			const Bool
			const Bytes
			const Float
			const Int
			const String
			const Time
			const Uint

	 type DeleteClausesInterface (interface)
		DeleteClausesInterface delete clauses interface

		Methods (only one)
			( DeleteClausesInterface) DeleteClauses(*Field) []clause.Interface
		Implemented By (at least one exported)
			 gorm.io/gorm.DeletedAt

	 type Field (struct)
		Field is the representation of model schema's field

		Fields (total 36)
			AutoCreateTime TimeType
			AutoIncrement bool
			AutoIncrementIncrement int64
			AutoUpdateTime TimeType
			BindNames []string
			Comment string
			Creatable bool
			DBName string
			DataType DataType
			DefaultValue string
			DefaultValueInterface interface{}
			EmbeddedSchema *Schema
			FieldType reflect.Type
			GORMDataType DataType
			HasDefaultValue bool
			IgnoreMigration bool
			IndirectFieldType reflect.Type
			Name string
			NewValuePool FieldNewValuePool
			NotNull bool
			OwnerSchema *Schema
			Precision int
			PrimaryKey bool
			Readable bool
			ReflectValueOf func(context.Context, reflect.Value) reflect.Value
			Scale int
			Schema *Schema
			Serializer SerializerInterface
			Set func(context.Context, reflect.Value, interface{}) error
			Size int
			StructField reflect.StructField
			Tag reflect.StructTag
			TagSettings map[string]string
			Unique bool
			Updatable bool
			ValueOf func(context.Context, reflect.Value) (value interface{}, zero bool)
		Methods (only one)
			(*Field) BindName() string
		As Outputs Of (at least 3)
			func Schema.LookUpField(name string) *Field
			func Schema.LookUpFieldByBindName(bindNames []string, name string) *Field
			func (*Schema).ParseField(fieldStruct reflect.StructField) *Field
		As Inputs Of (at least 35)
			func GetIdentityFieldValuesMap(ctx context.Context, reflectValue reflect.Value, fields []*Field) (map[string][]reflect.Value, [][]interface{})
			func GetIdentityFieldValuesMapFromValues(ctx context.Context, values []interface{}, fields []*Field) (map[string][]reflect.Value, [][]interface{})
			func CreateClausesInterface.CreateClauses(*Field) []clause.Interface
			func DeleteClausesInterface.DeleteClauses(*Field) []clause.Interface
			func GobSerializer.Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error)
			func GobSerializer.Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
			func JSONSerializer.Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error)
			func JSONSerializer.Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
			func QueryClausesInterface.QueryClauses(*Field) []clause.Interface
			func SerializerInterface.Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) error
			func SerializerInterface.Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
			func SerializerValuerInterface.Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
			func UnixSecondSerializer.Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error)
			func UnixSecondSerializer.Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (result interface{}, err error)
			func UpdateClausesInterface.UpdateClauses(*Field) []clause.Interface
			func gorm.io/gorm.DeletedAt.DeleteClauses(f *Field) []clause.Interface
			func gorm.io/gorm.DeletedAt.QueryClauses(f *Field) []clause.Interface
			func gorm.io/gorm.DeletedAt.UpdateClauses(f *Field) []clause.Interface
			func gorm.io/gorm.Dialector.DataTypeOf(*Field) string
			func gorm.io/gorm.Dialector.DefaultValueOf(*Field) clause.Expression
			func gorm.io/gorm.Migrator.FullDataTypeOf(*Field) clause.Expr
			func gorm.io/gorm.Migrator.MigrateColumn(dst interface{}, field *Field, columnType gorm.ColumnType) error
			func gorm.io/gorm/migrator.GormDataTypeInterface.GormDBDataType(*gorm.DB, *Field) string
			func gorm.io/gorm/migrator.Migrator.DataTypeOf(field *Field) string
			func gorm.io/gorm/migrator.Migrator.FullDataTypeOf(field *Field) (expr clause.Expr)
			func gorm.io/gorm/migrator.Migrator.MigrateColumn(value interface{}, field *Field, columnType gorm.ColumnType) error
			func gorm.io/driver/mysql.Dialector.DataTypeOf(field *Field) string
			func gorm.io/driver/mysql.Dialector.DefaultValueOf(field *Field) clause.Expression
			func gorm.io/driver/mysql.Migrator.FullDataTypeOf(field *Field) clause.Expr
			func gorm.io/driver/postgres.Dialector.DataTypeOf(field *Field) string
			func gorm.io/driver/postgres.Dialector.DefaultValueOf(field *Field) clause.Expression
			func gorm.io/driver/postgres.Migrator.CreateSequence(tx *gorm.DB, stmt *gorm.Statement, field *Field, serialDatabaseType string) (err error)
			func gorm.io/driver/postgres.Migrator.DeleteSequence(tx *gorm.DB, stmt *gorm.Statement, field *Field, fileType clause.Expr) (err error)
			func gorm.io/driver/postgres.Migrator.MigrateColumn(value interface{}, field *Field, columnType gorm.ColumnType) error
			func gorm.io/driver/postgres.Migrator.UpdateSequence(tx *gorm.DB, stmt *gorm.Statement, field *Field, serialDatabaseType string) (err error)

	 type FieldNewValuePool (interface)
		FieldNewValuePool field new scan value pool

		Methods (total 2)
			( FieldNewValuePool) Get() interface{}
			( FieldNewValuePool) Put(interface{})
		Implemented By (at least one exported)
			*sync.Pool

	 type GobSerializer (struct)
		GobSerializer gob serializer

		Methods (total 2)
			( GobSerializer) Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error)
				Scan implements serializer interface

			( GobSerializer) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
				Value implements serializer interface

		Implements (at least 2)
			 GobSerializer : SerializerInterface
			 GobSerializer : SerializerValuerInterface

	 type GormDataTypeInterface (interface)
		GormDataTypeInterface gorm data type interface

		Methods (only one)
			( GormDataTypeInterface) GormDataType() string

	 type Index (struct)

		Fields (total 7)
			Class string
				// UNIQUE | FULLTEXT | SPATIAL

			Comment string
			Fields []IndexOption
			Name string
			Option string
				// WITH PARSER parser_name

			Type string
				// btree, hash, gist, spgist, gin, and brin

			Where string
		As Outputs Of (at least 2)
			func (*Schema).LookIndex(name string) *Index
			func (*Schema).ParseIndexes() map[string]Index

	 type IndexOption (struct)

		Fields (total 41)
			Collate string
			Expression string
			Field *Field
			Field.AutoCreateTime TimeType
			Field.AutoIncrement bool
			Field.AutoIncrementIncrement int64
			Field.AutoUpdateTime TimeType
			Field.BindNames []string
			Field.Comment string
			Field.Creatable bool
			Field.DBName string
			Field.DataType DataType
			Field.DefaultValue string
			Field.DefaultValueInterface interface{}
			Field.EmbeddedSchema *Schema
			Field.FieldType reflect.Type
			Field.GORMDataType DataType
			Field.HasDefaultValue bool
			Field.IgnoreMigration bool
			Field.IndirectFieldType reflect.Type
			Field.Name string
			Field.NewValuePool FieldNewValuePool
			Field.NotNull bool
			Field.OwnerSchema *Schema
			Field.Precision int
			Field.PrimaryKey bool
			Field.Readable bool
			Field.ReflectValueOf func(context.Context, reflect.Value) reflect.Value
			Field.Scale int
			Field.Schema *Schema
			Field.Serializer SerializerInterface
			Field.Set func(context.Context, reflect.Value, interface{}) error
			Field.Size int
			Field.StructField reflect.StructField
			Field.Tag reflect.StructTag
			Field.TagSettings map[string]string
			Field.Unique bool
			Field.Updatable bool
			Field.ValueOf func(context.Context, reflect.Value) (value interface{}, zero bool)
			Length int
			Sort string
				// DESC, ASC

		Methods (only one)
			( IndexOption) BindName() string
		As Inputs Of (at least 3)
			func gorm.io/gorm/migrator.BuildIndexOptionsInterface.BuildIndexOptions([]IndexOption, *gorm.Statement) []interface{}
			func gorm.io/gorm/migrator.Migrator.BuildIndexOptions(opts []IndexOption, stmt *gorm.Statement) (results []interface{})
			func gorm.io/driver/postgres.Migrator.BuildIndexOptions(opts []IndexOption, stmt *gorm.Statement) (results []interface{})

	 type JSONSerializer (struct)
		JSONSerializer json serializer

		Methods (total 2)
			( JSONSerializer) Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error)
				Scan implements serializer interface

			( JSONSerializer) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
				Value implements serializer interface

		Implements (at least 2)
			 JSONSerializer : SerializerInterface
			 JSONSerializer : SerializerValuerInterface

	 type Namer (interface)
		Namer namer interface

		Methods (total 7)
			( Namer) CheckerName(table, column string) string
			( Namer) ColumnName(table, column string) string
			( Namer) IndexName(table, column string) string
			( Namer) JoinTableName(joinTable string) string
			( Namer) RelationshipFKName(Relationship) string
			( Namer) SchemaName(table string) string
			( Namer) TableName(table string) string
		Implemented By (at least one exported)
			 NamingStrategy
		As Inputs Of (at least 3)
			func Parse(dest interface{}, cacheStore *sync.Map, namer Namer) (*Schema, error)
			func ParseWithSpecialTableName(dest interface{}, cacheStore *sync.Map, namer Namer, specialTableName string) (*Schema, error)
			func TablerWithNamer.TableName(Namer) string

	 type NamingStrategy (struct)
		NamingStrategy tables, columns naming strategy

		Fields (total 5)
			IdentifierMaxLength int
			NameReplacer Replacer
			NoLowerCase bool
			SingularTable bool
			TablePrefix string
		Methods (total 7)
			( NamingStrategy) CheckerName(table, column string) string
				CheckerName generate checker name

			( NamingStrategy) ColumnName(table, column string) string
				ColumnName convert string to column name

			( NamingStrategy) IndexName(table, column string) string
				IndexName generate index name

			( NamingStrategy) JoinTableName(str string) string
				JoinTableName convert string to join table name

			( NamingStrategy) RelationshipFKName(rel Relationship) string
				RelationshipFKName generate fk name for relation

			( NamingStrategy) SchemaName(table string) string
				SchemaName generate schema name from table name, don't guarantee it is the reverse value of TableName

			( NamingStrategy) TableName(str string) string
				TableName convert string to table name

		Implements (at least one exported)
			 NamingStrategy : Namer

	 type Polymorphic (struct)

		Fields (total 3)
			PolymorphicID *Field
			PolymorphicType *Field
			Value string

	 type QueryClausesInterface (interface)
		QueryClausesInterface query clauses interface

		Methods (only one)
			( QueryClausesInterface) QueryClauses(*Field) []clause.Interface
		Implemented By (at least one exported)
			 gorm.io/gorm.DeletedAt

	 type Reference (struct)

		Fields (total 4)
			ForeignKey *Field
			OwnPrimaryKey bool
			PrimaryKey *Field
			PrimaryValue string

	 type Relationship (struct)

		Fields (total 8)
			Field *Field
			FieldSchema *Schema
			JoinTable *Schema
			Name string
			Polymorphic *Polymorphic
			References []*Reference
			Schema *Schema
			Type RelationshipType
		Methods (total 2)
			(*Relationship) ParseConstraint() *Constraint
			(*Relationship) ToQueryConditions(ctx context.Context, reflectValue reflect.Value) (conds []clause.Expression)
		As Inputs Of (at least 3)
			func GetRelationsValues(ctx context.Context, reflectValue reflect.Value, rels []*Relationship) (reflectResults reflect.Value)
			func Namer.RelationshipFKName(Relationship) string
			func NamingStrategy.RelationshipFKName(rel Relationship) string

	 type Relationships (struct)

		Fields (total 6)
			BelongsTo []*Relationship
			EmbeddedRelations map[string]*Relationships
			HasMany []*Relationship
			HasOne []*Relationship
			Many2Many []*Relationship
			Relations map[string]*Relationship

	 type RelationshipType string (basic type)
		RelationshipType relationship type

		As Types Of (total 4)
			const BelongsTo
			const HasMany
			const HasOne
			const Many2Many

	 type Replacer (interface)
		Replacer replacer interface like strings.Replacer

		Methods (only one)
			( Replacer) Replace(name string) string
		Implemented By (at least one exported)
			*strings.Replacer

	 type Schema (struct)

		Fields (total 26)
			AfterCreate bool
			AfterDelete bool
			AfterFind bool
			AfterSave bool
			AfterUpdate bool
			BeforeCreate bool
			BeforeDelete bool
			BeforeSave bool
			BeforeUpdate bool
			CreateClauses []clause.Interface
			DBNames []string
			DeleteClauses []clause.Interface
			Fields []*Field
			FieldsByBindName map[string]*Field
				// embedded fields is 'Embed.Field'

			FieldsByDBName map[string]*Field
			FieldsByName map[string]*Field
			FieldsWithDefaultDBValue []*Field
				// fields with default value assigned by database

			ModelType reflect.Type
			Name string
			PrimaryFieldDBNames []string
			PrimaryFields []*Field
			PrioritizedPrimaryField *Field
			QueryClauses []clause.Interface
			Relationships Relationships
			Table string
			UpdateClauses []clause.Interface
		Methods (total 8)
			(*Schema) LookIndex(name string) *Index
			( Schema) LookUpField(name string) *Field
			( Schema) LookUpFieldByBindName(bindNames []string, name string) *Field
				LookUpFieldByBindName looks for the closest field in the embedded struct.
				
					type Struct struct {
						Embedded struct {
							ID string // is selected by LookUpFieldByBindName([]string{"Embedded", "ID"}, "ID")
						}
						ID string // is selected by LookUpFieldByBindName([]string{"ID"}, "ID")
					}

			( Schema) MakeSlice() reflect.Value
			(*Schema) ParseCheckConstraints() map[string]Check
				ParseCheckConstraints parse schema check constraints

			(*Schema) ParseField(fieldStruct reflect.StructField) *Field
				ParseField parses reflect.StructField to Field

			(*Schema) ParseIndexes() map[string]Index
				ParseIndexes parse schema indexes

			( Schema) String() string
		Implements (at least 2)
			 Schema : fmt.Stringer
			 Schema : github.com/ChrisTrenkamp/goxpath/tree.Result
		As Outputs Of (at least 2)
			func Parse(dest interface{}, cacheStore *sync.Map, namer Namer) (*Schema, error)
			func ParseWithSpecialTableName(dest interface{}, cacheStore *sync.Map, namer Namer, specialTableName string) (*Schema, error)

	 type SerializerInterface (interface)
		SerializerInterface serializer interface

		Methods (total 2)
			( SerializerInterface) Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) error
			( SerializerInterface) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
		Implemented By (at least 3)
			 GobSerializer
			 JSONSerializer
			 UnixSecondSerializer
		Implements (at least one exported)
			 SerializerInterface : SerializerValuerInterface
		As Outputs Of (at least one exported)
			func GetSerializer(name string) (serializer SerializerInterface, ok bool)
		As Inputs Of (at least one exported)
			func RegisterSerializer(name string, serializer SerializerInterface)

	 type SerializerValuerInterface (interface)
		SerializerValuerInterface serializer valuer interface

		Methods (only one)
			( SerializerValuerInterface) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (interface{}, error)
		Implemented By (at least 4)
			 GobSerializer
			 JSONSerializer
			 SerializerInterface (interface)
			 UnixSecondSerializer

	 type Tabler (interface)

		Methods (only one)
			( Tabler) TableName() string
		Implemented By (at least 13)
			 github.com/limanmys/render-engine/app/models.AccessToken
			 github.com/limanmys/render-engine/app/models.CronJob
			 github.com/limanmys/render-engine/app/models.Extension
			 github.com/limanmys/render-engine/app/models.Licence
			 github.com/limanmys/render-engine/app/models.Oauth2Token
			 github.com/limanmys/render-engine/app/models.Permission
			 github.com/limanmys/render-engine/app/models.Queue
			 github.com/limanmys/render-engine/app/models.RoleUsers
			 github.com/limanmys/render-engine/app/models.Server
			 github.com/limanmys/render-engine/app/models.ServerKey
			 github.com/limanmys/render-engine/app/models.Settings
			 github.com/limanmys/render-engine/app/models.Token
			 github.com/limanmys/render-engine/app/models.User

	 type TablerWithNamer (interface)

		Methods (only one)
			( TablerWithNamer) TableName(Namer) string

	 type TimeType int64 (basic type)
		TimeType GORM time type

		As Types Of (total 4)
			const UnixMillisecond
			const UnixNanosecond
			const UnixSecond
			const UnixTime

	 type UnixSecondSerializer (struct)
		UnixSecondSerializer json serializer

		Methods (total 2)
			( UnixSecondSerializer) Scan(ctx context.Context, field *Field, dst reflect.Value, dbValue interface{}) (err error)
				Scan implements serializer interface

			( UnixSecondSerializer) Value(ctx context.Context, field *Field, dst reflect.Value, fieldValue interface{}) (result interface{}, err error)
				Value implements serializer interface

		Implements (at least 2)
			 UnixSecondSerializer : SerializerInterface
			 UnixSecondSerializer : SerializerValuerInterface

	 type UpdateClausesInterface (interface)
		UpdateClausesInterface update clauses interface

		Methods (only one)
			( UpdateClausesInterface) UpdateClauses(*Field) []clause.Interface
		Implemented By (at least one exported)
			 gorm.io/gorm.DeletedAt


Package-Level Functions (total 9)

	 func GetIdentityFieldValuesMap(ctx context.Context, reflectValue reflect.Value, fields []*Field) (map[string][]reflect.Value, [][]interface{})
		GetIdentityFieldValuesMap get identity map from fields

	 func GetIdentityFieldValuesMapFromValues(ctx context.Context, values []interface{}, fields []*Field) (map[string][]reflect.Value, [][]interface{})
		GetIdentityFieldValuesMapFromValues get identity map from fields

	 func GetRelationsValues(ctx context.Context, reflectValue reflect.Value, rels []*Relationship) (reflectResults reflect.Value)
		GetRelationsValues get relations's values from a reflect value

	 func GetSerializer(name string) (serializer SerializerInterface, ok bool)
		GetSerializer get serializer

	 func Parse(dest interface{}, cacheStore *sync.Map, namer Namer) (*Schema, error)
		Parse get data type from dialector

	 func ParseTagSetting(str string, sep string) map[string]string
	 func ParseWithSpecialTableName(dest interface{}, cacheStore *sync.Map, namer Namer, specialTableName string) (*Schema, error)
		ParseWithSpecialTableName get data type from dialector with extra schema table

	 func RegisterSerializer(name string, serializer SerializerInterface)
		RegisterSerializer register serializer

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


Package-Level Variables (total 4)

	  var ByteReflectType reflect.Type
		special types' reflect type

	  var ErrUnsupportedDataType error
		ErrUnsupportedDataType unsupported data type

	  var TimePtrReflectType reflect.Type
		special types' reflect type

	  var TimeReflectType reflect.Type
		special types' reflect type


Package-Level Constants (total 15)

	const BelongsTo RelationshipType = "belongs_to" // BelongsToRel belongs to relationship
	const Bool DataType = "bool"
		GORM fields types

	const Bytes DataType = "bytes"
		GORM fields types

	const Float DataType = "float"
		GORM fields types

	const HasMany RelationshipType = "has_many" // HasManyRel has many relationship
	const HasOne RelationshipType = "has_one" // HasOneRel has one relationship
	const Int DataType = "int"
		GORM fields types

	const Many2Many RelationshipType = "many_to_many" // Many2ManyRel many to many relationship
	const String DataType = "string"
		GORM fields types

	const Time DataType = "time"
		GORM fields types

	const Uint DataType = "uint"
		GORM fields types

	const UnixMillisecond TimeType = 3
		GORM time types

	const UnixNanosecond TimeType = 4
		GORM time types

	const UnixSecond TimeType = 2
		GORM time types

	const UnixTime TimeType = 1
		GORM time types

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.