gockle

type Batch interface {
	// Add adds the query for statement and arguments.
	Add(statement string, arguments ...interface{})

	// Exec executes the queries in the order they were added.
	Exec() error

	// ExecTx executes the queries in the order they were added. It returns a slice
	// of maps from columns to values, the maps corresponding to all the conditional
	// queries, and ordered in the same relative order. The special column
	// ColumnApplied has a bool that indicates whether the conditional statement was
	// applied. If a conditional statement was not applied, the current values for
	// the columns are put into the map.
	ExecTx() ([]map[string]interface{}, error)
}

type BatchKind byte

type BatchMock struct {
	mock.Mock
}

type Iterator interface {
	// Close closes the Iterator.
	Close() error

	// Scan puts the current result row in results and returns whether there are
	// more result rows.
	Scan(results ...interface{}) bool

	// ScanMap puts the current result row in results and returns whether there are
	// more result rows.
	ScanMap(results map[string]interface{}) bool

	// WillSwitchPage detects if iterator reached end of current page and the
	// next page is available.
	WillSwitchPage() bool
	// PageState return the current paging state for a query which can be used
	// for subsequent quries to resume paging this point.
	PageState() []byte
}

type IteratorMock struct {
	mock.Mock
}

type Query interface {
	// Consistency sets the consistency level for this query. If no consistency
	// level have been set, the default consistency level of the cluster
	// is used.
	Consistency(c gocql.Consistency) Query
	// PageSize will tell the iterator to fetch the result in pages of size n.
	// This is useful for iterating over large result sets, but setting the
	// page size too low might decrease the performance. This feature is only
	// available in Cassandra 2 and onwards.
	PageSize(n int) Query
	// WithContext will set the context to use during a query, it will be used to
	// timeout when waiting for responses from Cassandra.
	WithContext(ctx context.Context) Query
	// PageState sets the paging state for the query to resume paging from a specific
	// point in time. Setting this will disable to query paging for this query, and
	// must be used for all subsequent pages.
	PageState(state []byte) Query
	// Exec executes the query without returning any rows.
	Exec() error
	// Iter executes the query and returns an iterator capable of iterating
	// over all results.
	Iter() Iterator
	// MapScan executes the query, copies the columns of the first selected
	// row into the map pointed at by m and discards the rest. If no rows
	// were selected, ErrNotFound is returned.
	MapScan(m map[string]interface{}) error
	// Scan executes the query, copies the columns of the first selected
	// row into the values pointed at by dest and discards the rest. If no rows
	// were selected, ErrNotFound is returned.
	Scan(dest ...interface{}) error
	// Release releases a query back into a pool of queries. Released Queries
	// cannot be reused.
	//
	// Example:
	//              qry := session.Query("SELECT * FROM my_table")
	//              qry.Exec()
	//              qry.Release()
	Release()
}

type QueryMock struct {
	mock.Mock
}

type Session interface {
	// Batch returns a new Batch for the Session.
	Batch(kind BatchKind) Batch

	// Close closes the Session.
	Close()

	// Columns returns a map from column names to types for keyspace and table.
	// Schema changes during a session are not reflected; you must open a new
	// Session to observe them.
	Columns(keyspace, table string) (map[string]gocql.TypeInfo, error)

	// Exec executes the query for statement and arguments.
	Exec(statement string, arguments ...interface{}) error

	// Scan executes the query for statement and arguments and puts the first
	// result row in results.
	Scan(statement string, results []interface{}, arguments ...interface{}) error

	// ScanIterator executes the query for statement and arguments and returns an
	// Iterator for the results.
	ScanIterator(statement string, arguments ...interface{}) Iterator

	// ScanMap executes the query for statement and arguments and puts the first
	// result row in results.
	ScanMap(statement string, results map[string]interface{}, arguments ...interface{}) error

	// ScanMapSlice executes the query for statement and arguments and returns all
	// the result rows.
	ScanMapSlice(statement string, arguments ...interface{}) ([]map[string]interface{}, error)

	// ScanMapTx executes the query for statement and arguments as a lightweight
	// transaction. If the query is not applied, it puts the current values for the
	// conditional columns in results. It returns whether the query is applied.
	ScanMapTx(statement string, results map[string]interface{}, arguments ...interface{}) (bool, error)

	// Tables returns the table names for keyspace. Schema changes during a session
	// are not reflected; you must open a new Session to observe them.
	Tables(keyspace string) ([]string, error)

	// Query generates a new query object for interacting with the database.
	// Further details of the query may be tweaked using the resulting query
	// value before the query is executed. Query is automatically prepared if
	// it has not previously been executed.
	Query(statement string, arguments ...interface{}) Query
}

type SessionMock struct {
	mock.Mock
}