db

type AliasNodesType = maps.SliceMap[string, Aliaser]

type Column struct {
	// DbName is the name of the column in the database. This is blank if this is a "virtual" table for sql tables like an association or virtual attribute query.
	DbName string
	// GoName is the name of the column in go code
	GoName string
	// NativeType is the type of the column as described by the database itself.
	NativeType string
	//  ColumnType is the equivalent Go type to the database column
	ColumnType GoColumnType
	// MaxCharLength is the maximum length of characters to allow in the column if a string type column.
	// If the database has the ability to specify this, this will correspond to what is specified.
	// In any case, we will generate code to prevent fields from getting bigger than this.
	MaxCharLength uint64
	// DefaultValue is the default value as specified by the database. We will initialize new ORM objects
	// with this value. Call DefaultValueAsValue
	DefaultValue interface{}
	// MaxValue is the maximum value allowed for numeric values. This can be used by UI objects to tell the user what the limits are.
	MaxValue interface{}
	// MinValue is the minimum value allowed for numeric values. This can be used by UI objects to tell the user what the limits are.
	MinValue interface{}
	// IsId is true if this column represents a unique identifier generated by the database
	IsId bool
	// IsPk is true if this is the single primary key column. PK's do not necessarily need to be ID columns, and if not, we will need to do our own work to generate unique PKs.
	IsPk bool
	// IsNullable is true if the column can be given a NULL value
	IsNullable bool
	// IsUnique is true if the column's table has a single unique index on the column.
	IsUnique bool
	// IsTimestamp is true if the field is a timestamp. Timestamps represent a specific point in world time.
	// By default, timestamps are treated as not editable by the user. To automatically update a timestamp
	// value when its saved, you should edit the Save method in the model.
	IsTimestamp bool
	// IsDateOnly indicates that we have a time type of column that should only be concerned about the date and not the time.
	IsDateOnly bool
	// IsTimeOnly indicates that we have a time type of column that should only be concerned about the time and not the date.
	IsTimeOnly bool
	// Comment is the contents of the comment associated with this field
	Comment string

	// Options are the options extracted from the comments string
	Options map[string]interface{}
	// ForeignKey is additional information describing a foreign key relationship
	ForeignKey *ForeignKeyInfo
	// contains filtered or unexported fields
}

type ColumnDescription struct {
	// Name is the name of the column in the database. This is blank if this is a "virtual" table for sql tables like an association or virtual attribute query.
	Name string
	// NativeType is the type of the column as described by the database itself.
	NativeType string
	//  GoType is the goradd defined column type
	GoType string
	// SubType has additional information to the type of column that can help control code generation
	// When column type is "time.Time", the column will default to both a date and time format. You can also make it:
	//   date (which means date only)
	//   time (time only)
	//   timestamp (not editable by the user)
	SubType string
	// MaxCharLength is the maximum length of characters to allow in the column if a string type column.
	// If the database has the ability to specify this, this will correspond to what is specified.
	// In any case, we will generate code to prevent fields from getting bigger than this. Zero indicates there is
	// no length checking or limiting.
	MaxCharLength uint64
	// DefaultValue is the default value as specified by the database. We will initialize new ORM objects
	// with this value. It will be cast to the corresponding GO type.
	DefaultValue interface{}
	// MaxValue is the maximum value allowed for numeric values. This can be used by UI objects to tell the user what the limits are.
	MaxValue interface{}
	// MinValue is the minimum value allowed for numeric values. This can be used by UI objects to tell the user what the limits are.
	MinValue interface{}
	// IsId is true if this column represents a unique identifier generated by the database.
	IsId bool
	// IsPk is true if this is a primary key column. PK's do not necessarily need to be ID columns, and if not,
	// we will need to do our own work to generate unique PKs.
	IsPk bool
	// IsNullable is true if the column can be given a NULL value
	IsNullable bool
	// IsUnique indicates that the column holds a single unique value. If this column
	// is part of a multi-column unique value, IsUnique will be false since its value
	// could be repeated.
	IsUnique bool
	// ForeignKey is additional information describing a foreign key relationship
	ForeignKey *ForeignKeyDescription
	// Comment is the contents of the comment associated with this column
	Comment string
	// Options are key-value settings that can be used to further describe code generation
	Options map[string]interface{}
}

type Copier interface {
	Copy() interface{}
}

type DatabaseDescription struct {
	// Tables are the tables in the database
	Tables []TableDescription
	// MM are the many-to-many links between tables. In SQL databases, these are actual tables,
	// but in NoSQL, these might be array fields on either side of the relationship.
	MM []ManyManyDescription
}

