datasource

type Aggregations interface {
	DataSource
	Aggregate(expr.SqlStatement) error
}

type ContextSimple struct {
	Data map[string]value.Value
	// contains filtered or unexported fields
}

type ContextUrlValues struct {
	Data url.Values
	// contains filtered or unexported fields
}

type ContextWriterEmpty struct{}

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

type DataSource interface {
	Tables() []string
	Open(connInfo string) (SourceConn, error)
	Close() error
}

type DataSourceFeatures struct {
	Features *Features
	DataSource
}

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

type Deletion interface {
	// Delete using this key
	Delete(driver.Value) (int, error)
	// Delete with given expression
	DeleteExpression(expr.Node) (int, error)
}

type Features struct {
	SourcePlanner  bool
	Scanner        bool
	Seeker         bool
	WhereFilter    bool
	GroupBy        bool
	Sort           bool
	Aggregations   bool
	Projection     bool
	SourceMutation bool
	Upsert         bool
	PatchWhere     bool
	Deletion       bool
}

type Field struct {
	Name               string
	Description        string
	Data               FieldData
	Length             uint32
	Type               value.ValueType
	DefaultValueLength uint64
	DefaultValue       driver.Value
	Indexed            bool
}

type FieldData []byte

type GroupBy interface {
	DataSource
	GroupBy(expr.SqlStatement) error
}

type Iterator interface {
	Next() Message
}

type JsonHelperScannable u.JsonHelper

type JsonWrapper json.RawMessage

type Key interface {
	Key() driver.Value
}

type KeyCol struct {
	Name string
	Val  driver.Value
}

type KeyInt struct {
	Id int
}

type KeyInt64 struct {
	Id int64
}

type Message interface {
	Id() uint64
	Body() interface{}
}

type Mutator interface {
	Upsert
	Deletion
}

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

type NodeConfig struct {
	Name     string       `json:"name"`     // Name of this Node optional
	Source   string       `json:"source"`   // Name of source this node belongs to
	Address  string       `json:"address"`  // host/ip
	Settings u.JsonHelper `json:"settings"` // Arbitrary settings
}

type PatchWhere interface {
	PatchWhere(ctx context.Context, where expr.Node, patch interface{}) (int64, error)
}

type Projection interface {
	// Describe the Columns etc
	Projection() (*expr.Projection, error)
}

type RuntimeSchema struct {
	Sources *DataSources // All registered DataSources

	DisableRecover bool // If disableRecover=true, we will not capture/suppress panics
	// contains filtered or unexported fields
}

type Scanner interface {
	SchemaColumns
	SourceConn
	// create a new iterator for underlying datasource
	CreateIterator(filter expr.Node) Iterator
	MesgChan(filter expr.Node) <-chan Message
}

type Schema struct {
	Name          string                   `json:"name"`
	SourceSchemas map[string]*SourceSchema // map[source_name]:Source Schemas
	// contains filtered or unexported fields
}

type SchemaColumns interface {
	Columns() []string
}

type SchemaConfig struct {
	Name       string   `json:"name"`    // Virtual Schema Name, must be unique
	Sources    []string `json:"sources"` // List of sources , the names of the "Db" in source
	NodeConfig []string `json:"-"`       // List of backend Servers
}

type SchemaProvider interface {
	DataSource
	Table(table string) (*Table, error)
}

type Seeker interface {
	DataSource
	// Just because we have Get, Multi-Get, doesn't mean we can seek all
	// expressions, find out with CanSeek for given expression
	CanSeek(*expr.SqlSelect) bool
	Get(key driver.Value) (Message, error)
	MultiGet(keys []driver.Value) ([]Message, error)
}

type Sort interface {
	DataSource
	Sort(expr.SqlStatement) error
}

type SourceConfig struct {
	Name         string        `json:"name"`           // Name
	SourceType   string        `json:"type"`           // [mysql,elasticsearch,csv,etc] Name in DataSource Registry
	TablesToLoad []string      `json:"tables_to_load"` // if non empty, only load these tables
	Nodes        []*NodeConfig `json:"nodes"`          // List of nodes
	Settings     u.JsonHelper  `json:"settings"`       // Arbitrary settings specific to each source type
}

type SourceConn interface {
	Close() error
}

type SourceMutation interface {
	Create(tbl *Table, stmt expr.SqlStatement) (Mutator, error)
}

type SourcePlanner interface {
	// Accept a sql statement, to plan the execution ideally, this would be done
	// by planner but, we need source specific planners, as each backend has different features
	Accept(expr.SubVisitor) (Scanner, error)
}

type SourceSchema struct {
	Name       string              // Source specific Schema name, generally underlying db name
	Conf       *SourceConfig       // source configuration
	Schema     *Schema             // Schema this is participating in
	Nodes      []*NodeConfig       // List of nodes config
	DSFeatures *DataSourceFeatures // The datasource Interface
	DS         DataSource          // This datasource Interface
	// contains filtered or unexported fields
}

type SourceSelectPlanner interface {
	// Accept a sql statement, to plan the execution ideally, this would be done
	// by planner but, we need source specific planners, as each backend has different features
	//Accept(expr.Visitor) (Scanner, error)
	VisitSelect(stmt *expr.SqlSelect) (interface{}, error)
}

type SqlDriverMessage struct {
	Vals  []driver.Value
	IdVal uint64
}

type SqlDriverMessageMap struct {
	IdVal uint64 // id()
	// contains filtered or unexported fields
}

type StringArray []string

type Table struct {
	Name           string            // Name of table lowercased
	NameOriginal   string            // Name of table
	FieldPositions map[string]int    // Maps name of column to ordinal position in array of []driver.Value's
	Fields         []*Field          // List of Fields, in order
	FieldMap       map[string]*Field // List of Fields, in order
	DescribeValues [][]driver.Value  // The Values that will be output for Describe
	Schema         *Schema           // The schema this is member of
	SourceSchema   *SourceSchema     // The source schema this is member of
	Charset        uint16            // Character set, default = utf8
	// contains filtered or unexported fields
}

type TimeValue time.Time

type Upsert interface {
	Put(ctx context.Context, key Key, value interface{}) (Key, error)
	PutMulti(ctx context.Context, keys []Key, src interface{}) ([]Key, error)
}

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

type ValueContextWrapper struct {
	*SqlDriverMessage
	// contains filtered or unexported fields
}

type WhereFilter interface {
	DataSource
	Filter(expr.SqlStatement) error
}