sql

type BaseDatabase struct {
	RootMessageDescriptor protoreflect.MessageDescriptor
	// contains filtered or unexported fields
}

type BaseDialect struct {
	CreateTableSql      map[string]string
	PrimaryKeySql       []*Constraint
	ForeignKeySql       []*Constraint
	UniqueConstraintSql []*Constraint
	// IndexSql holds the indexes the sink creates for itself rather than because the
	// schema asked for one. They are built in the same pass as the constraints, being the
	// same kind of expensive.
	IndexSql      []*Constraint
	TableRegistry map[string]*schema.Table
	Logger        *zap.Logger
}

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

type Constraint struct {
	Table string
	Sql   string

	// ReferencedTable is the logical name of the table a foreign key points at, empty for
	// any other kind of constraint. It is what the apply order is computed from: the
	// SQL carries schema-qualified names, which is not what the registry is keyed by.
	ReferencedTable string
}

type ConstraintPolicy struct {
	// Timing decides when they are created; the zero value is ConstraintsAuto.
	Timing ConstraintTiming

	// DisableForeignKeys leaves out every foreign key, including the one to the block
	// table. Those are what a load pays most for.
	DisableForeignKeys bool

	// DisablePrimaryKeys and DisableUniques name the tables that go without, or AllTables.
	DisablePrimaryKeys []string
	DisableUniques     []string

	// DisableBlockNumberIndex leaves out the index on _block_number_. Every table carries
	// that column and the reorg path deletes by it on every table, so without the index
	// each undo is a sequential scan per table. It is only dead weight on a run that can
	// never reorg.
	//
	// Unlike the rest of this policy it is not about what the schema declares, and not
	// governed by Timing: the index is created when the sink starts.
	DisableBlockNumberIndex bool

	// Parallelism is how many constraints are created or dropped at once. Zero means one.
	//
	// They go on independent relations, so the only ordering that matters is between the
	// waves — a foreign key needs the key it references to exist — and within a wave the
	// server is free to build them side by side. Each statement still commits on its own,
	// which is what keeps the pass restartable: a run that is killed keeps what it
	// finished. It is an execution knob rather than a property of the schema.
	Parallelism int

	// WorkMem is what maintenance_work_mem is set to for the duration of each statement,
	// empty leaving the server's own setting alone. The default is 64MB on most servers,
	// at which an index build over a large table spills to an external merge sort; raising
	// it for the pass alone is the cheapest thing that makes it faster.
	//
	// It multiplies with Parallelism, each concurrent build taking its own.
	WorkMem string
}

type ConstraintTiming string

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

type Database interface {
	// Inserter: both implementations already pass themselves as the inserter for a
	// walk, this states it.
	Inserter

	FetchSinkInfo(schemaName string) (*SinkInfo, error)
	UpdateSinkInfoHash(schemaName string, newHash string) error
	StoreSinkInfo(schemaName string, schemaHash string) error

	CreateDatabase(useConstraints bool) error
	// ApplyConstraints adds the schema's constraints to a database that already exists,
	// skipping the ones already in place. A schema first synced without constraints has
	// none of them, and only this puts them there.
	ApplyConstraints() error

	// EnsureBlockNumberIndexes creates the index the sink needs for its own reorg path,
	// when it starts. It is not part of the constraint pass: --apply-constraints describes
	// the schema and is the operator's to schedule, where this one the sink depends on to
	// undo a reorg without sequentially scanning every table.
	EnsureBlockNumberIndexes(ctx context.Context) error

	// MissingConstraints names the constraints the policy says the schema should carry and
	// the database does not have. It is what turns "this schema has no indexes" from
	// something you find out by querying it into something the sink says on every start.
	MissingConstraints() ([]string, error)

	// DropConstraints removes the constraints this schema's DDL would create, leaving
	// anything the sink did not put there alone. It is the escape hatch after
	// --apply-constraints=always, and what makes a stalled backfill fast again without a
	// second setup.
	DropConstraints() error
	// SwitchToDirectInserts leaves any buffered write path behind and inserts straight
	// into the database from now on. It is a one-way switch, and a no-op for a backend
	// that never buffered. The reason is what the caller knows and the database does not
	// — reaching the chain head, or reaching the end of a bounded range — and it is what
	// the switch reports, so the log does not claim a head the stream never saw.
	// atChainHead says the sink carries on from here rather than exiting, which is what
	// makes the spool's own bookkeeping worth clearing: a run that stays live seals a
	// segment or two on every restart and would otherwise accumulate their records for as
	// long as it lives.
	SwitchToDirectInserts(ctx context.Context, reason string, atChainHead bool) error
	// WalkMessageDescriptorAndInsert reads the message through protoreflect only, so it
	// does not care which dynamic implementation produced it — dynamicpb and hyperpb are
	// both accepted, and the decoder picks.
	WalkMessageDescriptorAndInsert(dm protoreflect.Message, blockNum uint64, blockTimestamp time.Time, parent *Parent) (time.Duration, error)
	// WalkMessageDescriptorAndInsertInto is the same walk, against a caller-supplied
	// inserter. It touches no database state, so it is safe to call concurrently with
	// a BufferedInserter per goroutine.
	WalkMessageDescriptorAndInsertInto(dm protoreflect.Message, blockNum uint64, blockTimestamp time.Time, parent *Parent, inserter Inserter) (time.Duration, error)
	InsertBlock(blockNum uint64, hash string, timestamp time.Time) error

	HandleBlocksUndo(lastValidBlockNumber uint64) error

	FetchCursor() (*sink.Cursor, error)
	StoreCursor(cursor *sink.Cursor) error

	BeginTransaction() error
	CommitTransaction() error
	RollbackTransaction()
	Flush() (time.Duration, error)

	DatabaseHash(schemaName string) (uint64, error)

	GetDialect() Dialect

	Open() error

	// Close releases anything the database buffered locally, so blocks held at shutdown
	// reach the server rather than being streamed again.
	Close(ctx context.Context) error

	// BufferStats reports what sits between the stream and the server, and what the
	// applier has done to drain it. enabled is false when nothing buffers locally, in
	// which case the caller knows a flush means the rows are stored and the snapshot
	// says nothing.
	//
	// The whole snapshot rather than the few numbers the gap needs, because they are only
	// readable together: a gap says the database is behind, and only the applier's
	// occupancy next to it says whether that is the database being slow or the stream
	// having burst.
	BufferStats() (stats WriteStats, enabled bool)
}

type Dialect interface {
	SchemaHash() string
	FullTableName(table *schema.Table) string
	GetTable(table string) *schema.Table
	GetTables() []*schema.Table
	UseVersionField() bool
	UseDeletedField() bool
	// UseRowIDField reports whether the given table carries the DialectFieldRowID column.
	// It is per-table because a schema can annotate some of its messages and not others.
	UseRowIDField(table string) bool
	AppendInlineFieldValues(fieldValues []any, fd protoreflect.FieldDescriptor, fv protoreflect.Value, dm protoreflect.Message) ([]any, error)
}

type EnumValue struct {
	Number int32
	Name   string
}

type ForeignKey struct {
	Name         string
	Table        string
	Field        string
	ForeignTable string
	ForeignField string
}

type Inserter interface {
	Insert(table string, values []any) error
}

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

type SinkInfo struct {
	SchemaHash string `json:"schema_hash"`
}

type WriteMode string

type WriteStats struct {
	spool.Stats

	// DatabaseBytesWritten is what actually went down the socket to the server.
	DatabaseBytesWritten int64
}