type DatabaseI interface {
	// Model returns a Model object, which is a description of the tables and fields in
	// a database and their relationships. SQL databases can, for the most part, generate this description
	// based on their structure. NoSQL databases would need to get this description some other way, like through
	// a configuration file.
	Model() *Model

	// NewBuilder returns a newly created query builder
	NewBuilder(ctx context.Context) QueryBuilderI

	// Update will put the given values into a record that already exists in the database. The "fields" value
	// should include only fields that have changed.
	Update(ctx context.Context, table string, fields map[string]interface{}, pkName string, pkValue interface{})
	// Insert will insert a new record into the database with the given values, and return the new record's primary key value.
	// The fields value should include all the required values in the database.
	Insert(ctx context.Context, table string, fields map[string]interface{}) string
	// Delete will delete the given record from the database
	Delete(ctx context.Context, table string, pkName string, pkValue interface{})
	// Associate sets a many-many relationship to the given values.
	// The values are taken from the ORM, and are treated differently depending on whether this is a SQL or NoSQL database.
	Associate(ctx context.Context,
		table string,
		column string,
		pk interface{},
		relatedTable string,
		relatedColumn string,
		relatedPks interface{})

	// Begin will begin a transaction in the database and return the transaction id
	Begin(ctx context.Context) TransactionID
	// Commit will commit the given transaction
	Commit(ctx context.Context, txid TransactionID)
	// Rollback will roll back the given transaction PROVIDED it has not been committed. If it has been
	// committed, it will do nothing. Rollback can therefore be used in a defer statement as a safeguard in case
	// a transaction fails.
	Rollback(ctx context.Context, txid TransactionID)
	// PutBlankContext is called early in the processing of a response to insert an empty context that the database can use if needed.
	PutBlankContext(ctx context.Context) context.Context
}

type DatabaseMap = maps.SliceMap[string, DatabaseI]

type EnumTable struct {
	// DbKey is the key used to find the database in the global database cluster
	DbKey string
	// DbName is the name of the table in the database
	DbName string
	// LiteralName is the english name of the object when describing it to the world. Use the "literalName" option in the comment to override the default.
	LiteralName string
	// LiteralPlural is the plural english name of the object. Use the "literalPlural" option in the comment to override the default.
	LiteralPlural string
	// GoName is the name of the item as a go type name.
	GoName string
	// GoPlural is the plural of the go type
	GoPlural string
	// LcGoName is the lower case version of the go name
	LcGoName string
	// FieldNames are the names of the fields defined in the table. The first field name MUST be the name of the id field, and 2nd MUST be the name of the name field, the others are optional extra fields.
	FieldNames []string
	// FieldTypes are the go column types of the fields, indexed by field name
	FieldTypes map[string]GoColumnType
	// Values are the constant values themselves as defined in the table, mapped to field names in each row.
	Values []map[string]interface{}
	// PkField is the name of the private key field
	PkField string

	// Filled in by analyzer
	Constants map[int]string
}

type FKAction int

type ForeignKeyDescription struct {
	// ReferencedTable is the name of the table on the other end of the foreign key
	ReferencedTable string
	// ReferencedColumn is the database column name in the linked table that matches this column. Often that is the primary key of the other table.
	ReferencedColumn string
	// UpdateAction indicates how the column will react when the referenced item's ID changes.
	UpdateAction FKAction
	// DeleteAction indicates how the column will react when the referenced item is deleted.
	DeleteAction FKAction
	// IsUnique is true if the reference is one-to-one
	IsUnique bool

	// GoName is the name we should use to refer to the related object. Leave blank to get a computed value.
	GoName string
	// ReverseName is the name that the reverse reference should use to refer to the collection of objects pointing to it.
	// Leave blank to get a "ThisAsThat" type default name. The lower-case version of this name will be used as a column name
	// to store the values if using a NoSQL database.
	ReverseName string
}

