pgxapi

type CanPostGet interface {
	PostGet() error
}

type CanPreInsert interface {
	PreInsert() error
}

type CanPreUpdate interface {
	PreUpdate() error
}

type CoreTable struct {
	Nm TableName
	Ex Execer
}

type DBStats = sql.DBStats

type Execer interface {
	Getter

	// Exec executes a query without returning any rows.
	// The arguments are for any placeholder parameters in the query.
	Exec(ctx context.Context, sql string, arguments ...interface{}) (int64, error)

	// Insert executes a query and returns the insertion ID.
	// The primary key column, pk, is used for some dialects, notably PostgreSQL.
	// The arguments are for any placeholder parameters in the query.
	Insert(ctx context.Context, pk, query string, arguments ...interface{}) (int64, error)

	IsTx() bool

	// Logger gets the trace logger. Note that you can use this to rotate the output writer
	// via its SetOutput method. Also, it can even disable it completely (via ioutil.Discard).
	Logger() Logger

	// Dialect gets the database dialect.
	Dialect() driver.Dialect
}

type Getter interface {
	// Query executes a query that returns rows, typically a SELECT.
	// The arguments are for any placeholder parameters in the query.
	// Placeholders in the SQL are automatically replaced with numbered placeholders.
	Query(ctx context.Context, sql string, arguments ...interface{}) (SqlRows, error)

	// QueryRowContext executes a query that is expected to return at most one row.
	// QueryRowContext always returns a non-nil value. Errors are deferred until
	// Row's Scan method is called.
	// If the query selects no rows, the *Row's Scan will return ErrNoRows.
	// Otherwise, the *Row's Scan scans the first selected row and discards
	// the rest.
	//
	// Placeholders in the SQL are automatically replaced with numbered placeholders.
	QueryRow(ctx context.Context, query string, arguments ...interface{}) SqlRow
}

type Logger interface {
	tracelog.Logger
	LogT(ctx context.Context, level tracelog.LogLevel, msg string, startTime *time.Time, data ...interface{})
	LogQuery(ctx context.Context, query string, args ...interface{})
	LogIfError(ctx context.Context, err error) error
	LogError(ctx context.Context, err error) error
	TraceLogging(on bool)
	SetOutput(out io.Writer) // no-op
}

type NamedArgList []sql.NamedArg

type RowData struct {
	Fields []pgconn.FieldDescription
	Data   map[string]any
}

type Rows struct {
	Rows SqlRows
	// contains filtered or unexported fields
}

type SqlDB interface {
	Execer

	// Transact handles a transaction according to some function. If the function completes
	// without error, the transaction will be committed automatically. If there is an error
	// or a panic, the transaction will be rolled back automatically.
	//
	// The function fn should avoid using the original SqlDB; this is easily achieved by
	// using a named function instead of an anonymous closure.
	Transact(ctx context.Context, txOptions *pgx.TxOptions, fn func(SqlTx) error) error

	// PingContext tests connectivity to the database server.
	Ping(ctx context.Context) error

	// Stats gets statistics from the database server.
	Stats() DBStats

	// SingleConn takes exclusive use of a connection for use by the supplied function.
	// The connection will be automatically released after the function has terminated.
	SingleConn(ctx context.Context, fn func(ex Execer) error) error

	// Close closes the database connection.
	Close() error

	// With returns a modified SqlDB with a user-supplied item.
	With(wrapped interface{}) SqlDB

	// UserItem gets a user-supplied item associated with this DB.
	UserItem() interface{}
}

type SqlRow interface {
	Scan(dest ...interface{}) error
}

type SqlRows interface {
	SqlRow

	// Next prepares the next row for reading. It returns true if there is another
	// row and false if no more rows are available. It automatically closes rows
	// when all rows are read.
	Next() bool

	FieldDescriptions() []pgconn.FieldDescription

	// Values returns an array of the row values
	Values() ([]interface{}, error)

	// Close closes the rows, making the connection ready for use again. It is safe
	// to call Close after rows is already closed.
	Close()

	Err() error
}

type SqlTx interface {
	Execer
	Commit(ctx context.Context) error
	Rollback(ctx context.Context) error
}

type StdLog interface {
	Println(v ...interface{})
}

type Table interface {
	// Name gets the table name. without prefix
	Name() TableName

	// Execer gets the wrapped database or transaction handle.
	Execer() Execer

	// DB gets the wrapped database handle, provided this is not within a transaction.
	// Panics if it is in the wrong state - use IsTx() if necessary.
	DB() SqlDB

	// Tx gets the wrapped transaction handle, provided this is within a transaction.
	// Panics if it is in the wrong state - use IsTx() if necessary.
	Tx() SqlTx

	// IsTx tests whether this is within a transaction.
	IsTx() bool

	// Ctx gets the current request context.
	Ctx() context.Context

	// Dialect gets the database dialect.
	Dialect() driver.Dialect

	// Logger gets the trace logger.
	Logger() Logger
}

type TableCreator interface {
	Table

	// CreateTable creates the database table.
	CreateTable(ifNotExists bool) (int64, error)

	// DropTable drops the database table.
	DropTable(ifExists bool) (int64, error)

	// Truncate empties the table
	Truncate(force bool) (err error)
}

type TableName struct {
	// Prefix on the table name. It can be used as the schema name, in which case
	// it should include the trailing dot. Or it can be any prefix as needed.
	Prefix string

	// The principal name of the table.
	Name string
}

type TableWithIndexes interface {
	TableCreator

	// CreateIndexes creates the indexes for the database table.
	CreateIndexes(ifNotExist bool) (err error)

	// DropIndexes executes a query that drops all the indexes on the database table.
	DropIndexes(ifExist bool) (err error)

	// CreateTableWithIndexes creates the database table and its indexes.
	CreateTableWithIndexes(ifNotExist bool) (err error)
}