gocqlmem

type ClusteringOrderCaseSensitivity int

type ClusteringOrderType int

type ColumnSetExp struct {
	Name      string
	ExpLexems []*Lexem
}

type Command interface {
	GetCtxKeyspace() string
	SetCtxKeyspace(string)
}

type CommandCreateKeyspace struct {
	IfNotExists     bool
	KeyspaceName    string
	WithReplication []*KeyValuePair
}

type CommandCreateTable struct {
	CtxKeyspace          string
	IfNotExists          bool
	TableName            string
	ColumnDefs           []*CreateTableColumnDef
	PartitionKeyColumns  []string
	ClusteringKeyColumns []string
	ClusteringOrderBy    []*OrderByField
}

type CommandDelete struct {
	CtxKeyspace     string
	TableName       string
	ColumnsToDelete []string
	WhereExpLexems  []*Lexem
	IfExists        bool
	WhereExpAst     ast.Expr
}

type CommandDropKeyspace struct {
	IfExists     bool
	KeyspaceName string
}

type CommandDropTable struct {
	CtxKeyspace string
	IfExists    bool
	TableName   string
}

type CommandInsert struct {
	CtxKeyspace string
	TableName   string

	ColumnNames []string

	ColumnValueLexems [][]*Lexem
	// ColumnValueExpAsts []ast.Expr
	ColumnValues []any

	IfNotExists bool
}

type CommandSelect struct {
	CtxKeyspace     string
	Distinct        bool
	SelectExpLexems [][]*Lexem
	TableName       string
	WhereExpLexems  []*Lexem
	OrderByFields   []*OrderByField
	Limit           *Lexem
	SelectExpAsts   []ast.Expr
	SelectExpNames  []string
	WhereExpAst     ast.Expr
}

type CommandTruncateTable struct {
	CtxKeyspace string
	TableName   string
}

type CommandUpdate struct {
	CtxKeyspace string
	TableName   string

	ColumnSetExpressions []*ColumnSetExp
	ColumnSetExpAsts     []ast.Expr

	WhereExpLexems []*Lexem
	WhereExpAst    ast.Expr

	IfExists    bool
	IfExpLexems []*Lexem
	IfExpAst    ast.Expr
}

type CommandUseKeyspace struct {
	KeyspaceName string
}

type CqlDataType string

type CreateTableColumnDef struct {
	Name       string
	ColumnType gocql.Type
}

type Iter interface {
	Host() *gocql.HostInfo
	Columns() []gocql.ColumnInfo
	Attempts() int
	Latency() int64
	Keyspace() string
	Table() string
	Scanner() gocql.Scanner
	Scan(dest ...any) bool
	GetCustomPayload() map[string][]byte
	Warnings() []string
	Close() error
	WillSwitchPage() bool
	PageState() []byte
	NumRows() int
	RowData() (gocql.RowData, error)
	SliceMap() ([]map[string]any, error)
	MapScan(m map[string]any) bool

	// These methods are not in gocql, but it's worth adding them:
	Err() error       // Called by tests and Query wrappers around Iter (why do we need them, btw?): MapScan, Scan, ScanCAS, MapScanCAS
	SetErr(err error) // Called by Iter.Scan
}

type KeyValuePair struct {
	K string
	V *Lexem
}

type Keyspace struct {
	TableMap         map[string]*tableStore
	WithReplication  []*KeyValuePair
	Lock             sync.RWMutex
	TableMetadataMap map[string]*gocql.TableMetadata
}

type Lexem struct {
	T LexemType
	V string
}

type LexemType int

type OrderByField struct {
	FieldName       string
	ClusteringOrder ClusteringOrderType
	CaseSensitivity ClusteringOrderCaseSensitivity
}

type PrimaryKeyType int

type Query interface {
	Consistency(c gocql.Consistency) Query
	GetConsistency() gocql.Consistency
	CustomPayload(customPayload map[string][]byte) Query
	Trace(trace gocql.Tracer) Query
	Observer(observer gocql.QueryObserver) Query
	PageSize(n int) Query
	DefaultTimestamp(enable bool) Query
	WithTimestamp(timestamp int64) Query
	RoutingKey(routingKey []byte) Query
	Keyspace() string
	Prefetch(p float64) Query
	RetryPolicy(r gocql.RetryPolicy) Query
	SetSpeculativeExecutionPolicy(sp gocql.SpeculativeExecutionPolicy) Query
	IsIdempotent() bool
	Idempotent(value bool) Query
	Bind(v ...any) Query
	SerialConsistency(cons gocql.Consistency) Query
	PageState(state []byte) Query
	NoSkipMetadata() Query
	Exec() error
	ExecContext(ctx context.Context) error
	Iter() Iter
	IterContext(ctx context.Context) Iter
	MapScan(m map[string]any) error
	MapScanContext(ctx context.Context, m map[string]any) error
	Scan(dest ...any) error
	ScanContext(ctx context.Context, dest ...any) error
	ScanCAS(dest ...any) (applied bool, err error)
	ScanCASContext(ctx context.Context, dest ...any) (applied bool, err error)
	MapScanCAS(dest map[string]any) (applied bool, err error)
	MapScanCASContext(ctx context.Context, dest map[string]any) (applied bool, err error)
	SetHostID(hostID string) Query
	GetHostID() string
	SetKeyspace(keyspace string) Query
	WithNowInSeconds(now int) Query
}

type Session interface {
	AwaitSchemaAgreement(ctx context.Context) error
	Query(stmt string, values ...any) Query
	Bind(stmt string, b func(q *gocql.QueryInfo) ([]any, error)) Query
	Close()
	Closed() bool
	KeyspaceMetadata(keyspace string) (*gocql.KeyspaceMetadata, error)
	Batch(typ gocql.BatchType) *gocql.Batch
	GetHosts() []*gocql.HostInfo
}