driverbase

type AutocommitSetter interface {
	SetAutocommit(ctx context.Context, enabled bool) error
}

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

type BaseRecordReaderOptions struct {
	BatchByteLimit int64
	BatchRowLimit  int64
}

type BufferBulkIngestSink struct {
	bytes.Buffer
}

type BulkIngestFileImpl interface {
	// Upload serialized data to the staging area, if needed.
	Upload(ctx context.Context, chunk BulkIngestPendingUpload) (BulkIngestPendingCopy, error)
	// Delete serialized data from the staging area, if needed.
	Delete(ctx context.Context, chunk BulkIngestPendingCopy) error
}

type BulkIngestImpl interface {
	// CreateTable is the first step, and should create the table to ingest into.
	CreateTable(ctx context.Context, schema *arrow.Schema, ifTableExists BulkIngestTableExistsBehavior, ifTableMissing BulkIngestTableMissingBehavior) error
	// CreateSink is called repeatedly to allocate a sink to write serialized data
	// into, if needed. Return BufferBulkIngestSink to use an in-memory staging area.
	CreateSink(ctx context.Context, options *BulkIngestOptions) (BulkIngestSink, error)
	// Serialize writes Arrow data into the sink, pulling from the stream of
	// batches. Returns (rows, bytes) written.
	Serialize(ctx context.Context, writerProps *WriterProps, schema *arrow.Schema, batches chan arrow.RecordBatch, sink BulkIngestSink) (int64, int64, error)
	// Copy actually uploads the given serialized data into the target table.
	Copy(ctx context.Context, chunk BulkIngestPendingCopy) error
}

type BulkIngestInitFinalizeImpl interface {
	// Init is called prior to any other methods.
	Init(ctx context.Context) error
	// Finalize ends the bulk ingest. It is always called.
	Finalize(ctx context.Context, success bool) error
}

type BulkIngestManager struct {
	Impl        BulkIngestImpl
	ErrorHelper *ErrorHelper
	Logger      *slog.Logger
	Alloc       memory.Allocator
	Ctx         context.Context
	Options     BulkIngestOptions
	Data        array.RecordReader
	// contains filtered or unexported fields
}

type BulkIngestOptions struct {
	// The table to ingest data into.
	TableName   string
	SchemaName  string
	CatalogName string
	// If true, use a temporary table.  The catalog/schema, if specified, will likely
	// be ignored (as temporary tables generally get implemented via a special
	// catalog/schema).
	Temporary bool
	// The ingest mode.
	Mode string
	// How far to read ahead on the data source
	ReadDepth int
	// How many parallel writers to use
	WriterParallelism int
	// How many parallel uploaders to use
	UploaderParallelism int
	// How many buffers to queue at once
	MaxPendingBuffers int
	// Format-specific options.
	WriterProps WriterProps
	// IngestBatchSize controls rows per INSERT during batched ingestion (0 means driver default)
	IngestBatchSize int
	// MaxQuerySizeBytes controls maximum SQL query size in bytes (0 means driver default)
	MaxQuerySizeBytes int
}

type BulkIngestPendingCopy interface {
	fmt.Stringer
	NumRows() int64
}

type BulkIngestPendingUpload struct {
	Data BulkIngestSink
	Rows int64
}

type BulkIngestSink interface {
	io.Closer
	Sink() io.Writer
}

type BulkIngestTableExistsBehavior int

type BulkIngestTableMissingBehavior int

type BulkIngestTransformImpl interface {
	TransformedSchema() *arrow.Schema
	TransformBatch(ctx context.Context, batch arrow.RecordBatch) (arrow.RecordBatch, error)
}

