common

type Column struct {
	TableName    string
	Name         string
	Type         *Type
	RawType      string
	Length       int
	Null         bool
	PrimaryKey   bool
	AutoIncr     bool
	Default      interface{}
	NeedsQuoting bool

	/* how to select the column */
	Select string
}

type Config struct {
	Hostname string `yaml:"hostname,omitempty"`
	Socket   string `yaml:"socket,omitempty"`
	Port     int    `yaml:"port,omitempty"`
	Username string `yaml:"username,omitempty"`
	Password string `yaml:"password,omitempty"`
	Database string `yaml:"database,omitempty"`
	Compress bool   `yaml:"compress,omitempty"`
}

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

type Executor interface {
	io.Closer

	/* begin a transaction, it's an error to begin a transaction
	 * while another is already in progress */
	Begin(name string) error
	Commit() error

	/* if the statement provokes an error, will automatically rollback,
	 * after which the transaction is no longer in progress */
	Submit(stmt string) error

	/* bulk statements for copying large amounts of data, the underlying
	 * implementation will try to use the most efficient way of achieving this,
	 * for example postgres' COPY FROM semantics. */
	BulkInit(table string, columns ...string) error
	BulkAddRecord(args ...interface{}) error
	BulkFinish() error

	/* submit a transaction in one go */
	Transaction(name string, statements []string) error

	/* submit multiple statements in one go (without a transaction) */
	Multiple(name string, statements []string) []error

	/* submit a single statement */
	Single(name string, statement string) error

	/* for e.g. PostgreSQL COPY support */
	HasCapability(capability int) bool

	/* will return the underlying sql.DB if it exists, otherwise nil */
	GetDb() *sql.DB

	/* will return the underlying sql.Tx if it exists, otherwise nil */
	GetTx() *sql.Tx
}

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

type Queryer interface {
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryRow(query string, args ...interface{}) *sql.Row
}

type ReadCloser interface {
	io.Closer
	Reader
}

type Reader interface {
	Queryer

	TableNames() []string

	/* FilteredTables() is more performant than Tables() if you
	 * only need a few tables */
	Tables() []*Table
	FilteredTables(incl, excl map[string]bool) []*Table

	Read(table *Table) (*sql.Rows, error)
	CreateView(name string, body string) error
	DropView(name string) error

	CreateProjection(name string, body string, engine string, pk []string, uks [][]string) error
	DropProjection(name string) error
}

type Table struct {
	Name    string
	DbType  string /* mysql, postgres, sqlite, ... */
	Columns []*Column
}

type Type struct {
	/* a base type, possible values:
	 * - text,
	 * - char,
	 * - boolean,
	 * - blob
	 * - float
	 * - double
	 * - numeric (floating point type with scale/precision)
	 * - integer */
	Name string

	/* parameters that are optionally added to base types */
	Max       uint
	Min       uint
	Scale     uint
	Precision uint
}

type WriteCloser interface {
	io.Closer
	Writer
}

type Writer interface {

	/* merge the contents of table */
	MergeTable(src *Table, dstName string, r Reader) error
}