dbt

type Account struct {
	AccountID  string     `db-column:"account_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	Name       string     `db-column:"name"db-size:"32"db-not-null:"true"db-constraint:"unique"`
	CreateDate *time.Time `db-column:"create_date"db-not-null:"true"`
	Active     bool       `db-column:"active"db-not-null:"true"`
	CreateIP   []byte     `db-column:"create_ip"db-not-null:"true"`
	// contains filtered or unexported fields
}

type CommandTag pgx.CommandTag

type Connection interface {

	// WithTransaction provides a closure where database queries can be executed within a database transaction.
	// Returns the results of the TransactionHandler.
	WithTransaction(transactionHandler TransactionHandler) (interface{}, DbError)

	// Query issues a parameterized query, passing each row of the result set to the RowHandler f.
	// Returns a slice of  all the return values of the row handler. If at any point
	// the row handler returns an error, Query immediately returns
	MapSlice(sql string, args []interface{}, f RowHandler) ([]interface{}, error)

	// Issue a query against the database getting only the fist row returned in the result set. The query can have
	// placeholders (e.g. "$1, $2, $3...) for each value in args. The first row is passed to rowHandler whose return value
	// is the return value of Select
	Select(sql string, args []interface{}, f RowHandler) (interface{}, DbError)

	// Execute executes sql. sql can be either a prepared statement name or an SQL string.
	// arguments should be referenced positionally from the sql string as $1, $2, etc.
	Execute(sql string, args []interface{}) (CommandTag, DbError)

	// ForEach executes parameterized SQL. For each row in the result set rowHandler is called. If rowHandler returns
	// an error, processing the result set stops and ForEach returns the error.
	ForEach(sql string, args []interface{}, rowHandler RowForEachFunc) DbError
}

type Database interface {
	// Issue a query against a PostgreSql database and process only the first row. The query can be parameterized by using
	// placeholders in the form of "$1, $2, $3...etc" which corresponds to the values in args. On the first row of the
	// result set is fetched and passed to rowHandler. Select returns the value and error that rowHandler returns.
	Select(sql string, args []interface{}, f RowHandler) (interface{}, DbError)

	// Issue a query against a PostgreSql database and call rowHandler with each row of the result set. The query can be
	// parameterized via placeholders (e.g. "$1, $2, $3...etc") which corresponds to the respective args values.
	// If rowHandler returns an error, the processing stops and Query returns the error. Otherwise when rowHandler returns
	// no error, Query returns a slice containing all the values rowHandler returned.
	MapSlice(sql string, args []interface{}, f RowHandler) ([]interface{}, DbError)

	// Issue a query against a PostgreSQL database. The query can be parameterized by using placeholders (e.g. $1, $2..etc).
	// StructValue must be an instances with fields tagged with "db" that must correspond to the fields present
	// in the result set. Returns a structure populated with the mapped fields.
	SelectStruct(sql string, args []interface{}, structValue interface{}) (interface{}, error)

	//   sql := "SELECT value from things where id = $1 or id = $2"
	//   ret, err := db.QueryStructSlice(sql, []interface{}{id1, id2}, structValue)
	//
	//   if err != nil {
	//      t.Error(err)
	//   }
	//   structList := ret.([]TestStruct)
	MapStructSlice(sql string, args []interface{}, structType interface{}) (interface{}, error)

	// Exec executes sql. sql can be either a prepared statement name or an SQL string.
	// arguments should be referenced positionally from the sql string as $1, $2, etc.
	Execute(sql string, args []interface{}) (CommandTag, DbError)

	// Fetches a connection object from the connection pool and calls a function with it.
	WithConnection(f func(Connection) (interface{}, error)) (interface{}, error)

	// WithTransaction accepts an handler function, returning any values the handler returns.
	// If transactionHandler returns an error, the transaction is rolled back and the error gets propagated
	// to the caller.
	WithTransaction(transactionHandler TransactionHandler) (interface{}, DbError)

	// ForEach executes parameterized SQL. For each row in the result set rowHandler is called. If rowHandler returns
	// an error, processing the result set stops and ForEach returns the error.
	ForEach(sql string, args []interface{}, rowHandler RowForEachFunc) DbError

	InsertStruct(i ...interface{}) DbError

	UpdateStruct(obj ...interface{}) DbError
}

type DatabaseConfig struct {
	// Host is the hostname of the database
	Host string

	// Port is the port the database is running on.
	Port uint

	// Database is the name of the Postgres database/
	Database string

	// Username is the name of the user used to access the database.
	Username string

	// Password is the password use to access the database.
	Password string

	// PoolSize is the maximum number of connections to use for connecting to the database.
	PoolSize uint
}

type DatabaseEnvironmentConfig map[string]DatabaseConfig

type DbError error

type DbErrorBase struct {
	DbError

	// SQL is the sql statement that caused the error
	SQL string

	// The arguments that were supplied
	Args []interface{}
	// contains filtered or unexported fields
}

type DbStructError struct {
	DbError
	// contains filtered or unexported fields
}

type Email struct {
	EmailID    string     `db-column:"email_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	Address    string     `db-column:"address"db-size:"254"db-not-null:"true"db-constraint:"unique"`
	Type       string     `db-column:"type"db-size:"32"`
	CreateDate *time.Time `db-column:"create_date"db-not-null:"true"`
	// contains filtered or unexported fields
}

