api

type Array interface {
	// MetaData returns the array's metadata (base type + element count).
	MetaData() ArrayMetaData

	// BaseType returns the JDBC type code of the array element type
	// (matches java.sql.Array.getBaseType()).
	BaseType() int
	// BaseTypeName returns the display name of the element type.
	BaseTypeName() string

	// Length returns the number of elements.
	Length() int

	// Element returns the element at oneBasedIndex (1-indexed per
	// JDBC convention). Returns ErrCodeInvalidColumnReference if out
	// of range.
	Element(oneBasedIndex int) (any, error)
	// Elements returns every element in order. Convenience wrapper
	// around repeated Element calls.
	Elements() []any
}

type ArrayMetaData interface {
	// ElementType returns the JDBC type code of elements.
	ElementType() int
	// ElementTypeName returns the display name of the element type.
	ElementTypeName() string
	// ElementDataType returns the full DataType — carries struct/enum
	// detail that the JDBC code alone can't convey. Relational-specific
	// extension over JDBC's ArrayMetaData.
	ElementDataType() DataType
	// Nullable reports whether elements may be NULL. One of the
	// ColumnNullable* constants.
	Nullable() int
}

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

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

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

type Code uint8

type Column interface {
	Metadata
	// DataType returns the column's declared type.
	DataType() DataType
}

type CompositeType interface {
	// HasIdenticalStructure reports structural compatibility. Unlike
	// Equal, this treats composites with the same shape as identical
	// regardless of name identity. Default behavior delegates to Equal.
	HasIdenticalStructure(other any) bool
}

type Connection interface {
	// CreateStatement constructs an empty RelationalStatement. Matches
	// Java's createStatement(). The statement shares the connection's
	// lifecycle — closing the connection invalidates it.
	CreateStatement(ctx context.Context) (Statement, error)

	// PrepareStatement compiles sql (with `?` placeholders) into a
	// reusable prepared statement. Matches Java's
	// prepareStatement(String).
	PrepareStatement(ctx context.Context, sql string) (PreparedStatement, error)

	// Options returns the current options map. Matches Java's
	// getOptions().
	Options() *Options
	// SetOption applies name=value to the connection-level options.
	// Matches Java's setOption(Name, Object).
	SetOption(name OptionName, value any) error

	// Path returns the database path this connection targets (matches
	// Java's getPath() returning a URI).
	Path() *url.URL

	// SetAutoCommit toggles auto-commit mode. Matches JDBC's
	// Connection.setAutoCommit.
	SetAutoCommit(autoCommit bool) error
	// AutoCommit reports the current auto-commit mode.
	AutoCommit() bool

	// Commit / Rollback end the current explicit transaction. Return
	// ErrCodeCannotCommitRollbackWithAutocommit if called with
	// auto-commit enabled (matches Java's behavior).
	Commit() error
	Rollback() error

	// SetSchema selects the default schema. Matches JDBC's
	// setSchema(String).
	SetSchema(schema string) error
	// Schema returns the current default schema name. Empty if none.
	Schema() string

	// Close releases the connection. Idempotent — close twice must
	// not panic.
	Close() error
	// IsClosed reports whether Close has been called.
	IsClosed() bool
}

type Continuation interface {
	// Serialize returns a wire-compatible representation that encodes
	// the continuation's full state. Must be round-trippable by
	// implementations.
	Serialize() []byte

	// ExecutionState returns the underlying cursor state bytes. A nil
	// result means "at the beginning"; an empty (length-0) result
	// means "at the end".
	ExecutionState() []byte

	// Reason explains why the continuation was generated.
	Reason() ContinuationReason
}

type ContinuationReason int

type DataType interface {
	// Code returns the type's discriminator.
	Code() Code
	// IsNullable reports whether the type admits NULL.
	IsNullable() bool
	// IsPrimitive reports whether the type is a flat scalar.
	IsPrimitive() bool
	// IsResolved reports whether this type and all of its constituent
	// types are resolved (no UnresolvedType anywhere in the tree).
	IsResolved() bool
	// WithNullable returns a copy of the type with the given nullability.
	// For singleton primitives it returns the corresponding cached
	// instance; for composites it returns a new value.
	WithNullable(isNullable bool) DataType
	// Resolve replaces UnresolvedType references anywhere in this
	// type's tree using the given resolution map. If the type is
	// already resolved, returns the receiver unchanged.
	Resolve(resolution map[string]Named) DataType
	// Equal reports structural equality. Matches Java's equals()
	// override on each concrete type.
	Equal(other DataType) bool
	// String renders the type as human-readable text. The exact format
	// matches Java's toString() — "int", "int ∪ ∅", "[int]", etc.
	String() string
}