type ForeignKeyInfo struct {
	// ReferencedTable is the name of the table on the other end of the foreign key
	ReferencedTable string
	// ReferencedColumn is the database column name in the linked table that matches this column name.
	// Often that is the primary key of the other table.
	ReferencedColumn string
	// UpdateAction indicates how the column will react when the other end of the relationship's value changes.
	// Some databases react automatically, but databases or tables that do not support
	// foreign keys will need to be updated manually.
	UpdateAction FKAction
	// DeleteAction indicates how the column will react when the other end of the relationship's record is deleted.
	// Some databases react automatically, but databases or tables that do not support
	// foreign keys will need to be updated manually.
	DeleteAction FKAction
	// GoName is the name we should use to refer to the related object
	GoName string
	// GoType is the type of the related object
	GoType string
	// GoTypePlural is the plural version of the type when referring to groups of related objects
	GoTypePlural string
	// isEnum is true if this is a related type
	IsEnum bool
	// RR is filled in by the analyzer and represents a reverse reference relationship
	RR *ReverseReference
}

type Index struct {
	// IsUnique indicates whether the index is for a unique index
	IsUnique bool
	// Columns are the columns that are part of the index
	Columns []*Column
}

type IndexDescription struct {
	// IsUnique indicates whether the index is unique
	IsUnique bool
	// ColumnNames are the columns that are part of the index
	ColumnNames []string
}

type LimitInfo struct {
	MaxRowCount int
	Offset      int
}

type ManyManyDescription struct {
	// Table1 is the name of the first table that is part of the relationship. The private key of that table will be referred to.
	Table1 string
	// Column1 is the database column name. For SQL databases, this is the name of the column in the assn table. For
	// NoSQL, this is the name of the column that will be used to store the ids of the other side. This is optional for
	// NoSQL, as one will be created based on the table names if left blank.
	Column1 string
	// GoName1 is the singular name of the object that Table2 will use to refer to Table1 objects.
	GoName1 string
	// GoPlural1 is the plural name of the object that Table2 will use to refer to Table1 objects.
	GoPlural1 string

	// Table2 is the name of the second table that is part of the relationship. The private key of that table will be referred to.
	Table2 string
	// Column2 is the database column name. For SQL databases, this is the name of the column in the assn table. For
	// NoSQL, this is the name of the column that will be used to store the ids of the other side. This is optional for
	// NoSQL, as one will be created based on the table names if left blank.
	Column2 string
	// GoName2 is the singular name of the object that Table1 will use to refer to Table2 objects.
	GoName2 string
	// GoPlural2 is the plural name of the object that Table1 will use to refer to Table2 objects.
	GoPlural2 string

	// AssnTableName is the name of the intermediate association table that will be used to create the relationship. This is
	// needed for SQL databases, but not for NoSQL, as NoSQL will create additional array columns on each side of the relationship.
	AssnTableName string
	// SupportsForeignKeys indicates that the database engine for the table will automatically take
	// care of updating foreign key pointers when the item pointed to has an updated key or is deleted.
	// If this is false, the code generator will need to do the updating.
	SupportsForeignKeys bool
}

type ManyManyReference struct {
	// AssnTableName is the database table that links the two associated tables together.
	AssnTableName string
	// AssnSourceColumnName is the database column in the association table that points at the source table's primary key.
	AssnSourceColumnName string
	// AssnDestColumnName is the database column in the association table that points at the destination table's primary key.
	AssnDestColumnName string
	// DestinationTableName is the database table being linked (the table that we are joining to)
	DestinationTableName string

	// GoName is the name used to refer to an object on the other end of the reference.
	// It is not the same as the object type. For example TeamMember would refer to a Person type.
	// This is derived from the AssnDestColumnName but can be overridden by comments in the column.
	GoName string
	// GoPlural is the name used to refer to the group of objects on the other end of the reference.
	// For example, TeamMembers. This is derived from the AssnDestColumnName but can be overridden by
	// a comment in the table.
	GoPlural string

	// SupportsForeignKeys indicates that updates and deletes are automatically handled by the database engine.
	// If this is false, the code generator will need to manually update these items.
	SupportsForeignKeys bool

	// IsEnumAssociation is true if this is a many-many relationship with an enum table
	IsEnumAssociation bool

	// MM is the many-many reference on the other end of the relationship that points back to this one.
	MM *ManyManyReference
	// contains filtered or unexported fields
}

type Model struct {
	// The database key corresponding to its key in the global database cluster
	DbKey string
	// The name of the database or schema.
	DbName string
	// Tables are the tables in the database, keyed by database table name
	Tables map[string]*Table
	// EnumTables contains a description of the enumerated types from the enum tables in the database, keyed by database table name
	EnumTables map[string]*EnumTable

	// ForeignKeySuffix is the text to strip off the end of foreign key references when converting to names.
	// Defaults to "_id"
	ForeignKeySuffix string
	// EnumTableSuffix is the text to string off the end of an enum table when converting it to a type name.
	// Defaults to "_enum".
	EnumTableSuffix string
	// contains filtered or unexported fields
}