type EnvironmentConfiguration interface {
	// GetEnvironment get the environment configuration corresponding to a particular environment name
	// If no such environment exists, return nil.
	GetEnvironment(environment string) DatabaseConfig

	// LookupEnvironment gets the environment configuration corresponding to a particular environment name,
	// returning the environment if it exists and a boolean indication whether the environment
	// configuration was found.
	LookupEnvironment(environment string) (*DatabaseConfig, bool)
}

type EnvironmentDatabaseConfig string

type EnvironmentVariableConfig DatabaseEnvironmentConfig

type Marshaler interface {
	// MarshalDatabase converts a struct to a row in a database
	MarshalDatabase() (map[string]interface{}, error)
}

type NullConstraintError struct {
	DbErrorBase
}

type Password struct {
	PasswordID string     `db-column:"password_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	Password   string     `db-column:"password"db-size:"64"db-not-null:"true"db-constraint:"unique"`
	CreateDate *time.Time `db-column:"create_date"db-not-null:"true"`
	// contains filtered or unexported fields
}

type PostgresConnection struct {
	// Conn is is the postgress connection
	Conn *pgx.Conn
	// contains filtered or unexported fields
}

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

type PostgresTransaction struct {

	// The psx transaction object
	Trans *pgx.Tx
	// contains filtered or unexported fields
}

type RelationAlreadyExistsError struct {
	DbErrorBase
}

type RowForEachFunc func(map[string]interface{}) error

type RowHandler func(map[string]interface{}) (interface{}, error)

type SyntaxError struct {
	DbErrorBase
}

type Transaction interface {
	// Connection returns the database connection that can be used within a database transaction.
	Connection() Connection

	// Database returns the database struct that can be used within a database transaction.
	Database() Database
}

type TransactionHandler func(tx Transaction) (interface{}, error)

type UniqueConstraintError struct {
	DbErrorBase
}

type Unmarshaler interface {

	// UnmarshalDatabase converts a database row to a struct
	UnmarshalDatabase(row map[string]interface{}) error
}

type User struct {
	UserID     string     `db-column:"user_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	EmailID    string     `db-column:"email_id"db-size:"36"db-not-null:"true"`
	Name       string     `db-column:"name"db-size:"32"db-not-null:"true"db-constraint:"unique"`
	Active     bool       `db-column:"active"db-not-null:"true"`
	CreateDate *time.Time `db-column:"create_date"db-not-null:"true"`
	CreateIP   []byte     `db-column:"create_ip"db-not-null:"true"`
	// contains filtered or unexported fields
}

type UserEmail struct {
	UserID   string `db-column:"user_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	EmailID  string `db-column:"email_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	CreateIP []byte `db-column:"create_ip"db-not-null:"true"`
	// contains filtered or unexported fields
}

type UserPassword struct {
	UserID     string     `db-column:"user_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	PasswordID string     `db-column:"password_id"db-size:"36"db-not-null:"true"db-constraint:"primaryKey"`
	CreateDate *time.Time `db-column:"create_date"db-not-null:"true"`
	// contains filtered or unexported fields
}

type ValueTooLongError struct {
	DbErrorBase
}