type DatabaseMetaData interface {
	// Schemas returns every schema in every catalog.
	//
	// Columns:
	//   1 TABLE_SCHEM   string
	//   2 TABLE_CATALOG string
	Schemas(ctx context.Context) (ResultSet, error)

	// SchemasFiltered returns schemas matching the SQL LIKE
	// catalog + schemaPattern filters. Empty patterns match anything.
	SchemasFiltered(ctx context.Context, catalog, schemaPattern string) (ResultSet, error)

	// Tables returns tables matching the patterns. types is an
	// optional list of table types ("TABLE", "VIEW", "SYSTEM TABLE");
	// nil or empty returns all types.
	//
	// Columns (matching JDBC's DatabaseMetaData.getTables):
	//   1 TABLE_CAT   string  2 TABLE_SCHEM string  3 TABLE_NAME string
	//   4 TABLE_TYPE  string  5 REMARKS string      6 TYPE_CAT string
	//   7 TYPE_SCHEM  string  8 TYPE_NAME string    9 SELF_REFERENCING_COL_NAME string
	//  10 REF_GENERATION string
	Tables(ctx context.Context, catalog, schemaPattern, tableNamePattern string, types []string) (ResultSet, error)

	// Columns returns column metadata matching the patterns.
	//
	// Columns (matching JDBC's DatabaseMetaData.getColumns):
	//   1 TABLE_CAT  2 TABLE_SCHEM  3 TABLE_NAME  4 COLUMN_NAME
	//   5 DATA_TYPE (int, JDBC type code)  6 TYPE_NAME
	//   7 COLUMN_SIZE  8 BUFFER_LENGTH  9 DECIMAL_DIGITS 10 NUM_PREC_RADIX
	//  11 NULLABLE  12 REMARKS  13 COLUMN_DEF  14 SQL_DATA_TYPE
	//  15 SQL_DATETIME_SUB  16 CHAR_OCTET_LENGTH  17 ORDINAL_POSITION
	//  18 IS_NULLABLE  19 SCOPE_CATALOG  20 SCOPE_SCHEMA  21 SCOPE_TABLE
	//  22 SOURCE_DATA_TYPE  23 IS_AUTOINCREMENT  24 IS_GENERATEDCOLUMN
	Columns(ctx context.Context, catalog, schemaPattern, tableNamePattern, columnNamePattern string) (ResultSet, error)

	// IndexInfo returns secondary-index metadata for a table. If
	// unique is true, only unique indexes are returned. The
	// approximate flag tells the driver whether it may return stale
	// statistics (speed vs. freshness).
	//
	// Columns: 1 TABLE_CAT  2 TABLE_SCHEM  3 TABLE_NAME
	//          4 NON_UNIQUE  5 INDEX_QUALIFIER  6 INDEX_NAME
	//          7 TYPE  8 ORDINAL_POSITION  9 COLUMN_NAME
	//         10 ASC_OR_DESC  11 CARDINALITY  12 PAGES  13 FILTER_CONDITION
	IndexInfo(ctx context.Context, catalog, schema, table string, unique, approximate bool) (ResultSet, error)

	// PrimaryKeys returns the primary-key columns of the given table.
	//
	// Columns: 1 TABLE_CAT  2 TABLE_SCHEM  3 TABLE_NAME
	//          4 COLUMN_NAME  5 KEY_SEQ  6 PK_NAME
	PrimaryKeys(ctx context.Context, catalog, schema, table string) (ResultSet, error)

	// URL returns the JDBC-style URL this connection was opened with.
	URL() string
	// UserName returns the authenticated user, or empty if none.
	UserName() string
	// IsReadOnly reports whether the underlying database is read-only.
	IsReadOnly() bool

	// DatabaseProductName returns a human-readable database name
	// ("FoundationDB Relational"). Tools use this to route
	// dialect-specific quirks.
	DatabaseProductName() string
	// DatabaseProductVersion is the database version string.
	DatabaseProductVersion() string
	// DriverName is the relational-layer driver name.
	DriverName() string
	// DriverVersion is the driver version string.
	DriverVersion() string
}

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