type QueryBuilder struct {
	Ctx           context.Context // The context that will be used in all the queries
	Joins         []NodeI
	OrderBys      []NodeI
	ConditionNode NodeI
	IsDistinct    bool
	AliasNodes    *AliasNodesType
	// Adds a COUNT(*) to the select list
	GroupBys   []NodeI
	Selects    []NodeI
	LimitInfo  *LimitInfo
	HavingNode NodeI
	IsSubquery bool
}

type QueryExport struct {
	Joins      []NodeI
	OrderBys   []NodeI
	Condition  NodeI
	Distinct   bool
	AliasNodes *AliasNodesType
	// Adds a COUNT(*) to the select list
	GroupBys   []NodeI
	Selects    []NodeI
	LimitInfo  *LimitInfo
	Having     NodeI
	IsSubquery bool
}

type ReverseReference struct {
	// DbColumn is only used in NoSQL databases, and is the name of a column that will hold the pk(s) of the referring column(s)
	DbColumn string
	// AssociatedTableName is the table on the "many" end that is pointing to the table containing the ReverseReference.
	AssociatedTable *Table
	// AssociatedColumn is the column on the "many" end that is pointing to the table containing the ReverseReference. It is a foreign-key.
	AssociatedColumn *Column
	// GoName is the name used to represent an object in the reverse relationship
	GoName string
	// GoPlural is the name used to represent the group of objects in the reverse relationship
	GoPlural string
	// GoType is the type of object in the collection of "many" objects, which corresponds to the name of the struct corresponding to the table
	GoType string
	// GoTypePlural is the plural of the type of object in the collection of "many" objects
	GoTypePlural string
}

type Table struct {
	// DbKey is the key used to find the database in the global database cluster
	DbKey string
	// DbName is the name of the database table or object in the database.
	DbName string
	// LiteralName is the name of the object when describing it to the world. Use the "literalName" option in the comment to override the default. Should be lower case.
	LiteralName string
	// LiteralPlural is the plural name of the object. Use the "literalPlural" option in the comment to override the default. Should be lower case.
	LiteralPlural string
	// GoName is the name of the struct when referring to it in go code. Use the "goName" option in the comment to override the default.
	GoName string
	// GoPlural is the name of a collection of these objects when referring to them in go code. Use the "goPlural" option in the comment to override the default.
	GoPlural string
	// LcGoName is the same as GoName, but with first letter lower case.
	LcGoName string
	// Columns is a list of ColumnDescriptions, one for each column in the table.
	Columns []*Column

	// Indexes are the indexes defined in the database. Unique indexes will result in LoadBy* functions.
	Indexes []Index
	// Options are key-value pairs of values that can be used to customize how code generation is performed
	Options map[string]interface{}

	// Comment is the general comment included in the database
	Comment string

	// ManyManyReferences describe the many-to-many references pointing to this table
	ManyManyReferences []*ManyManyReference
	// ReverseReferences describes the many-to-one references pointing to this table
	ReverseReferences []*ReverseReference

	// SupportsForeignKeys determines whether the table uses a storage engine that
	// supports foreign keys. Some examples: Postgres supports foreign keys across all tables,
	// while some MySQL database engines do not support foreign keys, and the engine
	// can be assigned on a table-by-table basis.
	//
	// If the table has foreign key support, the code generator will assume that the
	// database will automatically handle updates and deletes of foreign key values.
	// If not, the code generator will attempt to update the foreign keys as appropriate.
	SupportsForeignKeys bool
	// contains filtered or unexported fields
}

type TableDescription struct {
	// Name is the name of the database table or collection.
	// Schemas will be delineated with a period in the name.
	Name string
	// Columns is a list of ColumnDescriptions, one for each column in the table.
	// The first columns are the primary keys. Usually there is just one primary key.
	Columns []ColumnDescription
	// Indexes are the indexes defined in the database. Unique indexes will result in LoadBy* functions.
	Indexes []IndexDescription
	// EnumData is the data of the enum table if this is a enum table. The data structure must match that of the columns.
	EnumData []map[string]interface{}

	// Comment is an optional comment about the table
	Comment string
	// Options are key-value settings that can be used to further describe code generation
	Options map[string]interface{}
	// SupportsForeignKeys indicates that the engine for the table will automatically
	// update foreign keys per its internal constraints.
	SupportsForeignKeys bool
}

type TransactionID int

type ValueMap map[string]interface{}