rel

type Column struct {
	ParentIndex    int       // slice idx position in parent query cols
	Index          int       // slice idx position in original query cols
	SourceIndex    int       // slice idx position in source []driver.Value
	SourceField    string    // field name of underlying field
	SourceOriginal string    // field name of underlying field without the "left.right" parse
	As             string    // As field, auto-populate the Field Name if exists
	Comment        string    // optional in-line comments
	Order          string    // (ASC | DESC)
	Star           bool      // *
	Agg            bool      // aggregate function column?   count(*), avg(x) etc
	Expr           expr.Node // Expression, optional, often Identity.Node
	Guard          expr.Node // column If guard, non-standard sql column guard
	// contains filtered or unexported fields
}

type ColumnPb struct {
	SourceQuote      []byte       `protobuf:"bytes,1,opt,name=sourceQuote" json:"sourceQuote,omitempty"`
	AsQuoteByte      []byte       `protobuf:"bytes,2,opt,name=asQuoteByte" json:"asQuoteByte,omitempty"`
	OriginalAs       *string      `protobuf:"bytes,3,opt,name=originalAs" json:"originalAs,omitempty"`
	Left             *string      `protobuf:"bytes,4,opt,name=left" json:"left,omitempty"`
	Right            *string      `protobuf:"bytes,5,opt,name=right" json:"right,omitempty"`
	ParentIndex      int32        `protobuf:"varint,6,opt,name=parentIndex" json:"parentIndex"`
	Index            int32        `protobuf:"varint,7,opt,name=index" json:"index"`
	SourceIndex      int32        `protobuf:"varint,8,opt,name=sourceIndex" json:"sourceIndex"`
	SourceField      *string      `protobuf:"bytes,9,opt,name=sourceField" json:"sourceField,omitempty"`
	As               string       `protobuf:"bytes,11,opt,name=as" json:"as"`
	Comment          *string      `protobuf:"bytes,12,opt,name=comment" json:"comment,omitempty"`
	Order            *string      `protobuf:"bytes,13,opt,name=order" json:"order,omitempty"`
	Star             *bool        `protobuf:"varint,14,opt,name=star" json:"star,omitempty"`
	Agg              bool         `protobuf:"varint,15,opt,name=agg" json:"agg"`
	Expr             *expr.NodePb `protobuf:"bytes,16,opt,name=Expr,json=expr" json:"Expr,omitempty"`
	Guard            *expr.NodePb `protobuf:"bytes,17,opt,name=Guard,json=guard" json:"Guard,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

type Columns []*Column

type ColumnsStatement interface {
	AddColumn(col Column) error
}

type CommandColumn struct {
	Expr expr.Node // column expression
	Name string    // Original path/name for command field
}

type CommandColumnPb struct {
	Expr             *expr.NodePb `protobuf:"bytes,1,opt,name=Expr,json=expr" json:"Expr,omitempty"`
	Name             string       `protobuf:"bytes,2,req,name=name" json:"name"`
	XXX_unrecognized []byte       `json:"-"`
}

type CommandColumns []*CommandColumn

type DdlColumn struct {
	Kw            lex.TokenType // initial keyword (identity for normal, constraint, primary)
	Null          bool          // Do we support NULL?
	AutoIncrement bool          // auto increment
	IndexType     string        // index_type
	IndexCols     []string      // index_col_name
	RefTable      string        // refererence table
	RefCols       []string      // ref cols
	Default       expr.Node     // Default value
	DataType      string        // data type
	DataTypeSize  int           // Data Type Size:    varchar(2000)
	DataTypeArgs  []expr.Node   // data type args
	Key           lex.TokenType // UNIQUE | PRIMARY
	Name          string        // name
	Comment       string        // optional in-line comments
	Expr          expr.Node     // Expression, optional, often Identity.Node but could be composite key
}

type Filter interface {
	String() string
}

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

type FilterSelect struct {
	*FilterStatement
	Columns Columns
}

type FilterStatement struct {
	Description string       // initial pre-start comments
	Raw         string       // full original raw statement
	Filter      expr.Node    // FILTER <filter_expr>
	Where       expr.Node    // WHERE <expr> [AND <expr>] syntax
	OrderBy     Columns      // order by
	From        string       // From is optional
	Limit       int          // Limit
	Alias       string       // Non-Standard sql, alias/name of sql another way of expression Prepared Statement
	With        u.JsonHelper // Non-Standard SQL for properties/config info, similar to Cassandra with, purse json
	// contains filtered or unexported fields
}

type KvInt struct {
	K                string `protobuf:"bytes,1,req,name=k" json:"k"`
	V                int32  `protobuf:"varint,2,req,name=v" json:"v"`
	XXX_unrecognized []byte `json:"-"`
}

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

type PreparedStatement struct {
	Alias     string
	Statement SqlStatement
}

type Projection struct {
	Distinct bool
	Final    bool // Is this a Final Projection? or intermiediate?

	Columns ResultColumns
	// contains filtered or unexported fields
}

type ProjectionPb struct {
	Distinct         bool              `protobuf:"varint,1,req,name=distinct" json:"distinct"`
	Final            bool              `protobuf:"varint,2,req,name=final" json:"final"`
	ColNames         []string          `protobuf:"bytes,3,rep,name=colNames" json:"colNames,omitempty"`
	Columns          []*ResultColumnPb `protobuf:"bytes,4,rep,name=columns" json:"columns,omitempty"`
	XXX_unrecognized []byte            `json:"-"`
}

type ResultColumn struct {
	Final  bool            // Is this part of final projection (ie, response)
	Name   string          // Original path/name for query field
	ColPos int             // Ordinal position in sql (or partial sql) statement
	Col    *Column         // the original sql column
	Star   bool            // Was this a select * ??
	As     string          // aliased
	Type   value.ValueType // Data Type
}

type ResultColumnPb struct {
	Final            *bool     `protobuf:"varint,1,opt,name=final" json:"final,omitempty"`
	Name             string    `protobuf:"bytes,2,req,name=name" json:"name"`
	ColPos           int32     `protobuf:"varint,3,req,name=colPos" json:"colPos"`
	Column           *ColumnPb `protobuf:"bytes,4,opt,name=column" json:"column,omitempty"`
	Star             *bool     `protobuf:"varint,5,opt,name=star" json:"star,omitempty"`
	As               string    `protobuf:"bytes,6,req,name=as" json:"as"`
	ValueType        int32     `protobuf:"varint,7,req,name=valueType" json:"valueType"`
	XXX_unrecognized []byte    `json:"-"`
}

type ResultColumns []*ResultColumn

type SqlAlter struct {
	Raw      string       // full original raw statement
	Identity string       // identity to alter
	Tok      lex.Token    // ALTER [TABLE,VIEW,CONTINUOUSVIEW,TRIGGER] etc
	Cols     []*DdlColumn // columns
}

type SqlCommand struct {
	Columns  CommandColumns // can have multiple columns in command
	Identity string         //
	Value    expr.Node      //
	// contains filtered or unexported fields
}

type SqlCreate struct {
	Raw         string       // full original raw statement
	Identity    string       // identity of table, view, etc
	Tok         lex.Token    // CREATE [TABLE,VIEW,CONTINUOUSVIEW,TRIGGER] etc
	OrReplace   bool         // OR REPLACE
	IfNotExists bool         // IF NOT EXISTS
	Cols        []*DdlColumn // columns
	Engine      map[string]interface{}
	With        u.JsonHelper
	Select      *SqlSelect
}

type SqlDelete struct {
	Table string
	Where *SqlWhere
	Limit int
}

type SqlDescribe struct {
	Raw      string    // full original raw statement
	Identity string    // Describe
	Tok      lex.Token // Explain, Describe, Desc
	Stmt     SqlStatement
}

type SqlDrop struct {
	Raw      string    // full original raw statement
	Identity string    // identity of table, view, etc
	Temp     bool      // Temp?
	Tok      lex.Token // DROP [TEMP] [TABLE,VIEW,CONTINUOUSVIEW,TRIGGER] etc
	With     u.JsonHelper
}

type SqlInsert struct {
	Table   string           // table name
	Columns Columns          // Column Names
	Rows    [][]*ValueColumn // Values to insert
	Select  *SqlSelect       //
	// contains filtered or unexported fields
}

type SqlInto struct {
	Table string
}

type SqlSelect struct {
	Db       string       // If provided a use "dbname"
	Raw      string       // full original raw statement
	Star     bool         // for select * from ...
	Distinct bool         // Distinct flag?
	Columns  Columns      // An array (ordered) list of columns
	From     []*SqlSource // From, Join
	Into     *SqlInto     // Into "table"
	Where    *SqlWhere    // Expr Node, or *SqlSelect
	Having   expr.Node    // Filter results
	GroupBy  Columns
	OrderBy  Columns
	Limit    int
	Offset   int
	Alias    string       // Non-Standard sql, alias/name of sql another way of expression Prepared Statement
	With     u.JsonHelper // Non-Standard SQL for properties/config info, similar to Cassandra with, purse json
	// contains filtered or unexported fields
}

type SqlSelectPb struct {
	Db               string         `protobuf:"bytes,1,req,name=db" json:"db"`
	Raw              string         `protobuf:"bytes,2,req,name=raw" json:"raw"`
	Star             bool           `protobuf:"varint,3,req,name=star" json:"star"`
	Distinct         bool           `protobuf:"varint,4,req,name=distinct" json:"distinct"`
	Columns          []*ColumnPb    `protobuf:"bytes,5,rep,name=columns" json:"columns,omitempty"`
	From             []*SqlSourcePb `protobuf:"bytes,6,rep,name=from" json:"from,omitempty"`
	Into             *string        `protobuf:"bytes,7,opt,name=into" json:"into,omitempty"`
	Where            *SqlWherePb    `protobuf:"bytes,8,opt,name=where" json:"where,omitempty"`
	Having           *expr.NodePb   `protobuf:"bytes,9,opt,name=having" json:"having,omitempty"`
	GroupBy          []*ColumnPb    `protobuf:"bytes,11,rep,name=groupBy" json:"groupBy,omitempty"`
	OrderBy          []*ColumnPb    `protobuf:"bytes,10,rep,name=orderBy" json:"orderBy,omitempty"`
	Limit            int32          `protobuf:"varint,12,opt,name=limit" json:"limit"`
	Offset           int32          `protobuf:"varint,13,opt,name=offset" json:"offset"`
	Alias            *string        `protobuf:"bytes,14,opt,name=alias" json:"alias,omitempty"`
	Projection       *ProjectionPb  `protobuf:"bytes,15,opt,name=projection" json:"projection,omitempty"`
	IsAgg            bool           `protobuf:"varint,16,req,name=isAgg" json:"isAgg"`
	Finalized        bool           `protobuf:"varint,17,req,name=finalized" json:"finalized"`
	Schemaqry        bool           `protobuf:"varint,18,req,name=schemaqry" json:"schemaqry"`
	With             []byte         `protobuf:"bytes,19,opt,name=with" json:"with,omitempty"`
	XXX_unrecognized []byte         `json:"-"`
}

type SqlShow struct {
	Raw        string // full raw statement
	Db         string // Database/Schema name
	Full       bool   // SHOW FULL TABLE FROM
	Scope      string // {FULL, GLOBAL, SESSION}
	ShowType   string // object type, [tables, columns, etc]
	From       string // `table`   or `schema`.`table`
	Identity   string // `table`   or `schema`.`table`
	Create     bool
	CreateWhat string
	Where      expr.Node
	Like       expr.Node
}

type SqlSource struct {
	Source      *SqlSelect    // Sql Select Source query, written by Rewrite
	Raw         string        // Raw Partial Query
	Name        string        // From Name (optional, empty if join, subselect)
	Alias       string        // From name aliased
	Schema      string        //  FROM `schema`.`table`
	Op          lex.TokenType // In, =, ON
	LeftOrRight lex.TokenType // Left, Right
	JoinType    lex.TokenType // INNER, OUTER
	JoinExpr    expr.Node     // Join expression       x.y = q.y
	SubQuery    *SqlSelect    // optional, Join/SubSelect statement

	// Plan Hints, move to a dedicated planner
	Seekable bool
	// contains filtered or unexported fields
}

type SqlSourcePb struct {
	Final            bool           `protobuf:"varint,1,opt,name=final" json:"final"`
	AliasInner       *string        `protobuf:"bytes,2,opt,name=aliasInner" json:"aliasInner,omitempty"`
	Columns          []*ColumnPb    `protobuf:"bytes,3,rep,name=columns" json:"columns,omitempty"`
	ColIndex         []KvInt        `protobuf:"bytes,4,rep,name=colIndex" json:"colIndex"`
	JoinNodes        []*expr.NodePb `protobuf:"bytes,5,rep,name=joinNodes" json:"joinNodes,omitempty"`
	Source           *SqlSelectPb   `protobuf:"bytes,6,opt,name=source" json:"source,omitempty"`
	Raw              string         `protobuf:"bytes,7,opt,name=raw" json:"raw"`
	Name             string         `protobuf:"bytes,8,opt,name=name" json:"name"`
	Alias            string         `protobuf:"bytes,9,opt,name=alias" json:"alias"`
	Op               int32          `protobuf:"varint,10,req,name=op" json:"op"`
	LeftOrRight      int32          `protobuf:"varint,11,req,name=leftOrRight" json:"leftOrRight"`
	JoinType         int32          `protobuf:"varint,12,req,name=joinType" json:"joinType"`
	JoinExpr         *expr.NodePb   `protobuf:"bytes,13,opt,name=joinExpr" json:"joinExpr,omitempty"`
	SubQuery         *SqlSelectPb   `protobuf:"bytes,14,opt,name=subQuery" json:"subQuery,omitempty"`
	Seekable         bool           `protobuf:"varint,15,opt,name=seekable" json:"seekable"`
	XXX_unrecognized []byte         `json:"-"`
}

type SqlSourceStatement interface {
	// string representation of Node, AST parseable back to itself
	String() string
	// Write out this statement in a specific dialect
	WriteDialect(w expr.DialectWriter)
	// SQL Keyword for this statement
	Keyword() lex.TokenType
}

type SqlStatement interface {
	// string representation of Node, AST parseable back to itself
	String() string
	// Write out this statement in a specific dialect
	WriteDialect(w expr.DialectWriter)
	// SQL keyword (select, insert, etc)
	Keyword() lex.TokenType
}

type SqlStatementPb struct {
	Select           *SqlSelectPb  `protobuf:"bytes,1,opt,name=select" json:"select,omitempty"`
	Source           *SqlSourcePb  `protobuf:"bytes,2,opt,name=source" json:"source,omitempty"`
	Projection       *ProjectionPb `protobuf:"bytes,4,opt,name=projection" json:"projection,omitempty"`
	XXX_unrecognized []byte        `json:"-"`
}

type SqlTokenPager struct {
	*expr.LexTokenPager
	// contains filtered or unexported fields
}

type SqlUpdate struct {
	Values map[string]*ValueColumn
	Where  *SqlWhere
	Table  string
}

type SqlUpsert struct {
	Columns Columns
	Rows    [][]*ValueColumn
	Values  map[string]*ValueColumn
	Where   *SqlWhere
	Table   string
}

type SqlWhere struct {
	// Either Op + Source exists
	Op     lex.TokenType // (In|=|ON)  for Select Clauses operators
	Source *SqlSelect    // IN (SELECT a,b,c from z)

	// OR expr but not both
	Expr expr.Node // x = y AND q > 5
}

type SqlWherePb struct {
	Op               int32        `protobuf:"varint,1,req,name=op" json:"op"`
	Source           *SqlSelectPb `protobuf:"bytes,2,opt,name=source" json:"source,omitempty"`
	Expr             *expr.NodePb `protobuf:"bytes,3,opt,name=Expr,json=expr" json:"Expr,omitempty"`
	XXX_unrecognized []byte       `json:"-"`
}

type Sqlbridge struct {
	*SqlTokenPager
	// contains filtered or unexported fields
}

type ValueColumn struct {
	Value value.Value
	Expr  expr.Node
}