type DirectAccessStatement interface {
	// ExecuteScan scans a contiguous range of rows in tableName,
	// using keyPrefix as a PK-prefix. keyPrefix may be EmptyKeySet to
	// scan the full table. Fails if keyPrefix columns are not a
	// prefix of the table's primary key.
	ExecuteScan(ctx context.Context, tableName string, keyPrefix *KeySet, opts *Options) (ResultSet, error)

	// ExecuteGet returns a single row by its primary key. Returns an
	// empty ResultSet (Next()=false) if the row does not exist.
	ExecuteGet(ctx context.Context, tableName string, key *KeySet, opts *Options) (ResultSet, error)

	// ExecuteInsert inserts one or more rows. Returns the number of
	// rows actually inserted (may be 0 for IF-NOT-EXISTS semantics
	// with REPLACE_ON_DUPLICATE_PK=false).
	ExecuteInsert(ctx context.Context, tableName string, data []Struct, opts *Options) (int64, error)

	// ExecuteDelete deletes a single row by primary key. Returns the
	// number of rows deleted (0 or 1).
	ExecuteDelete(ctx context.Context, tableName string, key *KeySet, opts *Options) (int64, error)

	// ExecuteDeleteRange bulk-deletes every row matching the
	// keyPrefix. Equivalent to DELETE FROM tableName WHERE PK-prefix
	// matches. Returns the number of rows removed.
	ExecuteDeleteRange(ctx context.Context, tableName string, keyPrefix *KeySet, opts *Options) (int64, error)
}

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

type Driver interface {
	// Connect opens a connection to the database described by url
	// with the given options. ctx propagates cancellation/deadlines.
	// Mirrors Java's RelationalDriver.connect(URI, Options).
	Connect(ctx context.Context, url *url.URL, opts *Options) (Connection, error)

	// MajorVersion / MinorVersion report the driver version. Java
	// exposes these via java.sql.Driver; kept here because our
	// DatabaseMetaData will surface them.
	MajorVersion() int
	MinorVersion() int
}

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

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

type Error struct {
	// Code is the SQLSTATE error code.
	Code ErrorCode
	// Message is the human-readable error description.
	Message string
	// Cause is the underlying error, if any. Unwrap returns it.
	Cause error
	// Context carries optional structured logging fields (table name,
	// column name, etc.). Corresponds to Java's errorContext map.
	Context map[string]any
}

type ErrorCode string

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

type Index interface {
	Metadata
	// TableName returns the name of the owning table.
	TableName() string
	// IndexType returns the index-type string (VALUE, COUNT, RANK,
	// VERSION, TEXT, VECTOR, ...). Matches Java IndexTypes constants.
	IndexType() string
	// IsUnique reports whether the index rejects duplicate entries.
	IsUnique() bool
	// IsSparse reports whether the index skips rows where the
	// expression evaluates to null.
	IsSparse() bool
}

type IndexFetchMethod int

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

type InvokedRoutine interface {
	Metadata
}

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

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

