warehouse

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

type ArrowType struct {
	ArrowDataType arrow.DataType
	Nullable      bool
	Metadata      arrow.Metadata
}

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

type Driver interface {
	// CreateTable creates a new table with the specified Arrow schema.
	// Returns error if table exists or schema conversion fails.
	// Implementation must convert Arrow types to warehouse-native types.
	CreateTable(table string, schema *arrow.Schema) error

	// AddColumn adds a new column to an existing table.
	AddColumn(table string, field *arrow.Field) error

	// Write inserts batch data into the specified table.
	// Schema must match table structure. Rows contain column_name -> value mappings.
	// Implementation handles type conversion and batch optimization.
	// Returns error on type mismatch, constraint violation, or connection issues.
	Write(ctx context.Context, table string, schema *arrow.Schema, rows []map[string]any) error

	// MissingColumns compares provided schema against existing table structure.
	// Returns fields that exist in schema but not in table.
	// Used for schema drift detection before writes.
	// Returns TableNotFoundError if table doesn't exist.
	MissingColumns(table string, schema *arrow.Schema) ([]*arrow.Field, error)
}

type ErrColumnAlreadyExists struct {
	TableName  string
	ColumnName string
}

type ErrInvalidTableName struct {
	TableName string
	Reason    string
}

type ErrMultipleTypeIncompatible struct {
	TableName string
	Errors    []*ErrTypeIncompatible
}

type ErrTableAlreadyExists struct {
	TableName string
}

type ErrTableNotFound struct {
	TableName string
}

type ErrTypeIncompatible struct {
	TableName     string
	ColumnName    string
	ExistingType  arrow.DataType
	ExpectedType  arrow.DataType
	DetailedError string
}

type ErrUnsupportedMapping struct {
	Type   any
	Mapper string
}

type ErrUnsupportedWarehouseType struct {
	WarehouseType string
	Operation     string
}

type FieldCompatibilityChecker interface {
	AreFieldsCompatible(existing, input *arrow.Field) (bool, error)
}

type FieldTypeMapper[WHT SpecificWarehouseType] interface {
	ArrowToWarehouse(arrowType ArrowType) (WHT, error)
	WarehouseToArrow(warehouseType WHT) (ArrowType, error)
}

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

type MockDriver struct {
	Writes     []MockWrittenRows
	WriteError error
}

type MockWarehouseDriver struct {
	WriteCallCount    int
	WriteErrors       []error
	WriteCalls        []WriteCall
	CreateTableCalls  []CreateTableCall
	AddColumnCalls    []AddColumnCall
	MissingColumnResp []MissingColumnResp
	// contains filtered or unexported fields
}

type MockWrittenRows struct {
	Table string
	Rows  []map[string]any
}

type QueryMapper interface {
	// TablePredicate returns warehouse-specific table creation prefix.
	// Examples: "TABLE", "TABLE IF NOT EXISTS", "TEMPORARY TABLE"
	TablePredicate(table string) string

	// Field converts Arrow field to warehouse column type definition.
	// Must handle type mapping, nullability, and metadata.
	// Returns string like "VARCHAR(255)", "Int64", "TIMESTAMP", etc.
	Field(*arrow.Field) (string, error)

	// TableSuffix returns warehouse-specific table creation suffix.
	// Examples: "ENGINE = MergeTree()", "OPTIONS (description='...')"
	// May include newlines for multi-line clauses.
	TableSuffix(table string) string
}

type Registry interface {
	Get(propertyID string) (Driver, error)
}

type SpecificWarehouseType interface {
	Format(i any, m arrow.Metadata) (any, error)
}

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

type TypeComparisonResult struct {
	Equal        bool
	ErrorMessage string
	TypePath     string
}

type TypeCompatibilityRule func(expected, actual arrow.DataType) (compatible bool, handled bool)

type TypeMapperImpl[T SpecificWarehouseType] struct {
	Types []FieldTypeMapper[T]
}

type TypeNotFoundInRegistryErr struct {
	TypeName string
	TypeKind string
}

type WriteCall struct {
	Table   string
	Schema  *arrow.Schema
	Records []map[string]any
}