type ColumnInfo struct {
	ColumnName            string  `json:"column_name"`
	OrdinalPosition       *int32  `json:"ordinal_position,omitempty"`
	Remarks               *string `json:"remarks,omitempty"`
	XdbcDataType          *int16  `json:"xdbc_data_type,omitempty"`
	XdbcTypeName          *string `json:"xdbc_type_name,omitempty"`
	XdbcColumnSize        *int32  `json:"xdbc_column_size,omitempty"`
	XdbcDecimalDigits     *int16  `json:"xdbc_decimal_digits,omitempty"`
	XdbcNumPrecRadix      *int16  `json:"xdbc_num_prec_radix,omitempty"`
	XdbcNullable          *int16  `json:"xdbc_nullable,omitempty"`
	XdbcColumnDef         *string `json:"xdbc_column_def,omitempty"`
	XdbcSqlDataType       *int16  `json:"xdbc_sql_data_type,omitempty"`
	XdbcDatetimeSub       *int16  `json:"xdbc_datetime_sub,omitempty"`
	XdbcCharOctetLength   *int32  `json:"xdbc_char_octet_length,omitempty"`
	XdbcIsNullable        *string `json:"xdbc_is_nullable,omitempty"`
	XdbcScopeCatalog      *string `json:"xdbc_scope_catalog,omitempty"`
	XdbcScopeSchema       *string `json:"xdbc_scope_schema,omitempty"`
	XdbcScopeTable        *string `json:"xdbc_scope_table,omitempty"`
	XdbcIsAutoincrement   *bool   `json:"xdbc_is_autoincrement,omitempty"`
	XdbcIsGeneratedcolumn *bool   `json:"xdbc_is_generatedcolumn,omitempty"`
}

type Connection interface {
	adbc.ConnectionWithContext
	adbc.GetSetOptionsWithContext
}

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

type ConnectionImpl interface {
	adbc.ConnectionWithContext
	adbc.GetSetOptionsWithContext
	adbc.OTelTracing
	Base() *ConnectionImplBase
}

type ConnectionImplBase struct {
	Alloc       memory.Allocator
	ErrorHelper ErrorHelper
	DriverInfo  *DriverInfo
	Logger      *slog.Logger
	Tracer      trace.Tracer

	Autocommit bool
	Closed     bool
	// contains filtered or unexported fields
}

type ConstraintColumnUsage struct {
	ForeignKeyCatalog  *string `json:"fk_catalog,omitempty"`
	ForeignKeyDbSchema *string `json:"fk_db_schema,omitempty"`
	ForeignKeyTable    string  `json:"fk_table"`
	ForeignKeyColumn   string  `json:"fk_column_name"`
}

type ConstraintInfo struct {
	ConstraintName        *string                 `json:"constraint_name,omitempty"`
	ConstraintType        string                  `json:"constraint_type"`
	ConstraintColumnNames requiredList[string]    `json:"constraint_column_names"`
	ConstraintColumnUsage []ConstraintColumnUsage `json:"constraint_column_usage,omitempty"`
}

type CurrentNamespacer interface {
	GetCurrentCatalog(context.Context) (string, error)
	GetCurrentDbSchema(context.Context) (string, error)
	SetCurrentCatalog(context.Context, string) error
	SetCurrentDbSchema(context.Context, string) error
}

type DBSchemaInfo struct {
	DbSchemaName   *string     `json:"db_schema_name,omitempty"`
	DbSchemaTables []TableInfo `json:"db_schema_tables"`
}

type DataDependentMetadata interface {
	// Called after BeginAppending. Return nil if no changes are needed.
	UpdateSchema(ctx context.Context, oldSchema *arrow.Schema, firstBatch arrow.RecordBatch) (*arrow.Schema, error)
}

type Database interface {
	adbc.DatabaseWithContext
	adbc.GetSetOptionsWithContext
	adbc.DatabaseLogging
	adbc.OTelTracingInit
}

type DatabaseImpl interface {
	adbc.DatabaseWithContext
	adbc.GetSetOptionsWithContext
	Base() *DatabaseImplBase
}

type DatabaseImplBase struct {
	Alloc       memory.Allocator
	ErrorHelper ErrorHelper
	DriverInfo  *DriverInfo
	Logger      *slog.Logger
	Tracer      trace.Tracer
	// contains filtered or unexported fields
}

type DbObjectsEnumerator interface {
	GetCatalogs(ctx context.Context, catalogFilter *string) ([]string, error)
	GetDBSchemasForCatalog(ctx context.Context, catalog string, schemaFilter *string) ([]string, error)
	GetTablesForDBSchema(ctx context.Context, catalog string, schema string, tableFilter *string, columnFilter *string, includeColumns bool) ([]TableInfo, error)
}

