orm

type AfterPreloader struct {
	// contains filtered or unexported fields
}

type ArgWithPosition struct {
	Name       string
	Start      int
	Stop       int
	Expression bob.Expression
}

type ExecQuery[Q bob.Expression] struct {
	bob.BaseQuery[Q]
	Hooks *bob.Hooks[Q, bob.SkipQueryHooksKey]
}

type Loadable interface {
	AppendLoader(f ...bob.Loader)
	AppendMapperMod(f scan.MapperMod)
}

type Loader[Q Loadable] func(ctx context.Context, exec bob.Executor, retrieved any) error

type ModExecQuery[Q any, E bob.Expression] struct {
	ExecQuery[E]
	Mod bob.Mod[Q]
}

type ModQuery[Q any, E bob.Expression, T, Ts any, Tr bob.Transformer[T, Ts]] struct {
	Query[E, T, Ts, Tr]
	Mod bob.Mod[Q]
}

type NullTypeConverter struct{}

type PreloadAs[Q Loadable] string

type PreloadExcept[Q Loadable] []string

type PreloadOnly[Q Loadable] []string

type PreloadOption[Q Loadable] interface {
	ModifyPreloadSettings(*PreloadSettings[Q])
}

type PreloadRel[E bob.Expression] struct {
	Name  string
	Sides []PreloadSide[E]
}

type PreloadSettings[Q Loadable] struct {
	Columns     []string
	SubLoaders  []Preloader[Q]
	ExtraLoader *AfterPreloader
	Mods        [][]preloadfilter
	Alias       string
}

type PreloadSide[E bob.Expression] struct {
	From        nameable[E]
	To          nameable[E]
	FromColumns []string `yaml:"-"`
	ToColumns   []string `yaml:"-"`

	FromWhere []RelWhere `yaml:"from_where"`
	ToWhere   []RelWhere `yaml:"to_where"`
}

type PreloadWhere[Q Loadable] []preloadfilter

type Preloadable interface {
	Preload(name string, rel any) error
}

type PreloadableQuery interface {
	Loadable
	AppendJoin(clause.Join)
	AppendPreloadSelect(columns ...any)
}

type Preloader[Q Loadable] func(parent string) (bob.Mod[Q], scan.MapperMod, []bob.Loader)

type Query[Q bob.Expression, T, Ts any, Tr bob.Transformer[T, Ts]] struct {
	ExecQuery[Q]
	Scanner scan.Mapper[T]
}

type RelSetDetails struct {
	TableName string
	Mapped    []RelSetMapping
	Position  int
	Start     bool
	End       bool
}

type RelSetMapping struct {
	Column         string
	Value          [2]string // [0] is the SQL value, [1] is the Go value
	ExternalTable  string
	ExternalColumn string
	ExtPosition    int
	ExternalStart  bool
	ExternalEnd    bool
}

type RelSide struct {
	From string `yaml:"from"`
	To   string `yaml:"to"`

	// To make sure the column lengths match and are in the right order,
	// a slice of tupules is expected.
	// bobgen-helpers.GenConfig has a function to spread that into From/ToColumns
	Columns     [][2]string `yaml:"columns"`
	FromColumns []string    `yaml:"-"`
	ToColumns   []string    `yaml:"-"`

	FromWhere []RelWhere `yaml:"from_where"`
	ToWhere   []RelWhere `yaml:"to_where"`

	// These are columns that exist in the database, but should not be
	// considered by the relationship when determining if it is a join table
	// the columns are never set or read, so make sure they have a default value
	// or operations will fail
	// the first slice is for the from table, the second is for the to table
	IgnoredColumns [2][]string `yaml:"-"`

	// if the origin is unique
	FromUnique bool `yaml:"-"`
	// if the destination is unique
	ToUnique bool `yaml:"-"`

	// Which side to modify, "from" or "to"
	// If not set, it will try to "guess" which side to modify
	// - if only one of the sides contains a primary key,
	//   it will choose to modify the other side
	// - If (both or none) of them contains a primary key,
	//   it will try with "Unique" columns
	// - If it still cannot choose, it defaults to "to"
	Modify string `yaml:"modify"`

	// If the key is nullable. We need this to know if we can remove the
	// relationship without deleting it
	// this is set in Relationships.init()
	KeyNullable bool `yaml:"-"`
}

type RelWhere struct {
	Column   string `yaml:"column"`
	SQLValue string `yaml:"sql_value"`
	GoValue  string `yaml:"go_value"`
}

type Relationship struct {
	Name  string    `yaml:"name"`
	Sides []RelSide `yaml:"sides"`

	// These can be set through user configuration
	Ignored bool
	// Do not create the inverse of a user configured relationship
	NoReverse bool `yaml:"no_reverse"`
	// Makes sure the factories does not require the relationship to be set.
	// Useful if you're not using foreign keys
	NeverRequired bool `yaml:"never_required"`
}

type RelationshipChainError struct {
	Table1  string
	Column1 string
	Value   string
	Table2  string
	Column2 string
}

type SchemaTable string

type Setter[T, InsertQ, UpdateQ any] interface {
	// SetColumns should return the column names that are set
	SetColumns() []string
	// Act as a mod for the insert query
	// the BeforeInsertHooks MUST be run here
	bob.Mod[InsertQ]
	// Return a mod for the update query
	// this should add "SET col1 = val1, col2 = val2, ..."
	UpdateMod() bob.Mod[UpdateQ]
}