type Metadata interface {
	// MetadataName returns the node's own name. Named "MetadataName"
	// rather than "Name" so embeddings keep Name() free for other
	// uses (e.g. ColumnName() on Column).
	MetadataName() string
	// Accept dispatches through the given Visitor. Implementations
	// should call the appropriate v.Visit* method for their type
	// and (for composite nodes) recurse into children.
	Accept(v Visitor)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Named interface {
	Name() string
}

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

type OptionName string

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

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

type ParseTreeInfo interface {
	// QueryType returns the top-level query kind.
	QueryType() QueryType
}

type PreparedStatement interface {
	Statement

	// SetObject binds value to parameter at parameterIndex
	// (1-indexed per JDBC convention, not 0-indexed).
	SetObject(parameterIndex int, value any) error
	// ClearParameters unbinds every parameter.
	ClearParameters() error

	// ExecuteQueryPrepared runs the statement with the currently-bound
	// parameters.
	ExecuteQueryPrepared(ctx context.Context) (ResultSet, error)
	// ExecuteUpdatePrepared runs the statement with bound parameters
	// as an update.
	ExecuteUpdatePrepared(ctx context.Context) (int64, error)
}

type QueryType int

type ResultSet interface {
	// Next advances to the next row. Returns true if there is one,
	// false on end-of-rows or error. Call Err() after Next()=false to
	// check for an error vs. a clean end-of-cursor.
	Next() bool
	// Err returns any error that terminated iteration, or nil on a
	// clean EOF. Idiomatic Go — matches sql.Rows.Err() shape.
	Err() error

	// Close releases resources. Safe to call multiple times.
	Close() error

	// MetaData returns the ResultSetMetaData describing columns.
	MetaData() ResultSetMetaData

	// Typed column getters. columnIndex is 1-based per JDBC. Return
	// ErrCodeInvalidColumnReference for out-of-range index and
	// ErrCodeCannotConvertType for unsupported coercion.
	Long(columnIndex int) (int64, error)
	Float(columnIndex int) (float32, error)
	Double(columnIndex int) (float64, error)
	String(columnIndex int) (string, error)
	Bytes(columnIndex int) ([]byte, error)
	Boolean(columnIndex int) (bool, error)
	Object(columnIndex int) (any, error)

	// WasNull reports whether the last column read was SQL NULL.
	// Matches JDBC's wasNull() protocol.
	WasNull() bool

	// Continuation returns the current cursor position, suitable for
	// resumption in a later transaction.
	Continuation() (Continuation, error)

	// LongByName / StringByName / etc. accept a column name instead of
	// a numeric index. Convenience accessors on top of the positional
	// ones — implementations should use MetaData to resolve names.
	LongByName(columnName string) (int64, error)
	StringByName(columnName string) (string, error)
	BytesByName(columnName string) ([]byte, error)
	BooleanByName(columnName string) (bool, error)
	ObjectByName(columnName string) (any, error)
}

type ResultSetMetaData interface {
	// ColumnCount returns the number of columns.
	ColumnCount() int
	// ColumnName returns the column name at columnIndex.
	ColumnName(columnIndex int) (string, error)
	// ColumnLabel returns the alias used in the query (fallback:
	// ColumnName). Matches JDBC's ResultSetMetaData.getColumnLabel.
	ColumnLabel(columnIndex int) (string, error)
	// ColumnType returns the JDBC type code for columnIndex.
	ColumnType(columnIndex int) (int, error)
	// ColumnTypeName returns the SQL display name ("INTEGER", ...).
	ColumnTypeName(columnIndex int) (string, error)
	// ColumnNullable reports whether the column admits NULL. Value
	// is one of the JDBC ColumnNullable* constants.
	ColumnNullable(columnIndex int) (int, error)
	// ColumnDataType returns the richer DataType for the column.
	// Does not exist in JDBC — relational-specific extension to
	// carry struct/array/enum detail.
	ColumnDataType(columnIndex int) (DataType, error)
}

type Row interface {
	// NumFields returns the field count.
	NumFields() int

	// Long returns the value at position as an int64. Returns
	// ErrCodeCannotConvertType if the field is not integer-coercible,
	// or ErrCodeInvalidColumnReference if position is out of range.
	Long(position int) (int64, error)

	// Float returns the value at position as a float32.
	Float(position int) (float32, error)

	// Double returns the value at position as a float64.
	Double(position int) (float64, error)

	// String returns the value at position as a string.
	String(position int) (string, error)

	// Bytes returns the value at position as []byte.
	Bytes(position int) ([]byte, error)

	// Row returns the value at position as a nested Row (STRUCT).
	Row(position int) (Row, error)

	// Array returns the value at position as a sequence of Rows
	// (ARRAY). Callers iterate with the returned Iterable.
	Array(position int) (RowIterable, error)

	// Object returns the value at position as an untyped any.
	// Returns ErrCodeInvalidColumnReference if position is out of range.
	Object(position int) (any, error)

	// StartsWith reports whether the receiver begins with the given
	// prefix row (element-wise comparison of the first len(prefix)
	// fields).
	StartsWith(prefix Row) bool

	// Prefix returns a view of this row's first length fields.
	Prefix(length int) Row
}

type RowIterable interface {
	// Next advances the cursor. Returns false when exhausted.
	Next() bool
	// Row returns the current row. Undefined if Next returned false.
	Row() Row
	// Close releases any resources. Idempotent.
	Close() error
}

type SQLTypeName string

type Schema interface {
	Metadata
	// SchemaTemplate returns the template this schema was generated
	// from. Matches Java's Schema.getSchemaTemplate().
	SchemaTemplate() SchemaTemplate
	// DatabaseName returns the owning database's name.
	DatabaseName() string
	// Tables delegates to SchemaTemplate.Tables — convenience matching
	// Java's default Schema.getTables().
	Tables() ([]Table, error)
	// Views delegates to SchemaTemplate.Views.
	Views() ([]View, error)
	// Indexes returns the (tableName -> indexNames) mapping — matches
	// Java's Schema.getIndexes() default which delegates to the
	// template's TableIndexMapping. NOT the same shape as
	// SchemaTemplate.Indexes (which returns a flat []string).
	Indexes() (map[string][]string, error)
	// InvokedRoutines delegates to SchemaTemplate.InvokedRoutines.
	InvokedRoutines() ([]InvokedRoutine, error)
}

type SchemaTemplate interface {
	Metadata
	// Version is the schema version; incremented on every metadata
	// change. Matches RecordMetaData.version semantics.
	Version() int
	// EnableLongRows allows records larger than 100 KB via split
	// records (matches RecordMetaData.splitLongRecords).
	EnableLongRows() bool
	// StoreRowVersions indicates each row carries a monotonically
	// increasing version (matches Java's storeRowVersions).
	StoreRowVersions() bool
	// IntermingleTables reports whether rows from different record
	// types share the same keyspace prefix (no RecordTypeKey prefix
	// on primary keys). Matches Java's
	// RecordLayerSchemaTemplate.isIntermingleTables() which is
	// derived from `!primaryKeyHasRecordTypePrefix()`.
	IntermingleTables() bool
	// Tables returns the tables defined in this template. Error is
	// reserved for I/O / catalog-access failures; an empty template
	// returns a nil slice and nil error.
	Tables() ([]Table, error)
	// Views returns the views defined in this template. Same error
	// semantics as Tables.
	Views() ([]View, error)
	// FindTable looks up a table by name. Returns (nil, nil) when the
	// name is not found; returns an error only on a catalog access
	// failure.
	FindTable(name string) (Table, error)
	// FindView looks up a view by name; same not-found semantics as
	// FindTable.
	FindView(name string) (View, error)
	// TableIndexMapping returns (tableName → []indexName) mapping
	// (Java returns Guava Multimap; Go idiom is a map-of-slices).
	TableIndexMapping() (map[string][]string, error)
	// Indexes returns the names of every index declared in this
	// template.
	Indexes() ([]string, error)
	// InvokedRoutines returns every routine declared in this template.
	InvokedRoutines() ([]InvokedRoutine, error)
	// FindInvokedRoutine looks up a routine by name; nil if not found.
	FindInvokedRoutine(name string) (InvokedRoutine, error)
	// TemporaryInvokedRoutines returns transient routines added during
	// the current transaction.
	TemporaryInvokedRoutines() ([]InvokedRoutine, error)
	// TransactionBoundMetadataAsString is a diagnostic string
	// representation of the transaction-bound metadata.
	TransactionBoundMetadataAsString() (string, error)
	// GenerateSchema materializes a Schema from this template.
	GenerateSchema(databaseID, schemaName string) Schema
}

type SchemaTemplateCatalog interface {
	// DoesSchemaTemplateExist checks whether any version of the given
	// template name exists in the catalog.
	DoesSchemaTemplateExist(txn Transaction, templateName string) (bool, error)
	// DoesSchemaTemplateExistAtVersion checks whether a specific
	// (name, version) is present. Java overloads the method name; Go
	// splits the two paths to avoid optional-argument hacks.
	DoesSchemaTemplateExistAtVersion(txn Transaction, templateName string, version int) (bool, error)
	// LoadSchemaTemplate loads the latest version of templateName.
	// Returns an *Error with Code == ErrCodeUnknownSchemaTemplate
	// when templateName is not found.
	LoadSchemaTemplate(txn Transaction, templateName string) (SchemaTemplate, error)
	// LoadSchemaTemplateAtVersion loads a specific version. Same
	// not-found semantics as LoadSchemaTemplate.
	LoadSchemaTemplateAtVersion(txn Transaction, templateName string, version int) (SchemaTemplate, error)
	// CreateTemplate persists a new template version. Returns an
	// *Error with ErrCodeDuplicateSchemaTemplate when (name, version)
	// already exists.
	CreateTemplate(txn Transaction, newTemplate SchemaTemplate) error
	// ListTemplates returns a ResultSet over every template version
	// in the catalog.
	ListTemplates(txn Transaction) (ResultSet, error)
	// DeleteTemplate removes ALL versions of templateName. When
	// throwIfDoesNotExist is true and the template is missing, an
	// *Error with ErrCodeUnknownSchemaTemplate is returned.
	DeleteTemplate(txn Transaction, templateName string, throwIfDoesNotExist bool) error
	// DeleteTemplateVersion removes one specific (name, version).
	DeleteTemplateVersion(txn Transaction, templateName string, version int, throwIfDoesNotExist bool) error
}

type Statement interface {
	// ExecuteQuery runs a SELECT and returns a ResultSet. The cursor
	// owns the underlying FDB transaction for its lifetime (auto-close
	// when the ResultSet is closed).
	ExecuteQuery(ctx context.Context, sql string) (ResultSet, error)

	// ExecuteUpdate runs a DML statement (INSERT/UPDATE/DELETE) or DDL
	// and returns the number of affected rows (matching Java's
	// executeUpdate / Statement.executeUpdate).
	ExecuteUpdate(ctx context.Context, sql string) (int64, error)

	// Execute runs an arbitrary statement. Returns true if it produces
	// a ResultSet; false if it returns an update count. After calling,
	// use ResultSet() / UpdateCount() to retrieve the result.
	Execute(ctx context.Context, sql string) (bool, error)

	// ResultSet returns the ResultSet from the last Execute, or nil.
	ResultSet() ResultSet
	// UpdateCount returns the row count from the last Execute, or -1
	// if the last operation produced a ResultSet.
	UpdateCount() int64

	// Close releases the statement. Idempotent.
	Close() error
	// IsClosed reports whether Close has been called.
	IsClosed() bool
}

type StoreCatalog interface {
	// SchemaTemplateCatalog returns the nested template catalog used
	// by this store. Schemas reference their template by (name,
	// version) via the template catalog.
	SchemaTemplateCatalog() SchemaTemplateCatalog

	// LoadSchema returns the Schema for (databaseID, schemaName).
	// Returns *Error with ErrCodeUndefinedSchema if not found.
	LoadSchema(txn Transaction, databaseID, schemaName string) (Schema, error)

	// SaveSchema persists or updates a Schema. If
	// createDatabaseIfNecessary is true and the owning database does
	// not yet exist, it is created atomically with the schema. Java
	// raises on transaction-level conflicts; in Go those surface as
	// errors returned by the Transaction.Commit call, not from here.
	SaveSchema(txn Transaction, dataToWrite Schema, createDatabaseIfNecessary bool) error

	// RepairSchema rebinds schemaName in databaseID to the latest
	// version of its owning template. Matches Java's
	// repairSchema — a no-op when the schema is already on the
	// latest template version.
	RepairSchema(txn Transaction, databaseID, schemaName string) error

	// CreateDatabase records a new database entry keyed by dbURI.
	// Returns an error when the database already exists.
	CreateDatabase(txn Transaction, dbURI string) error

	// ListDatabases returns a ResultSet over every database entry.
	ListDatabases(txn Transaction, continuation Continuation) (ResultSet, error)

	// ListSchemas returns a ResultSet over every schema in every
	// database. Matches Java's listSchemas(txn, continuation).
	ListSchemas(txn Transaction, continuation Continuation) (ResultSet, error)

	// ListSchemasInDatabase narrows ListSchemas to a single database.
	// Java overloads listSchemas; Go splits for clarity.
	ListSchemasInDatabase(txn Transaction, databaseID string, continuation Continuation) (ResultSet, error)

	// DeleteSchema removes schemaName from databaseID. Underlying
	// record store data is NOT purged — callers are responsible for
	// that per Java's documented contract.
	DeleteSchema(txn Transaction, dbURI, schemaName string) error

	// DoesDatabaseExist reports whether dbURI is present in the
	// catalog.
	DoesDatabaseExist(txn Transaction, dbURI string) (bool, error)

	// DoesSchemaExist reports whether (dbURI, schemaName) resolves
	// to a Schema.
	DoesSchemaExist(txn Transaction, dbURI, schemaName string) (bool, error)

	// DeleteDatabase removes the database and every schema within.
	// Underlying record-store data is NOT purged — the caller must
	// clear it separately if needed. When throwIfDoesNotExist is
	// false, a missing database is a no-op.
	//
	// Returns (true, nil) on success, (false, nil) when the
	// transaction runs out of time partway through and the caller
	// should retry — matches Java's boolean return.
	DeleteDatabase(txn Transaction, dbURI string, throwIfDoesNotExist bool) (bool, error)
}

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

type Struct interface {
	// MetaData returns the struct's metadata.
	MetaData() StructMetaData

	// AttributeCount returns the number of attributes without the
	// error return that the getter methods need.
	AttributeCount() int

	// Attribute returns the attribute value at oneBasedIndex (1-indexed
	// per JDBC convention). Returns ErrCodeInvalidColumnReference if
	// out of range.
	Attribute(oneBasedIndex int) (any, error)
	// AttributeByName looks up by name (case-sensitive; uppercasing
	// is caller's responsibility).
	AttributeByName(name string) (any, error)

	// Attributes returns every attribute in declared order.
	Attributes() []any
}

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

type StructMetaData interface {
	// TypeName returns the struct type's user-visible name.
	TypeName() string
	// AttributeCount returns the number of attributes.
	AttributeCount() int
	// AttributeName returns the name of the attribute at oneBasedIndex.
	AttributeName(oneBasedIndex int) (string, error)
	// AttributeType returns the JDBC type code of the attribute.
	AttributeType(oneBasedIndex int) (int, error)
	// AttributeTypeName returns the display name of the attribute
	// type (e.g. "INTEGER", "STRING").
	AttributeTypeName(oneBasedIndex int) (string, error)
	// AttributeDataType returns the full DataType for richer struct/
	// array detail (relational-specific extension over JDBC).
	AttributeDataType(oneBasedIndex int) (DataType, error)
	// AttributeNullable reports whether the attribute admits NULL.
	// One of the ColumnNullable* constants.
	AttributeNullable(oneBasedIndex int) (int, error)
}

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

type Table interface {
	Metadata
	// Indexes returns the indexes defined on this table.
	Indexes() []Index
	// Columns returns the columns in declared order.
	Columns() []Column
	// StructDataType returns the struct type whose fields match this
	// table's columns. Matches Java's Table.getDatatype() returning
	// DataType.StructType.
	StructDataType() *StructType
}

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

type Transaction interface {
	// Commit finalises the transaction. Returns an error if the
	// commit fails (storage-engine conflict, deadline exceeded, etc.)
	// or if the transaction has already been closed.
	Commit() error
	// Abort cancels the transaction and discards any pending writes.
	Abort() error
	// BoundSchemaTemplate returns the schema template bound to this
	// transaction, or nil if none is bound. Matches Java's
	// Optional<SchemaTemplate> getBoundSchemaTemplateMaybe() —
	// "maybe" is modelled as a nil return in Go.
	BoundSchemaTemplate() SchemaTemplate
	// SetBoundSchemaTemplate binds (or replaces) the schema template
	// for the duration of this transaction. Any subsequent
	// metadata-requiring operation uses the bound template.
	SetBoundSchemaTemplate(template SchemaTemplate)
	// UnsetBoundSchemaTemplate clears any previously bound template.
	UnsetBoundSchemaTemplate()
	// Close releases the underlying resources. Safe to call on an
	// already-committed or already-aborted transaction — second call
	// is a no-op that returns nil. Matches Java's AutoCloseable.close.
	Close() error
	// IsClosed reports whether Close has been called (directly or
	// via a successful Commit / Abort).
	IsClosed() bool
	// Unwrap returns the underlying backend-specific handle. Callers
	// perform a type assertion on the result. A future remote/gRPC
	// transaction impl that wraps a local one must forward Unwrap()
	// to preserve the chain.
	Unwrap() any
}

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

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

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