type DbObjectsEnumeratorFactory func(context.Context) (DbObjectsEnumerator, error)

type Driver interface {
	DriverWithContext
}

type DriverImpl interface {
	DriverWithContext
	Base() *DriverImplBase
}

type DriverImplBase struct {
	Alloc       memory.Allocator
	ErrorHelper ErrorHelper
	DriverInfo  *DriverInfo
	Logger      *slog.Logger
}

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

type DriverInfoPreparer interface {
	PrepareDriverInfo(ctx context.Context, infoCodes []adbc.InfoCode) error
}

type DriverWithContext interface {
	NewDatabaseWithContext(ctx context.Context, opts map[string]string) (adbc.DatabaseWithContext, error)
}

type ErrorHelper struct {
	DriverName     string
	ErrorInspector ErrorInspector
}

type ErrorInspector interface {
	InspectError(err error, defaultStatus adbc.Status) adbc.Error
}

type GetObjectsInfo struct {
	CatalogName      *string        `json:"catalog_name,omitempty"`
	CatalogDbSchemas []DBSchemaInfo `json:"catalog_db_schemas"`
}

type ParquetIngestImpl struct{}

type RecordReaderImpl interface {
	io.Closer
	// AppendRows adds one or more rows of the current result set to the
	// record builder. Return io.EOF if no more rows can be appended from
	// the current result set. Return the number of rows appended, and an
	// estimate of row size. If ErrOverflow is returned, end the current
	// batch immediately. It is assumed the reader can retry again on the
	// next call.
	AppendRows(builder *array.RecordBuilder) (int64, int64, error)
	// BeginAppending is called exactly once before the first call to
	// AppendRow. The implementation can do any necessary initialization
	// here. It will be called after the first call to NextResultSet.
	BeginAppending(builder *array.RecordBuilder) error
	// NextResultSet closes the current result set and opens the next
	// result set for the given parameters. If there are no parameters, it
	// will be called exactly once with rec == nil.
	NextResultSet(ctx context.Context, rec arrow.RecordBatch, rowIdx int) (*arrow.Schema, error)
}

type Shared[T any] struct {
	// contains filtered or unexported fields
}

type SharedHandle[T any] struct {
	// contains filtered or unexported fields
}

type Statement interface {
	adbc.StatementWithContext
	adbc.GetSetOptionsWithContext
}

type StatementImpl interface {
	adbc.StatementWithContext
	adbc.StatementExecuteSchema
	adbc.GetSetOptionsWithContext
	adbc.OTelTracing
	Base() *StatementImplBase
}

type StatementImplBase struct {
	ErrorHelper ErrorHelper
	Tracer      trace.Tracer
	// contains filtered or unexported fields
}

type Statistic struct {
	TableName  string
	ColumnName *string // nil for table-level statistics
	Key        int16
	ValueKind  arrow.UnionTypeCode
	ValueI64   int64
	ValueU64   uint64
	ValueF64   float64
	ValueBin   []byte
	Approx     bool
}

type StatisticNameKey struct {
	Name string
	Key  int16
}

type SynchronousCancel interface {
	// Cancel is called to cancel the current query. Note that other
	// methods may be called after, but Cancel will not be called
	// concurrently with other methods. If possible an implementation
	// should handle context cancellation itself.
	Cancel()
}

type TableInfo struct {
	TableName        string           `json:"table_name"`
	TableType        string           `json:"table_type"`
	TableColumns     []ColumnInfo     `json:"table_columns"`
	TableConstraints []ConstraintInfo `json:"table_constraints"`
}

type TableTypeLister interface {
	ListTableTypes(ctx context.Context) ([]string, error)
}

type WriterProps struct {
	// A target file size in bytes.
	MaxBytes           int64
	ParquetWriterProps *parquet.WriterProperties
	ArrowWriterProps   pqarrow.ArrowWriterProperties
	ArrowIpcProps      []ipc.Option
}

type XdbcDataType int32