sql

package

Go to main page

Versions in this module

v0

v0.18.1

Apr 9, 2024

Changes in this version

+ const ANSI

+ const ANSIQuotes

+ const LastInsertUuid

+ const NoAutoValueOnZero

+ const NoEngineSubstitution

+ const OnlyFullGroupBy

+ const StrictTransTables

+ var ErrDuplicateKey = errors.NewKind("Duplicate key name '%s'")

+ var ErrUnknownStatusVariable = errors.NewKind(`Unknown status variable '%s'`)

+ func IncrementStatusVariable(ctx *Context, name string, val int)

type BaseSession

+ func BaseSessionFromConnection(ctx context.Context, c *mysql.Conn, addr string) (*BaseSession, error)

+ func (s *BaseSession) GetAllStatusVariables(_ *Context) map[string]StatusVarValue

+ func (s *BaseSession) GetLastQueryInfoInt(key string) int64

+ func (s *BaseSession) GetLastQueryInfoString(key string) string

+ func (s *BaseSession) GetStatusVariable(_ *Context, statVarName string) (interface{}, error)

+ func (s *BaseSession) IncrementStatusVariable(_ *Context, statVarName string, val int) error

+ func (s *BaseSession) SetLastQueryInfoInt(key string, value int64)

+ func (s *BaseSession) SetLastQueryInfoString(key string, value string)

+ func (s *BaseSession) SetStatusVariable(_ *Context, statVarName string, val interface{}) error

+ type ForeignKeyConstraints []*ForeignKeyConstraint

+ type ForeignKeyTables []ForeignKeyTable

type IndexDef

+ func (i *IndexDef) ColumnNames() []string

+ func (i *IndexDef) IsFullText() bool

+ func (i *IndexDef) IsPrimary() bool

+ func (i *IndexDef) IsSpatial() bool

+ func (i *IndexDef) IsUnique() bool

+ func (i *IndexDef) String() string

+ type IndexDefs []*IndexDef

+ type MySQLStatusVariable struct

+ Default interface{}

+ Name string

+ Scope StatusVariableScope

+ Type Type

+ func (m *MySQLStatusVariable) GetDefault() interface{}

+ func (m *MySQLStatusVariable) GetName() string

+ func (m *MySQLStatusVariable) GetScope() StatusVariableScope

+ func (m *MySQLStatusVariable) GetType() Type

+ type MysqlConnectionUser struct

+ Host string

+ User string

+ func (m MysqlConnectionUser) Get() *query.VTGateCallerID

+ type MysqlSVScopeType byte

+ func (s MysqlSVScopeType) String() string

+ type MysqlScope struct

+ Type MysqlSVScopeType

+ func GetMysqlScope(t MysqlSVScopeType) *MysqlScope

+ func (m *MysqlScope) GetValue(ctx *Context, name string, collation CollationID) (any, error)

+ func (m *MysqlScope) IsGlobalOnly() bool

+ func (m *MysqlScope) IsSessionOnly() bool

+ func (m *MysqlScope) SetValue(ctx *Context, name string, val any) error

+ type MysqlSystemVariable struct

+ Default interface{}

+ Dynamic bool

+ Name string

+ NotifyChanged func(SystemVariableScope, SystemVarValue) error

+ Scope *MysqlScope

+ SetVarHintApplies bool

+ Type Type

+ ValueFunction func() (interface{}, error)

+ func (m *MysqlSystemVariable) DisplayString(specifiedScope string) string

+ func (m *MysqlSystemVariable) GetDefault() any

+ func (m *MysqlSystemVariable) GetName() string

+ func (m *MysqlSystemVariable) GetSessionScope() SystemVariableScope

+ func (m *MysqlSystemVariable) GetType() Type

+ func (m *MysqlSystemVariable) InitValue(val any, global bool) (SystemVarValue, error)

+ func (m *MysqlSystemVariable) IsGlobalOnly() bool

+ func (m *MysqlSystemVariable) IsReadOnly() bool

+ func (m *MysqlSystemVariable) SetDefault(a any)

+ func (m *MysqlSystemVariable) SetValue(val any, global bool) (SystemVarValue, error)

type Session

+ GetAllStatusVariables func(ctx *Context) map[string]StatusVarValue

+ GetLastQueryInfoInt func(key string) int64

+ GetLastQueryInfoString func(key string) string

+ GetStatusVariable func(ctx *Context, statVarName string) (interface{}, error)

+ IncrementStatusVariable func(ctx *Context, statVarName string, val int) error

+ SetLastQueryInfoInt func(key string, value int64)

+ SetLastQueryInfoString func(key string, value string)

+ SetStatusVariable func(ctx *Context, statVarName string, val interface{}) error

+ type StatusVarValue struct

+ Val interface{}

+ Var StatusVariable

+ type StatusVariable interface

+ GetDefault func() interface{}

+ GetName func() string

+ GetScope func() StatusVariableScope

+ GetType func() Type

+ type StatusVariableRegistry interface

+ GetGlobal func(name string) (StatusVariable, interface{}, bool)

+ IncrementGlobal func(name string, val int) error

+ NewGlobalMap func() map[string]StatusVarValue

+ NewSessionMap func() map[string]StatusVarValue

+ SetGlobal func(name string, val interface{}) error

+ var StatusVariables StatusVariableRegistry

+ type StatusVariableScope byte

+ const StatusVariableScope_Both

+ const StatusVariableScope_Global

+ const StatusVariableScope_Session

type SystemVariable

+ DisplayString func(string) string

+ GetDefault func() any

+ GetName func() string

+ GetSessionScope func() SystemVariableScope

+ GetType func() Type

+ InitValue func(val any, global bool) (SystemVarValue, error)

+ IsGlobalOnly func() bool

+ IsReadOnly func() bool

+ SetDefault func(any)

+ SetValue func(val any, global bool) (SystemVarValue, error)

type SystemVariableScope

+ GetValue func(*Context, string, CollationID) (any, error)

+ IsGlobalOnly func() bool

+ IsSessionOnly func() bool

+ SetValue func(*Context, string, any) error

v0.18.0

Feb 28, 2024

Changes in this version

+ const EventDateSpaceTimeFormat

+ const IndexClassDefault

+ const IndexClassFulltext

+ const IndexClassSpatial

+ const MaxIdentifierLength

+ var ErrCollationNotSupportedOnUniqueTextIndex = errors.NewKind(...)

+ var ErrColumnSpecifiedTwice = errors.NewKind("column '%v' specified twice")

+ var ErrExpectedTableFoundView = errors.NewKind("expected a table and found view: '%s' ")

+ var ErrFileExists = errors.NewKind("File '%s' already exists")

+ var ErrGeneratedColumnWithDefault = errors.NewKind("Incorrect usage of DEFAULT and generated column")

+ var ErrIncorrectValue = errors.NewKind("Incorrect %s value: '%s'")

+ var ErrInvalidIdentifier = errors.NewKind("invalid identifier: `%s`")

+ var ErrInvalidOnUpdate = errors.NewKind("Invalid ON UPDATE clause for '%s' column")

+ var ErrInvalidRefInView = errors.NewKind(...)

+ var ErrInvalidTypeForLimit = errors.NewKind("invalid limit. expected %T, found %T")

+ var ErrRecursiveCTEMissingUnion = errors.NewKind("Recursive Common Table Expression '%s' should contain a UNION")

+ var ErrRecursiveCTENotUnion = errors.NewKind("Recursive table reference in EXCEPT or INTERSECT operand is not allowed")

+ var ErrSecureFilePriv = errors.NewKind(...)

+ var ErrUnexpectedSeparator = errors.NewKind("Field separator argument is not what is expected; check the manual")

+ var ErrUserAlterFailure = errors.NewKind("Operation ALTER USER failed for %s")

+ var ErrVirtualColumnPrimaryKey = errors.NewKind("Defining a virtual generated column as primary key is not supported")

+ func Describe(n fmt.Stringer, options DescribeOptions) string

+ func GetTimeValueFromStringInput(field, t string) (time.Time, error)

+ func ValidatePrimaryKeyDrop(ctx *Context, t IndexAddressableTable, oldSchema PrimaryKeySchema) error

+ type CheckConstraintNode interface

+ Checks func() CheckConstraints

+ WithChecks func(CheckConstraints) Node

type ColSet

+ func NewColSetFromIntSet(set FastIntSet) ColSet

type Collation

+ IsAccentSensitive bool

+ IsCaseSensitive bool

type Column

+ OnUpdate *ColumnDefaultValue

+ type CommentedTable interface

+ Comment func() string

+ type CountingRowIter struct

+ Stats *DescribeStats

+ func NewCountingRowIter(iter RowIter, describable WithDescribeStats) CountingRowIter

+ func (c CountingRowIter) Next(ctx *Context) (Row, error)

+ type Describable interface

+ Describe func(options DescribeOptions) string

+ type DescribeOptions struct

+ Analyze bool

+ Debug bool

+ Estimates bool

+ func (d DescribeOptions) String() string

+ type DescribeStats struct

+ ActualRowCount uint64

+ Cost float64

+ EstimatedRowCount uint64

+ HasStats bool

+ NumberOfIterations uint64

+ func (e *DescribeStats) GetDescribeStatsString(options DescribeOptions) string

+ func (e *DescribeStats) SetDescribeStats(newStats DescribeStats)

+ func (e DescribeStats) GetEstimatedCost() float64

+ func (e DescribeStats) GetEstimatedRowCount() uint64

type EventDatabase

+ NeedsToReloadEvents func(ctx *Context, token interface{}) (bool, error)

+ UpdateLastExecuted func(ctx *Context, eventName string, lastExecuted time.Time) error

type EventDefinition

+ Comment string

+ Definer string

+ Ends time.Time

+ EventBody string

+ ExecuteAt time.Time

+ ExecuteEvery string

+ HasEnds bool

+ HasExecuteAt bool

+ LastExecuted time.Time

+ OnCompletionPreserve bool

+ Starts time.Time

+ Status string

+ TimezoneOffset string

+ func (e *EventDefinition) ConvertTimesFromUTCToTz(tz string) *EventDefinition

+ func (e *EventDefinition) CreateEventStatement() string

+ func (e *EventDefinition) GetNextExecutionTime(curTime time.Time) (time.Time, bool, error)

+ type EventOnScheduleEveryInterval struct

+ Days int64

+ Hours int64

+ Minutes int64

+ Months int64

+ Seconds int64

+ Years int64

+ func EventOnScheduleEveryIntervalFromString(every string) (*EventOnScheduleEveryInterval, error)

+ func NewEveryInterval(y, mo, d, h, mi, s int64) *EventOnScheduleEveryInterval

+ func (e *EventOnScheduleEveryInterval) GetIntervalValAndField() (string, string)

+ type EventScheduler interface

+ AddEvent func(ctx *Context, edb EventDatabase, event EventDefinition)

+ RemoveEvent func(dbName, eventName string)

+ RemoveSchemaEvents func(dbName string)

+ UpdateEvent func(ctx *Context, edb EventDatabase, orgEventName string, event EventDefinition)

+ type EventSchedulerStatement interface

+ WithEventScheduler func(controller EventScheduler) Node

+ type EventStatus byte

+ const EventStatus_Disable

+ const EventStatus_DisableOnSlave

+ const EventStatus_Enable

+ func EventStatusFromString(status string) (EventStatus, error)

+ func (e EventStatus) String() string

type ExternalStoredProcedureDetails

+ AdminOnly bool

+ ReadOnly bool

type FuncDepSet

+ func (f *FuncDepSet) Empty() bool

type Histogram

+ func (h Histogram) DebugString() string

+ func (h Histogram) IsEmpty() bool

+ func (h Histogram) ToInterface() interface{}

type HistogramBucket

+ BoundCount func() uint64

+ DistinctCount func() uint64

+ McvCounts func() []uint64

+ Mcvs func() []Row

+ NullCount func() uint64

+ RowCount func() uint64

+ type IdExpression interface

+ Id func() ColumnId

+ WithId func(ColumnId) IdExpression

type IndexAddressable

+ PreciseMatch func() bool

+ type IndexBuildingTable interface

+ BuildIndex func(ctx *Context, indexDef IndexDef) (RowInserter, error)

+ ShouldBuildIndex func(ctx *Context, indexDef IndexDef) (bool, error)

+ type IndexClass uint8

type IndexLookup

+ func NewIndexLookup(idx Index, ranges RangeCollection, ...) IndexLookup

+ type IndexRequired interface

+ RequiredPredicates func() []string

+ type IndexSearchable interface

+ LookupForExpressions func(*Context, []Expression) (IndexLookup, error)

+ SkipIndexCosting func() bool

+ type IndexSearchableTable interface

+ type JSONWrapper interface

+ ToInterface func() interface{}

type MapCatalog

+ func (t MapCatalog) DataLength(ctx *Context, db, table string) (uint64, error)

+ func (t MapCatalog) DropDbStats(ctx *Context, db string, flush bool) error

+ func (t MapCatalog) DropStats(ctx *Context, qual StatQualifier, cols []string) error

+ func (t MapCatalog) GetStats(ctx *Context, qual StatQualifier, cols []string) (Statistic, bool)

+ func (t MapCatalog) GetTableStats(ctx *Context, db, table string) ([]Statistic, error)

+ func (t MapCatalog) RefreshTableStats(ctx *Context, table Table, db string) error

+ func (t MapCatalog) RowCount(ctx *Context, db, table string) (uint64, error)

+ func (t MapCatalog) SetStats(ctx *Context, stats Statistic) error

+ func (t MapCatalog) WithTableFunctions(fns ...TableFunction) (TableFunctionProvider, error)

+ type MutableStatistic interface

+ WithAvgSize func(uint64) Statistic

+ WithColSet func(ColSet) Statistic

+ WithDistinctCount func(uint64) Statistic

+ WithFuncDeps func(*FuncDepSet) Statistic

+ WithHistogram func(Histogram) (Statistic, error)

+ WithLowerBound func(Row) Statistic

+ WithNullCount func(uint64) Statistic

+ WithRowCount func(uint64) Statistic

+ type MutableTableNode interface

+ ReplaceTable func(table Table) (MutableTableNode, error)

+ WithTable func(Table) (MutableTableNode, error)

+ WrappedTable func() Table

+ type MutableTableWrapper interface

+ WithUnderlying func(Table) Table

type Node

+ IsReadOnly func() bool

type NumberType

+ DisplayWidth func() int

+ type PrivilegeCheckSubject struct

+ Column string

+ Database string

+ IsProcedure bool

+ Routine string

+ Table string

type PrivilegeSetDatabase

+ GetRoutines func() []PrivilegeSetRoutine

+ Routine func(routineName string, isProcedure bool) PrivilegeSetRoutine

+ type PrivilegeSetRoutine interface

+ Count func() int

+ Equals func(otherPs PrivilegeSetRoutine) bool

+ Has func(privileges ...PrivilegeType) bool

+ HasPrivileges func() bool

+ RoutineName func() string

+ RoutineType func() string

+ ToSlice func() []PrivilegeType

type PrivilegedOperation

+ IsProcedure bool

+ Routine string

type PrivilegedOperationChecker

+ RoutineAdminCheck func(ctx *Context, operations ...PrivilegedOperation) bool

+ type ReferenceChecker interface

+ SetReferenceCheck func() error

type Schema

+ func (s Schema) HasVirtualColumns() bool

+ func (s Schema) PhysicalSchema() Schema

+ type SchemaValidator interface

+ ValidateSchema func(Schema) error

+ type StatQualifier struct

+ Database string

+ Idx string

+ Tab string

+ func NewQualifierFromString(q string) (StatQualifier, error)

+ func NewStatQualifier(db, table, index string) StatQualifier

+ func (q StatQualifier) Db() string

+ func (q StatQualifier) Empty() bool

+ func (q StatQualifier) Index() string

+ func (q StatQualifier) String() string

+ func (q StatQualifier) Table() string

+ type Statistic interface

+ AvgSize func() uint64

+ ColSet func() ColSet

+ Columns func() []string

+ CreatedAt func() time.Time

+ DistinctCount func() uint64

+ FuncDeps func() *FuncDepSet

+ Histogram func() Histogram

+ IndexClass func() IndexClass

+ LowerBound func() Row

+ NullCount func() uint64

+ Qualifier func() StatQualifier

+ RowCount func() uint64

+ Types func() []Type

+ type StatsProvider interface

+ DataLength func(ctx *Context, db, table string) (uint64, error)

+ DropDbStats func(ctx *Context, db string, flush bool) error

+ DropStats func(ctx *Context, qual StatQualifier, cols []string) error

+ GetStats func(ctx *Context, qual StatQualifier, cols []string) (Statistic, bool)

+ GetTableStats func(ctx *Context, db, table string) ([]Statistic, error)

+ RefreshTableStats func(ctx *Context, table Table, db string) error

+ RowCount func(ctx *Context, db, table string) (uint64, error)

+ SetStats func(ctx *Context, stats Statistic) error

type TableFunctionProvider

+ WithTableFunctions func(fns ...TableFunction) (TableFunctionProvider, error)

+ type TableId uint16

+ func (i TableId) IsEmpty() bool

+ type WithDescribeStats interface

+ GetDescribeStatsString func(options DescribeOptions) string

+ SetDescribeStats func(stats DescribeStats)

v0.17.0

Aug 23, 2023

Changes in this version

+ const SqlModeSessionVar

+ var ErrAggregationUnsupported = errors.NewKind(...)

+ var ErrDuplicateColumn = errors.NewKind("duplicate column name: `%s`")

+ var ErrFullTextDatabaseNotSupported = errors.NewKind("database does not support FULLTEXT indexes")

+ var ErrFullTextDifferentCollations = errors.NewKind("Full-Text index columns must have the same collation")

+ var ErrFullTextDuplicateColumn = errors.NewKind("cannot have duplicate columns in a Full-Text index: `%s`")

+ var ErrFullTextInvalidColumnType = errors.NewKind("all Full-Text columns must be declared on a non-binary text type")

+ var ErrFullTextMatchAgainstNotColumns = errors.NewKind("match columns must be column names")

+ var ErrFullTextMatchAgainstSameTable = errors.NewKind("match columns must refer to the same table")

+ var ErrFullTextMissingColumn = errors.NewKind("Full-Text index could not find the column `%s`")

+ var ErrFullTextNotSupported = errors.NewKind("table does not support FULLTEXT indexes")

+ var ErrGeneratedColumnValue = errors.NewKind("The value specified for generated column %q in table %q is not allowed.")

+ var ErrIncompleteFullTextIntegration = errors.NewKind("proper Full-Text support requires all interfaces to be implemented")

+ var ErrInsertIntoMismatchValueCount = errors.NewKind("number of values does not match number of columns provided")

+ var ErrInvalidIndexName = errors.NewKind("invalid index name '%s'")

+ var ErrNoFullTextIndexFound = errors.NewKind("no matching Full-Text index found on table `%s`")

+ var ErrStarUnsupported = errors.NewKind("a '*' is in a context where it is not allowed.")

+ var ErrUnknownUserVariable = errors.NewKind(`Unknown user variable '%s'`)

+ var ErrWindowUnsupported = errors.NewKind("a window function '%s' is in a context where it cannot be evaluated.")

+ type CatalogTableFunction interface

+ WithCatalog func(c Catalog) (TableFunction, error)

type Column

+ Generated *ColumnDefaultValue

+ Virtual bool

type ColumnDefaultValue

+ Expr Expression

type DatetimeType

+ Precision func() int

+ type DynamicColumnsTable interface

+ AllColumns func(*Context) (Schema, error)

+ HasDynamicColumns func() bool

+ WithDefaultsSchema func(Schema) (Table, error)

type EventDefinition

+ SqlMode string

type Index

+ IsFullText func() bool

+ type MapCatalog struct

+ Databases map[string]Database

+ Funcs map[string]Function

+ Tables map[string]Table

+ func (t MapCatalog) AllDatabases(ctx *Context) []Database

+ func (t MapCatalog) CreateDatabase(ctx *Context, dbName string, collation CollationID) error

+ func (t MapCatalog) Database(ctx *Context, name string) (Database, error)

+ func (t MapCatalog) DatabaseTable(ctx *Context, db Database, tableName string) (Table, Database, error)

+ func (t MapCatalog) DatabaseTableAsOf(ctx *Context, db Database, tableName string, asOf interface{}) (Table, Database, error)

+ func (t MapCatalog) ExternalStoredProcedure(ctx *Context, name string, numOfParams int) (*ExternalStoredProcedureDetails, error)

+ func (t MapCatalog) ExternalStoredProcedures(ctx *Context, name string) ([]ExternalStoredProcedureDetails, error)

+ func (t MapCatalog) Function(ctx *Context, name string) (Function, error)

+ func (t MapCatalog) HasDatabase(ctx *Context, name string) bool

+ func (t MapCatalog) LockTable(ctx *Context, table string)

+ func (t MapCatalog) RegisterFunction(ctx *Context, fns ...Function)

+ func (t MapCatalog) RemoveDatabase(ctx *Context, dbName string) error

+ func (t MapCatalog) Statistics(ctx *Context) (StatsReadWriter, error)

+ func (t MapCatalog) Table(ctx *Context, dbName, tableName string) (Table, Database, error)

+ func (t MapCatalog) TableAsOf(ctx *Context, dbName, tableName string, asOf interface{}) (Table, Database, error)

+ func (t MapCatalog) TableFunction(ctx *Context, name string) (TableFunction, error)

+ func (t MapCatalog) UnlockTables(ctx *Context, id uint32) error

type Schema

+ func (s Schema) CaseSensitiveEquals(s2 Schema) bool

+ type SqlMode struct

+ func LoadSqlMode(ctx *Context) (*SqlMode, error)

+ func NewSqlModeFromString(sqlModeString string) *SqlMode

+ func (s *SqlMode) AnsiQuotes() bool

+ func (s *SqlMode) ModeEnabled(mode string) bool

+ func (s *SqlMode) ParserOptions() sqlparser.ParserOptions

+ func (s *SqlMode) String() string

type StoredProcedureDetails

+ SqlMode string

+ type TableNode interface

+ UnderlyingTable func() Table

type TriggerDefinition

+ SqlMode string

type TypeWithCollation

+ StringWithTableCollation func(tableCollation CollationID) string

type UnresolvedColumnDefault

+ ExprString string

+ func NewUnresolvedColumnDefault(s string) *UnresolvedColumnDefault

type Value

+ func MustConvertToValue(v interface{}) Value

type View

+ func (v *View) WithDefinition(def Node) *View

type ViewDefinition

+ SqlMode string

type WindowAdaptableExpression

+ Window func() *WindowDefinition

+ WithWindow func(window *WindowDefinition) WindowAdaptableExpression

v0.16.0

Jun 29, 2023

Changes in this version

+ var ErrInvalidSRID = errors.NewKind("SRID value is out of range in %s")

+ var ErrNoSRID = errors.NewKind("There's no spatial reference with SRID %d")

+ var ErrNotBaseTable = errors.NewKind("'%s' is not BASE TABLE")

+ var ErrSpatialRefSysAlreadyExists = errors.NewKind("There is already a spatial reference system with SRID %v")

+ var ErrViewsNotSupported = errors.NewKind("database '%s' doesn't support views")

+ type AliasedDatabase interface

+ AliasedName func() string

+ type AnalyzerVersion uint8

+ const VersionExperimental

+ const VersionStable

+ const VersionUnknown

type BaseSession

+ func (s *BaseSession) UseDatabase(ctx *Context, db Database) error

type Catalog

+ DatabaseTable func(ctx *Context, db Database, tableName string) (Table, Database, error)

+ DatabaseTableAsOf func(ctx *Context, db Database, tableName string, asOf interface{}) (Table, Database, error)

+ type ColSet struct

+ func MakeColSet(vals ...ColumnId) ColSet

+ func NewColSet(vals ...ColumnId) ColSet

+ func (s *ColSet) Add(col ColumnId)

+ func (s *ColSet) DifferenceWith(rhs ColSet)

+ func (s *ColSet) IntersectionWith(rhs ColSet)

+ func (s *ColSet) Remove(col ColumnId)

+ func (s *ColSet) UnionWith(rhs ColSet)

+ func (s ColSet) Contains(col ColumnId) bool

+ func (s ColSet) Copy() ColSet

+ func (s ColSet) Difference(rhs ColSet) ColSet

+ func (s ColSet) Empty() bool

+ func (s ColSet) Equals(rhs ColSet) bool

+ func (s ColSet) ForEach(f func(col ColumnId))

+ func (s ColSet) Intersection(rhs ColSet) ColSet

+ func (s ColSet) Intersects(rhs ColSet) bool

+ func (s ColSet) Len() int

+ func (s ColSet) Next(startVal ColumnId) (ColumnId, bool)

+ func (s ColSet) String() string

+ func (s ColSet) SubsetOf(rhs ColSet) bool

+ func (s ColSet) Union(rhs ColSet) ColSet

type ColumnDefaultValue

+ Literal bool

+ OutType Type

+ Parenthesized bool

+ ReturnNil bool

+ type ColumnId uint16

type Context

+ Version AnalyzerVersion

+ type EquivSets struct

+ func (e *EquivSets) Add(cols ColSet)

+ func (e *EquivSets) Len() int

+ func (e *EquivSets) Sets() []ColSet

+ func (e *EquivSets) String() string

+ type ExtendedIndex interface

+ ExtendedColumnExpressionTypes func() []ColumnExpressionType

+ ExtendedExpressions func() []string

+ type FuncDepSet struct

+ func NewCrossJoinFDs(left, right *FuncDepSet) *FuncDepSet

+ func NewFilterFDs(fds *FuncDepSet, notNull ColSet, constant ColSet, equiv [][2]ColumnId) *FuncDepSet

+ func NewInnerJoinFDs(left, right *FuncDepSet, filters [][2]ColumnId) *FuncDepSet

+ func NewLeftJoinFDs(left, right *FuncDepSet, filters [][2]ColumnId) *FuncDepSet

+ func NewLookupFDs(fds *FuncDepSet, idxCols ColSet, notNull ColSet, constant ColSet, ...) *FuncDepSet

+ func NewMax1RowFDs(cols, notNull ColSet) *FuncDepSet

+ func NewProjectFDs(fds *FuncDepSet, cols ColSet, distinct bool) *FuncDepSet

+ func NewTablescanFDs(all ColSet, strict []ColSet, lax []ColSet, notNull ColSet) *FuncDepSet

+ func (f *FuncDepSet) AddConstants(cols ColSet)

+ func (f *FuncDepSet) AddEquiv(i, j ColumnId)

+ func (f *FuncDepSet) AddEquivSet(cols ColSet)

+ func (f *FuncDepSet) AddKey(k Key)

+ func (f *FuncDepSet) AddLaxKey(cols ColSet)

+ func (f *FuncDepSet) AddNotNullable(cols ColSet)

+ func (f *FuncDepSet) AddStrictKey(cols ColSet)

+ func (f *FuncDepSet) All() ColSet

+ func (f *FuncDepSet) ColsAreStrictKey(cols ColSet) bool

+ func (f *FuncDepSet) Constants() ColSet

+ func (f *FuncDepSet) CopyKeys() []Key

+ func (f *FuncDepSet) Equiv() *EquivSets

+ func (f *FuncDepSet) EquivalenceClosure(cols ColSet) ColSet

+ func (f *FuncDepSet) HasMax1Row() bool

+ func (f *FuncDepSet) LaxKey() (ColSet, bool)

+ func (f *FuncDepSet) NotNull() ColSet

+ func (f *FuncDepSet) StrictKey() (ColSet, bool)

+ func (f *FuncDepSet) String() string

type IndexLookup

+ IsReverse bool

+ type Key struct

+ func (k *Key) Empty() bool

type OrderedIndex

+ Reversible func() bool

type Schema

+ func (s Schema) Resolved() bool

type Session

+ UseDatabase func(ctx *Context, db Database) error

type SystemVariable

+ NotifyChanged func(SystemVariableScope, SystemVarValue)

+ ValueFunction func() (interface{}, error)

type SystemVariableType

+ UnderlyingType func() Type

v0.15.0

Apr 18, 2023

Changes in this version

+ const EventTimeStampFormat

+ const InformationSchemaDatabaseName

+ var ErrAlterTableCollationNotSupported = errors.NewKind("table %s cannot have its collation altered")

+ var ErrBadSpatialIdxCol = errors.NewKind("a SPATIAL index may only contain a geometrical type column")

+ var ErrCursorAlreadyOpen = errors.NewKind("cursor '%s' is already open")

+ var ErrCursorNotFound = errors.NewKind("cursor '%s' does not exist")

+ var ErrCursorNotOpen = errors.NewKind("cursor '%s' is not open")

+ var ErrDeclareConditionOrderInvalid = errors.NewKind("DECLARE ... CONDITION may only exist at the beginning of a BEGIN/END block")

+ var ErrDeclareCursorDuplicate = errors.NewKind("duplicate cursor '%s'")

+ var ErrDeclareCursorOrderInvalid = errors.NewKind(...)

+ var ErrDeclareHandlerDuplicate = errors.NewKind("duplicate handler declared in the same block")

+ var ErrDeclareHandlerOrderInvalid = errors.NewKind(...)

+ var ErrDeclareHandlerUndo = errors.NewKind("DECLARE ... HANDLER does not support the UNDO action")

+ var ErrDeclareVariableDuplicate = errors.NewKind("duplicate variable '%s'")

+ var ErrDeclareVariableOrderInvalid = errors.NewKind("DECLARE variables may only exist at the beginning of a BEGIN/END block")

+ var ErrDiffSRIDs = errors.NewKind(...)

+ var ErrDroppedJoinFilters = errors.NewKind("dropped filters from join, but failed to re-insert them")

+ var ErrEventAlreadyExists = errors.NewKind("Event '%s' already exists")

+ var ErrEventCreateStatementInvalid = errors.NewKind(`Invalid CREATE TRIGGER statement: %s`)

+ var ErrEventDoesNotExist = errors.NewKind("Event '%s' does not exist")

+ var ErrEventsNotSupported = errors.NewKind("database '%s' doesn't support events")

+ var ErrFetchIncorrectCount = errors.NewKind("incorrect number of FETCH variables")

+ var ErrGrantRevokeIllegalPrivilegeWithMessage = errors.NewKind("Illegal GRANT/REVOKE command: %s")

+ var ErrInvalidArgumentType = errors.NewKind("function '%s' received invalid argument types")

+ var ErrInvalidBlobTextKey = errors.NewKind("blob/text column '%s' used in key specification without a key length")

+ var ErrInvalidJson = errors.NewKind("Invalid JSON text: %s")

+ var ErrKeyTooLong = errors.NewKind("specified key was too long; max key length is 3072 bytes")

+ var ErrKeyZero = errors.NewKind("key part '%s' length cannot be 0")

+ var ErrLoopLabelNotFound = errors.NewKind("%s with no matching label: '%s'")

+ var ErrLoopRedefinition = errors.NewKind("redefining label '%s'")

+ var ErrMergeJoinExpectsComparerFilters = errors.NewKind("merge join expects expression.Comparer filters, found: %T")

+ var ErrNoJoinFilters = errors.NewKind("join expected non-nil filters")

+ var ErrNonAggregatedColumnWithoutGroupBy = errors.NewKind(...)

+ var ErrNullableSpatialIdx = errors.NewKind("All parts of a SPATIAL index must be NOT NULL")

+ var ErrProcedureCallAsOfReadOnly = errors.NewKind("CALL ... AS OF converts databases to read only")

+ var ErrProcedureNestedCallAsOf = errors.NewKind("CALL ... AS OF in stored procedure `%s`")

+ var ErrSRIDOnNonGeomCol = errors.NewKind("incorrect usage of SRID and non-geometry column")

+ var ErrTooManyKeyParts = errors.NewKind("too many key parts specified; max %d parts allowed")

+ var ErrUnknownEvent = errors.NewKind("Unknown event '%s'")

+ var ErrUnknownPreparedStatement = errors.NewKind(`Unknown prepared statement handler (%s) given to EXECUTE`)

+ var ErrUnknownTable = errors.NewKind("Unknown table '%s'")

+ var ErrUnsupportedGISTypeForSpatialFunc = errors.NewKind("unsupported spatial type: %s for function %s")

+ var ErrUnsupportedIndexPrefix = errors.NewKind("prefix index on string column '%s' unsupported")

+ var ErrUnsupportedSRID = errors.NewKind("SRID %v has not been implemented for geographic spatial reference systems.")

+ var ErrUnsupportedSpatialIdx = errors.NewKind("unsupported index type: SPATIAL")

+ var ErrValueOutOfRange = errors.NewKind("%v out of range for %v")

+ var ErrVersionedStoredProceduresNotSupported = errors.NewKind(`database "%s" doesn't support versioned stored procedures`)

+ func GenerateCreateTableCheckConstraintClause(checkName, checkExpr string, enforced bool) string

+ func GenerateCreateTableColumnDefinition(colName string, colType Type, nullable bool, autoInc bool, hasDefault bool, ...) string

+ func GenerateCreateTableForiegnKeyDefinition(fkName string, fkCols []string, parentTbl string, parentCols []string, ...) string

+ func GenerateCreateTableIndexDefinition(isUnique, isSpatial bool, indexID string, indexCols []string, comment string) string

+ func GenerateCreateTablePrimaryKeyDefinition(pkCols []string) string

+ func GenerateCreateTableStatement(tblName string, colStmts []string, tblCharsetName, tblCollName string) string

+ func Now() time.Time

+ func QuoteIdentifier(id string) string

+ func QuoteIdentifiers(ids []string) []string

+ type AutoIncrementEditor interface

+ type AutoIncrementGetter interface

+ GetNextAutoIncrementValue func(ctx *Context, insertVal interface{}) (uint64, error)

type BaseSession

+ func (s *BaseSession) GetPrivilegeSet() (PrivilegeSet, uint64)

+ func (s *BaseSession) GetTransactionDatabase() string

+ func (s *BaseSession) SetPrivilegeSet(newPs PrivilegeSet, counter uint64)

+ func (s *BaseSession) SetTransactionDatabase(dbName string)

type Catalog

+ Statistics func(ctx *Context) (StatsReadWriter, error)

+ type CatalogTable interface

+ AssignCatalog func(cat Catalog) Table

+ type CollationAlterableTable interface

+ ModifyDefaultCollation func(ctx *Context, collation CollationID) error

+ ModifyStoredCollation func(ctx *Context, collation CollationID) error

+ type CollationCoercible interface

+ CollationCoercibility func(ctx *Context) (collation CollationID, coercibility byte)

type CollationID

+ const Collation_Information_Schema_Default

+ const Collation_utf8mb4_bg_0900_ai_ci

+ const Collation_utf8mb4_bg_0900_as_cs

+ const Collation_utf8mb4_bs_0900_ai_ci

+ const Collation_utf8mb4_bs_0900_as_cs

+ const Collation_utf8mb4_gl_0900_ai_ci

+ const Collation_utf8mb4_gl_0900_as_cs

+ const Collation_utf8mb4_mn_cyrl_0900_ai_ci

+ const Collation_utf8mb4_mn_cyrl_0900_as_cs

+ const Collation_utf8mb4_nb_0900_ai_ci

+ const Collation_utf8mb4_nb_0900_as_cs

+ const Collation_utf8mb4_nn_0900_ai_ci

+ const Collation_utf8mb4_nn_0900_as_cs

+ const Collation_utf8mb4_sr_latn_0900_ai_ci

+ const Collation_utf8mb4_sr_latn_0900_as_cs

+ func GetCoercibility(ctx *Context, nodeOrExpr interface{}) (collation CollationID, coercibility byte)

+ func ResolveCoercibility(leftCollation CollationID, leftCoercibility byte, rightCollation CollationID, ...) (CollationID, byte)

+ func (c CollationID) WriteWeightString(hash io.Writer, str string) error

+ type CollationSorter func(r rune) int32

type ColumnDefaultValue

+ func (e *ColumnDefaultValue) CollationCoercibility(ctx *Context) (collation CollationID, coercibility byte)

+ type ColumnRename struct

+ After string

+ Before string

type Context

+ func (c *Context) SetQueryTime(t time.Time)

+ type ConvertInRange bool

+ const InRange

+ const OutOfRange

+ type DbTable struct

+ Db string

+ Table string

+ func NewDbTable(db, table string) DbTable

+ func (dt *DbTable) String() string

+ type EditOpenerCloser interface

+ DiscardChanges func(ctx *Context, errorEncountered error) error

+ StatementBegin func(ctx *Context)

+ StatementComplete func(ctx *Context) error

type EmptyProcessList

+ func (e EmptyProcessList) AddConnection(id uint32, addr string)

+ func (e EmptyProcessList) BeginQuery(ctx *Context, query string) (*Context, error)

+ func (e EmptyProcessList) ConnectionReady(Session)

+ func (e EmptyProcessList) EndQuery(ctx *Context)

+ func (e EmptyProcessList) RemoveConnection(uint32)

+ type EventDatabase interface

+ DropEvent func(ctx *Context, name string) error

+ GetEvent func(ctx *Context, name string) (EventDefinition, bool, error)

+ GetEvents func(ctx *Context) ([]EventDefinition, error)

+ SaveEvent func(ctx *Context, ed EventDefinition) error

+ UpdateEvent func(ctx *Context, ed EventDefinition) error

+ type EventDefinition struct

+ CreateStatement string

+ CreatedAt time.Time

+ LastAltered time.Time

+ Name string

+ type EventDetails struct

+ Comment string

+ Created time.Time

+ Definer string

+ Definition string

+ Ends time.Time

+ ExecuteAt time.Time

+ ExecuteEvery string

+ ExecutionCount uint64

+ HasEnds bool

+ HasExecuteAt bool

+ HasStarts bool

+ LastAltered time.Time

+ LastExecuted time.Time

+ Name string

+ OnCompletionPreserve bool

+ Starts time.Time

+ Status string

+ func (e *EventDetails) CreateEventStatement() string

+ type ExecSourceRel interface

+ RowIter func(ctx *Context, r Row) (RowIter, error)

+ type ExpressionWithNodes interface

+ NodeChildren func() []Node

+ WithNodeChildren func(children ...Node) (ExpressionWithNodes, error)

+ type ForeignKeyEditor interface

type ForeignKeyReferentialAction

+ func (f ForeignKeyReferentialAction) IsEquivalentToRestrict() bool

type ForeignKeyTable

+ GetForeignKeyEditor func(ctx *Context) ForeignKeyEditor

type Index

+ IsSpatial func() bool

+ PrefixLengths func() []uint16

+ type IndexDef struct

+ Columns []IndexColumn

+ Comment string

+ Constraint IndexConstraint

+ Name string

+ Storage IndexUsing

type IndexLookup

+ IsSpatialLookup bool

+ type IndexedTableCreator interface

+ CreateIndexedTable func(ctx *Context, name string, schema PrimaryKeySchema, idxDef IndexDef, ...) error

+ type NameableNode interface

+ type NodeExecBuilder interface

+ Build func(ctx *Context, n Node, r Row) (RowIter, error)

+ type PrivilegeSet interface

+ Count func() int

+ Database func(dbName string) PrivilegeSetDatabase

+ Equals func(otherPs PrivilegeSet) bool

+ GetDatabases func() []PrivilegeSetDatabase

+ Has func(privileges ...PrivilegeType) bool

+ HasPrivileges func() bool

+ ToSlice func() []PrivilegeType

+ type PrivilegeSetColumn interface

+ Count func() int

+ Equals func(otherPs PrivilegeSetColumn) bool

+ Has func(privileges ...PrivilegeType) bool

+ Name func() string

+ ToSlice func() []PrivilegeType

+ type PrivilegeSetDatabase interface

+ Count func() int

+ Equals func(otherPs PrivilegeSetDatabase) bool

+ GetTables func() []PrivilegeSetTable

+ Has func(privileges ...PrivilegeType) bool

+ HasPrivileges func() bool

+ Name func() string

+ Table func(tblName string) PrivilegeSetTable

+ ToSlice func() []PrivilegeType

+ type PrivilegeSetTable interface

+ Column func(colName string) PrivilegeSetColumn

+ Count func() int

+ Equals func(otherPs PrivilegeSetTable) bool

+ GetColumns func() []PrivilegeSetColumn

+ Has func(privileges ...PrivilegeType) bool

+ HasPrivileges func() bool

+ Name func() string

+ ToSlice func() []PrivilegeType

type PrivilegeType

+ const PrivilegeType_GrantOption

type PrivilegedOperation

+ DynamicPrivileges []string

+ StaticPrivileges []PrivilegeType

+ func NewDynamicPrivilegedOperation(privs ...string) PrivilegedOperation

type Process

+ Command ProcessCommand

+ Database string

+ Host string

+ QueryPid uint64

+ type ProcessCommand string

+ const ProcessCommandConnect

+ const ProcessCommandQuery

+ const ProcessCommandSleep

type ProcessList

+ AddConnection func(connID uint32, addr string)

+ BeginQuery func(ctx *Context, query string) (*Context, error)

+ ConnectionReady func(sess Session)

+ EndQuery func(ctx *Context)

+ RemoveConnection func(connID uint32)

+ type RenameableNode interface

+ WithName func(string) Node

type Session

+ GetPrivilegeSet func() (PrivilegeSet, uint64)

+ GetTransactionDatabase func() string

+ SetPrivilegeSet func(newPs PrivilegeSet, counter uint64)

+ SetTransactionDatabase func(dbName string)

+ type SessionUserVariables interface

+ GetUserVariable func(ctx *Context, varName string) (Type, interface{}, error)

+ SetUserVariable func(ctx *Context, varName string, value interface{}, typ Type) error

+ func NewUserVars() SessionUserVariables

+ type SpatialIndexBuilder struct

+ func NewSpatialIndexBuilder(idx Index) *SpatialIndexBuilder

+ func (b *SpatialIndexBuilder) AddRange(lower, upper interface{}) *SpatialIndexBuilder

+ func (b *SpatialIndexBuilder) Build() (IndexLookup, error)

type StatisticsTable

+ RowCount func(ctx *Context) (uint64, error)

+ type StatsReadWriter interface

+ type StatsReader interface

+ Hist func(ctx *Context, db, table string) (HistogramMap, error)

+ RowCount func(ctx *Context, db, table string) (uint64, bool, error)

+ type StatsWriter interface

+ Analyze func(ctx *Context, db, table string) error

type StoredProcedureDatabase

+ GetStoredProcedure func(ctx *Context, name string) (StoredProcedureDetails, bool, error)

+ type SystemVarValue struct

+ Val interface{}

+ Var SystemVariable

+ type SystemVariableRegistry interface

+ AddSystemVariables func(sysVars []SystemVariable)

+ AssignValues func(vals map[string]interface{}) error

+ GetAllGlobalVariables func() map[string]interface{}

+ GetGlobal func(name string) (SystemVariable, interface{}, bool)

+ NewSessionMap func() map[string]SystemVarValue

+ SetGlobal func(name string, val interface{}) error

type TableStatistics

+ Histograms HistogramMap

+ type TransactionSession interface

+ CommitTransaction func(ctx *Context, tx Transaction) error

+ CreateSavepoint func(ctx *Context, transaction Transaction, name string) error

+ ReleaseSavepoint func(ctx *Context, transaction Transaction, name string) error

+ Rollback func(ctx *Context, transaction Transaction) error

+ RollbackToSavepoint func(ctx *Context, transaction Transaction, name string) error

+ StartTransaction func(ctx *Context, tCharacteristic TransactionCharacteristic) (Transaction, error)

type UnresolvedColumnDefault

+ func (UnresolvedColumnDefault) CollationCoercibility(ctx *Context) (collation CollationID, coercibility byte)

+ type UserVars struct

+ func (u *UserVars) GetUserVariable(ctx *Context, varName string) (Type, interface{}, error)

+ func (u *UserVars) SetUserVariable(ctx *Context, varName string, value interface{}, typ Type) error

type View

+ func (v *View) CreateStatement() string

type ViewDatabase

+ GetViewDefinition func(ctx *Context, viewName string) (ViewDefinition, bool, error)

type ViewDefinition

+ CreateViewStatement string

v0.14.0

Nov 1, 2022

Changes in this version

+ const GeometryMaxByteLength

+ const WKBGeomCollID

+ const WKBHeaderSize

+ const WKBMultiLineID

+ const WKBMultiPointID

+ const WKBMultiPolyID

+ var ErrAmbiguousColumnOrAliasName = errors.NewKind("ambiguous column or alias name %q")

+ var ErrCharSetFailedToEncode = errors.NewKind("failed to encode `%s`")

+ var ErrCharSetIntroducer = errors.NewKind("CHARACTER SET introducer must be attached to a string")

+ var ErrCharSetInvalidString = errors.NewKind("invalid string for character set `%s`: \"%s\"")

+ var ErrCharSetNotYetImplementedTemp = errors.NewKind(...)

+ var ErrCharSetUnknown = errors.NewKind("Unknown character set: %v")

+ var ErrCollatedExprWrongType = errors.NewKind("wrong type in collated expression")

+ var ErrCollationIllegalMix = errors.NewKind("Illegal mix of collations (%v) and (%v)")

+ var ErrCollationInvalidForCharSet = errors.NewKind("COLLATION '%s' is not valid for CHARACTER SET '%s'")

+ var ErrCollationMalformedString = errors.NewKind("malformed string encountered while %s")

+ var ErrCollationNotYetImplementedTemp = errors.NewKind(...)

+ var ErrCollationUnknown = errors.NewKind("Unknown collation: %v")

+ var ErrConflictingExternalQuery = errors.NewKind("found external scope with conflicting ORDER BY/LIMIT")

+ var ErrDatabaseCollationsNotSupported = errors.NewKind("database %s does not support collation operations")

+ var ErrDatabaseWriteLocked = errors.NewKind("database is locked to writes")

+ var ErrForeignKeyDepthLimit = errors.NewKind("Foreign key cascade delete/update exceeds max depth of 15.")

+ var ErrInvalidByteIndex = errors.NewKind("index on byte column '%s' unsupported")

+ var ErrInvalidBytePrimaryKey = errors.NewKind("invalid primary key on byte column '%s'")

+ var ErrInvalidColumnDefaultValue = errors.NewKind("Invalid default value for '%s'")

+ var ErrInvalidTextIndex = errors.NewKind("index on text column '%s' unsupported")

+ var ErrLockDeadlock = errors.NewKind("serialization failure: %s, try restarting transaction.")

+ var ErrNoTablesUsed = errors.NewKind("No tables used")

+ var ErrNotGeomColl = errors.NewKind("value of type %T is not a point")

+ var ErrNotMultiLineString = errors.NewKind("value of type %T is not a multilinestring")

+ var ErrNotMultiPoint = errors.NewKind("value of type %T is not a multipoint")

+ var ErrNotMultiPolygon = errors.NewKind("value of type %T is not a multipolygon")

+ var ErrReadOnly = errors.NewKind("database server is set to read only mode")

+ var ErrSystemVariableReinitialized = errors.NewKind(`Variable '%s' was initialized more than 1x`)

+ var ErrTemporaryEnum = errors.NewKind("attempted to use temporary enum")

+ var ErrUnsupportedGISType = errors.NewKind("unsupported geospatial type: %s from value: 0x%s")

+ var MaxJsonFieldByteLength = int64(1024) * int64(1024) * int64(1024)

+ var NoopTracer = trace.NewNoopTracerProvider().Tracer("github.com/dolthub/go-mysql-server/sql")

+ func ConvertToString(v interface{}, t StringType) (string, error)

+ func ConvertToTime(v interface{}, t datetimeType) (time.Time, error)

+ func DeserializeEWKBHeader(buf []byte) (srid uint32, bigEndian bool, typ uint32, err error)

+ func DeserializeWKBHeader(buf []byte) (bigEndian bool, typ uint32, err error)

+ func IsBinaryType(t Type) bool

+ func IsByteType(t Type) bool

+ func IsEnum(t Type) bool

+ func IsGeometry(t Type) bool

+ func IsSet(t Type) bool

+ func UnwrapError(err error) error

+ func WriteEWKBHeader(buf []byte, srid, typ uint32)

+ func WriteWKBHeader(buf []byte, typ uint32)

type Above

+ Key interface{}

+ type AboveNull struct

+ func (AboveNull) Compare(c RangeCut, typ Type) (int, error)

+ func (AboveNull) String() string

+ func (AboveNull) TypeAsLowerBound() RangeBoundType

+ func (AboveNull) TypeAsUpperBound() RangeBoundType

type BaseSession

+ func (s *BaseSession) GetCharacterSet() CharacterSetID

+ func (s *BaseSession) GetCharacterSetResults() CharacterSetID

+ func (s *BaseSession) GetCollation() CollationID

+ func (s *BaseSession) InitSessionVariable(ctx *Context, sysVarName string, value interface{}) error

+ func (s *BaseSession) ValidateSession(ctx *Context, dbName string) error

type Below

+ Key interface{}

+ type BelowNull struct

+ func (BelowNull) Compare(c RangeCut, typ Type) (int, error)

+ func (BelowNull) String() string

+ func (BelowNull) TypeAsLowerBound() RangeBoundType

+ func (BelowNull) TypeAsUpperBound() RangeBoundType

type CharacterSet

+ Encoder encodings.Encoder

+ ID CharacterSetID

+ Name string

+ type CharacterSetID uint16

+ const CharacterSet_Unspecified

+ func (cs CharacterSetID) BinaryCollation() CollationID

+ func (cs CharacterSetID) DefaultCollation() CollationID

+ func (cs CharacterSetID) Description() string

+ func (cs CharacterSetID) Encoder() encodings.Encoder

+ func (cs CharacterSetID) MaxLength() int64

+ func (cs CharacterSetID) Name() string

+ func (cs CharacterSetID) String() string

+ type CharacterSetsIterator struct

+ func NewCharacterSetsIterator() *CharacterSetsIterator

+ func (csi *CharacterSetsIterator) Next() (CharacterSet, bool)

+ type CollatedDatabase interface

+ GetCollation func(ctx *Context) CollationID

+ SetCollation func(ctx *Context, collation CollationID) error

+ type CollatedDatabaseProvider interface

+ CreateCollatedDatabase func(ctx *Context, name string, collation CollationID) error

type Collation

+ PadAttribute string

+ SortLength uint8

+ Sorter func(r rune) int32

+ type CollationID uint16

+ const Collation_Unspecified

+ func ConvertToCollatedString(val interface{}, typ Type) (string, CollationID, error)

+ func (c CollationID) CharacterSet() CharacterSetID

+ func (c CollationID) Collation() Collation

+ func (c CollationID) Equals(other CollationID) bool

+ func (c CollationID) HashToBytes(str string) ([]byte, error)

+ func (c CollationID) HashToUint(str string) (uint64, error)

+ func (c CollationID) IsCompiled() string

+ func (c CollationID) IsDefault() string

+ func (c CollationID) Name() string

+ func (c CollationID) PadAttribute() string

+ func (c CollationID) SortLength() int64

+ func (c CollationID) Sorter() func(r rune) int32

+ func (c CollationID) String() string

+ func (c CollationID) WorksWithCharacterSet(cs CharacterSetID) bool

+ type CollationsIterator struct

+ func NewCollationsIterator() *CollationsIterator

+ func (ci *CollationsIterator) Next() (Collation, bool)

type Column

+ DatabaseSource string

type ColumnDefaultValue

+ func (e *ColumnDefaultValue) IsParenthesized() bool

type DecimalType

+ BoundsCheck func(v decimal.Decimal) (decimal.Decimal, error)

+ ConvertNoBoundsCheck func(v interface{}) (decimal.Decimal, error)

type DriverIndexLookup

+ Lookup func() IndexLookup

type DriverIndexableTable

+ WithDriverIndexLookup func(DriverIndexLookup) Table

+ type ExternalStoredProcedureProvider interface

+ ExternalStoredProcedure func(ctx *Context, name string, numOfParams int) (*ExternalStoredProcedureDetails, error)

+ ExternalStoredProcedures func(ctx *Context, name string) ([]ExternalStoredProcedureDetails, error)

+ type ExternalStoredProcedureRegistry struct

+ func NewExternalStoredProcedureRegistry() ExternalStoredProcedureRegistry

+ func (epd *ExternalStoredProcedureRegistry) LookupByName(name string) ([]ExternalStoredProcedureDetails, error)

+ func (epd *ExternalStoredProcedureRegistry) LookupByNameAndParamCount(name string, numOfParams int) (*ExternalStoredProcedureDetails, error)

+ func (epd *ExternalStoredProcedureRegistry) Register(procedureDetails ExternalStoredProcedureDetails)

+ type FastIntSet struct

+ func NewFastIntSet(vals ...int) FastIntSet

+ func (s *FastIntSet) Add(i int)

+ func (s *FastIntSet) AddRange(from, to int)

+ func (s *FastIntSet) CopyFrom(c FastIntSet)

+ func (s *FastIntSet) DifferenceWith(rhs FastIntSet)

+ func (s *FastIntSet) IntersectionWith(rhs FastIntSet)

+ func (s *FastIntSet) Remove(i int)

+ func (s *FastIntSet) Shift(delta int) FastIntSet

+ func (s *FastIntSet) UnionWith(rhs FastIntSet)

+ func (s FastIntSet) Contains(i int) bool

+ func (s FastIntSet) Copy() FastIntSet

+ func (s FastIntSet) Difference(rhs FastIntSet) FastIntSet

+ func (s FastIntSet) Empty() bool

+ func (s FastIntSet) Equals(rhs FastIntSet) bool

+ func (s FastIntSet) ForEach(f func(i int))

+ func (s FastIntSet) Intersection(rhs FastIntSet) FastIntSet

+ func (s FastIntSet) Intersects(rhs FastIntSet) bool

+ func (s FastIntSet) Len() int

+ func (s FastIntSet) Next(startVal int) (int, bool)

+ func (s FastIntSet) Ordered() []int

+ func (s FastIntSet) String() string

+ func (s FastIntSet) SubsetOf(rhs FastIntSet) bool

+ func (s FastIntSet) Union(rhs FastIntSet) FastIntSet

type FilteredTable

+ Filters func() []Expression

+ type GeomColl struct

+ Geoms []GeometryValue

+ SRID uint32

+ func DeserializeGeomColl(buf []byte, isBig bool, srid uint32) (GeomColl, int, error)

+ func (g GeomColl) CalculateSize() (numPoints int, numCounts int, numHeaders int)

+ func (g GeomColl) GetSRID() uint32

+ func (g GeomColl) Serialize() (buf []byte)

+ func (g GeomColl) SetSRID(srid uint32) GeometryValue

+ func (g GeomColl) Swap() GeometryValue

+ func (g GeomColl) WriteData(buf []byte) int

+ type GeomCollType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t GeomCollType) Compare(a interface{}, b interface{}) (int, error)

+ func (t GeomCollType) Convert(v interface{}) (interface{}, error)

+ func (t GeomCollType) Equals(otherType Type) bool

+ func (t GeomCollType) GetSpatialTypeSRID() (uint32, bool)

+ func (t GeomCollType) MatchSRID(v interface{}) error

+ func (t GeomCollType) MaxTextResponseByteLength() uint32

+ func (t GeomCollType) Promote() Type

+ func (t GeomCollType) SQL(ctx *Context, dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t GeomCollType) SetSRID(v uint32) Type

+ func (t GeomCollType) String() string

+ func (t GeomCollType) Type() query.Type

+ func (t GeomCollType) ValueType() reflect.Type

+ func (t GeomCollType) Zero() interface{}

type GeometryType

+ func (t GeometryType) MaxTextResponseByteLength() uint32

type GeometryValue

+ GetSRID func() uint32

+ Serialize func() []byte

+ SetSRID func(srid uint32) GeometryValue

+ Swap func() GeometryValue

+ WriteData func(buf []byte) int

+ type Histogram struct

+ Buckets []*HistogramBucket

+ Count uint64

+ DistinctCount uint64

+ Max float64

+ Mean float64

+ Min float64

+ NullCount uint64

+ type HistogramBucket struct

+ Frequency float64

+ LowerBound float64

+ UpperBound float64

+ type HistogramMap map[string]*Histogram

+ func NewHistogramMapFromTable(ctx *Context, t Table) (HistogramMap, error)

+ type IgnorableError struct

+ OffendingRow Row

+ func NewIgnorableError(row Row) IgnorableError

+ func (e IgnorableError) Error() string

type Index

+ CanSupport func(...Range) bool

type IndexAddressable

+ GetIndexes func(ctx *Context) ([]Index, error)

+ IndexedAccess func(Index) IndexedTable

type IndexLookup

+ IsEmptyRange bool

+ IsPointLookup bool

+ func (il IndexLookup) DebugString() string

+ func (il IndexLookup) IsEmpty() bool

+ func (il IndexLookup) String() string

type IndexedTable

+ LookupPartitions func(*Context, IndexLookup) (PartitionIter, error)

type LineString

+ func DeserializeLine(buf []byte, isBig bool, srid uint32) (LineString, int, error)

+ func (l LineString) GetSRID() uint32

+ func (l LineString) Serialize() (buf []byte)

+ func (l LineString) SetSRID(srid uint32) GeometryValue

+ func (l LineString) Swap() GeometryValue

+ func (l LineString) WriteData(buf []byte) int

type LineStringType

+ func (t LineStringType) MaxTextResponseByteLength() uint32

+ type MultiLineString struct

+ Lines []LineString

+ SRID uint32

+ func DeserializeMLine(buf []byte, isBig bool, srid uint32) (MultiLineString, int, error)

+ func (p MultiLineString) GetSRID() uint32

+ func (p MultiLineString) Serialize() (buf []byte)

+ func (p MultiLineString) SetSRID(srid uint32) GeometryValue

+ func (p MultiLineString) Swap() GeometryValue

+ func (p MultiLineString) WriteData(buf []byte) int

+ type MultiLineStringType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t MultiLineStringType) Compare(a interface{}, b interface{}) (int, error)

+ func (t MultiLineStringType) Convert(v interface{}) (interface{}, error)

+ func (t MultiLineStringType) Equals(otherType Type) bool

+ func (t MultiLineStringType) GetSpatialTypeSRID() (uint32, bool)

+ func (t MultiLineStringType) MatchSRID(v interface{}) error

+ func (t MultiLineStringType) MaxTextResponseByteLength() uint32

+ func (t MultiLineStringType) Promote() Type

+ func (t MultiLineStringType) SQL(ctx *Context, dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t MultiLineStringType) SetSRID(v uint32) Type

+ func (t MultiLineStringType) String() string

+ func (t MultiLineStringType) Type() query.Type

+ func (t MultiLineStringType) ValueType() reflect.Type

+ func (t MultiLineStringType) Zero() interface{}

+ type MultiPoint struct

+ Points []Point

+ SRID uint32

+ func DeserializeMPoint(buf []byte, isBig bool, srid uint32) (MultiPoint, int, error)

+ func (p MultiPoint) GetSRID() uint32

+ func (p MultiPoint) Serialize() (buf []byte)

+ func (p MultiPoint) SetSRID(srid uint32) GeometryValue

+ func (p MultiPoint) Swap() GeometryValue

+ func (p MultiPoint) WriteData(buf []byte) int

+ type MultiPointType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t MultiPointType) Compare(a interface{}, b interface{}) (int, error)

+ func (t MultiPointType) Convert(v interface{}) (interface{}, error)

+ func (t MultiPointType) Equals(otherType Type) bool

+ func (t MultiPointType) GetSpatialTypeSRID() (uint32, bool)

+ func (t MultiPointType) MatchSRID(v interface{}) error

+ func (t MultiPointType) MaxTextResponseByteLength() uint32

+ func (t MultiPointType) Promote() Type

+ func (t MultiPointType) SQL(ctx *Context, dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t MultiPointType) SetSRID(v uint32) Type

+ func (t MultiPointType) String() string

+ func (t MultiPointType) Type() query.Type

+ func (t MultiPointType) ValueType() reflect.Type

+ func (t MultiPointType) Zero() interface{}

+ type MultiPolygon struct

+ Polygons []Polygon

+ SRID uint32

+ func DeserializeMPoly(buf []byte, isBig bool, srid uint32) (MultiPolygon, int, error)

+ func (p MultiPolygon) GetSRID() uint32

+ func (p MultiPolygon) Serialize() (buf []byte)

+ func (p MultiPolygon) SetSRID(srid uint32) GeometryValue

+ func (p MultiPolygon) Swap() GeometryValue

+ func (p MultiPolygon) WriteData(buf []byte) int

+ type MultiPolygonType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t MultiPolygonType) Compare(a interface{}, b interface{}) (int, error)

+ func (t MultiPolygonType) Convert(v interface{}) (interface{}, error)

+ func (t MultiPolygonType) Equals(otherType Type) bool

+ func (t MultiPolygonType) GetSpatialTypeSRID() (uint32, bool)

+ func (t MultiPolygonType) MatchSRID(v interface{}) error

+ func (t MultiPolygonType) MaxTextResponseByteLength() uint32

+ func (t MultiPolygonType) Promote() Type

+ func (t MultiPolygonType) SQL(ctx *Context, dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t MultiPolygonType) SetSRID(v uint32) Type

+ func (t MultiPolygonType) String() string

+ func (t MultiPolygonType) Type() query.Type

+ func (t MultiPolygonType) ValueType() reflect.Type

+ func (t MultiPolygonType) Zero() interface{}

type Point

+ func DeserializePoint(buf []byte, isBig bool, srid uint32) (Point, int, error)

+ func (p Point) GetSRID() uint32

+ func (p Point) Serialize() (buf []byte)

+ func (p Point) SetSRID(srid uint32) GeometryValue

+ func (p Point) Swap() GeometryValue

+ func (p Point) WriteData(buf []byte) int

type PointType

+ func (t PointType) MaxTextResponseByteLength() uint32

type Polygon

+ func DeserializePoly(buf []byte, isBig bool, srid uint32) (Polygon, int, error)

+ func (p Polygon) GetSRID() uint32

+ func (p Polygon) Serialize() (buf []byte)

+ func (p Polygon) SetSRID(srid uint32) GeometryValue

+ func (p Polygon) Swap() GeometryValue

+ func (p Polygon) WriteData(buf []byte) int

type PolygonType

+ func (t PolygonType) MaxTextResponseByteLength() uint32

+ type Projector interface

+ ProjectedExprs func() []Expression

+ WithProjectedExprs func(...Expression) (Projector, error)

type Range

+ func (rang Range) IsEmpty() (bool, error)

type RangeType

+ const RangeType_EqualNull

+ const RangeType_LessOrEqualOrNull

+ const RangeType_LessThanOrNull

type Session

+ GetCharacterSet func() CharacterSetID

+ GetCharacterSetResults func() CharacterSetID

+ GetCollation func() CollationID

+ InitSessionVariable func(ctx *Context, sysVarName string, value interface{}) error

+ ValidateSession func(ctx *Context, dbName string) error

type StatisticsTable

+ AnalyzeTable func(ctx *Context) error

+ Statistics func(ctx *Context) (TableStatistics, error)

type StringType

+ Length func() int64

type Table

+ Collation func() CollationID

+ type TableStatistics interface

+ CreatedAt func() time.Time

+ Histogram func(colName string) (*Histogram, error)

+ HistogramMap func() HistogramMap

+ RowCount func() uint64

type TupleType

+ func (t TupleType) MaxTextResponseByteLength() uint32

type Type

+ MaxTextResponseByteLength func() uint32

+ type TypeWithCollation interface

+ Collation func() CollationID

+ WithNewCollation func(collation CollationID) (Type, error)

+ type WrappedTypeConversionError struct

+ Err error

+ OffendingIdx int

+ OffendingVal interface{}

+ func NewWrappedTypeConversionError(offendingVal interface{}, idx int, err error) WrappedTypeConversionError

+ func (w WrappedTypeConversionError) Error() string

v0.12.0

Jun 12, 2022

Changes in this version

+ const CartesianSRID

+ const ConnectTimeLogKey

+ const ConnectionDbLogField

+ const ConnectionIdLogField

+ const CountSize

+ const DualTableName

+ const EWKBHeaderSize

+ const EndianSize

+ const GeoSpatialSRID

+ const PointSize

+ const RangeType_All

+ const RangeType_ClosedClosed

+ const RangeType_ClosedOpen

+ const RangeType_Empty

+ const RangeType_GreaterOrEqual

+ const RangeType_GreaterThan

+ const RangeType_Invalid

+ const RangeType_LessOrEqual

+ const RangeType_LessThan

+ const RangeType_Null

+ const RangeType_OpenClosed

+ const RangeType_OpenOpen

+ const SRIDSize

+ const TypeSize

+ const WKBLineID

+ const WKBPointID

+ const WKBPolyID

+ const WKBUnknown

+ var DualTableSchema = NewPrimaryKeySchema(Schema{ ... })

+ var ErrAddForeignKeyDuplicateColumn = errors.NewKind("cannot have duplicates of columns in a foreign key: `%v`")

+ var ErrCannotAddToClosedBackgroundThreads = errors.New("cannot add to a close background threads instance")

+ var ErrCannotCopyWindowFrame = errors.NewKind("cannot copy window '%s' because it has a frame clause")

+ var ErrCheckConstraintInvalidatedByColumnAlter = errors.NewKind("can't alter column %q because it would invalidate check constraint %q")

+ var ErrCircularWindowInheritance = errors.NewKind("there is a circularity in the window dependency graph")

+ var ErrColumnExists = errors.NewKind("Column %q already exists")

+ var ErrColumnNumberDoesNotMatch = errors.NewKind("The used SELECT statements have a different number of columns")

+ var ErrCreateTableNotSupported = errors.NewKind("tables cannot be created on database %s")

+ var ErrCteRecursionLimitExceeded = errors.NewKind("WITH RECURSIVE iteration limit exceeded")

+ var ErrDatabaseAccessDeniedForUser = errors.NewKind("Access denied for user %s to database '%s'")

+ var ErrDatabaseExists = errors.NewKind("can't create database %s; database exists")

+ var ErrDropTableNotSupported = errors.NewKind("tables cannot be dropped on database %s")

+ var ErrExternalProcedureAmbiguousOverload = errors.NewKind(...)

+ var ErrExternalProcedureFirstReturn = errors.NewKind("external stored procedures require the first return value to be the RowIter")

+ var ErrExternalProcedureInvalidParamType = errors.NewKind("external stored procedures do not support parameters with type `%s`")

+ var ErrExternalProcedureMissingContextParam = errors.NewKind("external stored procedures require the first parameter to be the context")

+ var ErrExternalProcedureNonFunction = errors.NewKind("received `%T` in place of a function for an external stored procedure")

+ var ErrExternalProcedurePointerVariadic = errors.NewKind(...)

+ var ErrExternalProcedureReturnTypes = errors.NewKind("external stored procedures must return a RowIter and error")

+ var ErrExternalProcedureSecondReturn = errors.NewKind("external stored procedures require the second return value to be the error")

+ var ErrForeignKeyColumnTypeMismatch = errors.NewKind("column type mismatch on `%s` and `%s`")

+ var ErrForeignKeyDropColumn = errors.NewKind("cannot drop column `%s` as it is used in foreign key `%s`")

+ var ErrForeignKeyDropIndex = errors.NewKind("cannot drop index: `%s` is used by foreign key `%s`")

+ var ErrForeignKeyDropTable = errors.NewKind("cannot drop table `%s` as it is referenced in foreign key `%s`")

+ var ErrForeignKeyDuplicateName = errors.NewKind("duplicate foreign key constraint name `%s`")

+ var ErrForeignKeyMissingColumns = errors.NewKind("cannot create a foreign key without columns")

+ var ErrForeignKeyMissingReferenceIndex = errors.NewKind("missing index for foreign key `%s` on the referenced table `%s`")

+ var ErrForeignKeyNotFound = errors.NewKind("foreign key `%s` was not found on the table `%s`")

+ var ErrForeignKeySetDefault = errors.NewKind(`"SET DEFAULT" is not supported`)

+ var ErrForeignKeySetNullNonNullable = errors.NewKind("cannot use SET NULL as column `%s` is non-nullable")

+ var ErrForeignKeyTextBlob = errors.NewKind("TEXT/BLOB are not valid types for foreign keys")

+ var ErrForeignKeyTypeChange = errors.NewKind("unable to change type of column `%s` as it is used by foreign keys")

+ var ErrForeignKeyTypeChangeSetNull = errors.NewKind("column `%s` must allow NULL values as foreign key `%s` has SET NULL")

+ var ErrGrantRevokeIllegalPrivilege = errors.NewKind("Illegal GRANT/REVOKE command")

+ var ErrGrantRevokeRoleDoesNotExist = errors.NewKind("Unknown authorization ID %s")

+ var ErrGrantUserDoesNotExist = errors.NewKind("You are not allowed to create a user with GRANT")

+ var ErrIllegalGISValue = errors.NewKind("illegal non geometric '%v' value found during parsing")

+ var ErrInvalidArgumentDetails = errors.NewKind("Invalid argument to %s: %s")

+ var ErrInvalidAutoIncCols = errors.NewKind("there can be only one auto_increment column and it must be defined as a key")

+ var ErrInvalidCheckConstraint = errors.NewKind("invalid constraint definition: %s")

+ var ErrInvalidColExpr = errors.NewKind("the expression `%s` could not be found from the index `%s`")

+ var ErrInvalidConstraintFunctionNotSupported = errors.NewKind("Invalid constraint expression, function not supported: %s")

+ var ErrInvalidExpressionNumber = errors.NewKind("%T: invalid expression number, got %d, expected %d")

+ var ErrInvalidGISData = errors.NewKind("invalid GIS data provided to function %s")

+ var ErrInvalidIndexPrefix = errors.NewKind("invalid index prefix: %v")

+ var ErrInvalidRangeType = errors.NewKind("encountered the RangeType_Invalid")

+ var ErrInvalidRecursiveCteInitialQuery = errors.NewKind("recursive cte initial query must be non-recursive projection; found: %v")

+ var ErrInvalidRecursiveCteRecursiveQuery = errors.NewKind("recursive cte recursive query must be a recursive projection; found: %v")

+ var ErrInvalidRecursiveCteUnion = errors.NewKind("recursive cte top-level query must be a union; found: %v")

+ var ErrInvalidSQLValType = errors.NewKind("invalid SQLVal of type: %d")

+ var ErrInvalidWindowInheritance = errors.NewKind("window '%s' cannot inherit '%s' since %s")

+ var ErrMoreThanOneRow = errors.NewKind("Result consisted of more than one row")

+ var ErrNoForeignKeySupport = errors.NewKind("the table does not support foreign key operations: %s")

+ var ErrNotAuthorized = errors.NewKind("not authorized")

+ var ErrNotGeometry = errors.NewKind("Value of type %T is not a geometry")

+ var ErrNotLineString = errors.NewKind("value of type %T is not a linestring")

+ var ErrNotMatchingSRID = errors.NewKind(...)

+ var ErrNotMatchingSRIDWithColName = errors.NewKind("The SRID of the geometry does not match the SRID of the column '%s'. %v")

+ var ErrNotPoint = errors.NewKind("value of type %T is not a point")

+ var ErrNotPolygon = errors.NewKind("value of type %T is not a polygon")

+ var ErrPrivilegeCheckFailed = errors.NewKind("command denied to user %s")

+ var ErrRangeSimplification = errors.NewKind("attempting to simplify ranges has removed all ranges")

+ var ErrRenameTableNotSupported = errors.NewKind("tables cannot be renamed on database %s")

+ var ErrRevokeUserDoesNotExist = errors.NewKind("There is no such grant defined for user '%s' on host '%s'")

+ var ErrRoleCreationFailure = errors.NewKind("Operation CREATE ROLE failed for %s")

+ var ErrRoleDeletionFailure = errors.NewKind("Operation DROP ROLE failed for %s")

+ var ErrSessionDoesNotSupportPersistence = errors.NewKind("session does not support persistence")

+ var ErrShowGrantsUserDoesNotExist = errors.NewKind("There is no such grant defined for user '%s' on host '%s'")

+ var ErrSpatialTypeConversion = errors.NewKind("Cannot get geometry object from data you send to the GEOMETRY field")

+ var ErrTableAccessDeniedForUser = errors.NewKind("Access denied for user %s to table '%s'")

+ var ErrTableCreatedNotFound = errors.NewKind("table was created but could not be found")

+ var ErrTableFunctionNotFound = errors.NewKind("table function: '%s' not found")

+ var ErrTemporaryTablesForeignKeySupport = errors.NewKind("temporary tables do not support foreign keys")

+ var ErrUnexpectedNilRow = errors.NewKind("unexpected nil row")

+ var ErrUnknownColumn = errors.NewKind("Unknown column '%s' in '%s'")

+ var ErrUnknownConstraintDefinition = errors.NewKind("unknown constraint definition: %s, %T")

+ var ErrUnknownIndexColumn = errors.NewKind("unknown column: '%s' in index '%s'")

+ var ErrUnknownWindowName = errors.NewKind("named window not found: '%s'")

+ var ErrUnsupportedJoinFactorCount = errors.NewKind("unsupported join factor count: expected fewer than %d tables, found %d")

+ var ErrUnsupportedSyntax = errors.NewKind("unsupported syntax: %s")

+ var ErrUserCreationFailure = errors.NewKind("Operation CREATE USER failed for %s")

+ var ErrUserDeletionFailure = errors.NewKind("Operation DROP USER failed for %s")

+ func DeepCopyJson(v interface{}) interface

+ func GetRangeCutKey(c RangeCut) interface

+ func InitSystemVariables()

+ func IsDeferredType(t Type) bool

+ func IsDualTable(t Table) bool

+ func OrderedCuts(l, r RangeCut, typ Type) (RangeCut, RangeCut, error)

+ func ParseEWKBHeader(buf []byte) (srid uint32, bigEndian bool, typ uint32, err error)

+ func RangeCutIsBinding(c RangeCut) bool

+ type Above struct

+ func (Above) TypeAsLowerBound() RangeBoundType

+ func (Above) TypeAsUpperBound() RangeBoundType

+ func (a Above) Compare(c RangeCut, typ Type) (int, error)

+ func (a Above) String() string

+ type AboveAll struct

+ func (AboveAll) Compare(c RangeCut, typ Type) (int, error)

+ func (AboveAll) String() string

+ func (AboveAll) TypeAsLowerBound() RangeBoundType

+ func (AboveAll) TypeAsUpperBound() RangeBoundType

type Aggregation

+ Window func() *WindowDefinition

+ WithWindow func(window *WindowDefinition) (Aggregation, error)

+ type BackgroundThreads struct

+ func NewBackgroundThreads() *BackgroundThreads

+ func (bt *BackgroundThreads) Add(name string, f func(ctx context.Context)) error

+ func (bt *BackgroundThreads) Shutdown() error

type BaseSession

+ func NewBaseSessionWithClientServer(server string, client Client, id uint32) *BaseSession

+ func (s *BaseSession) SetClient(c Client)

+ func (s *BaseSession) SetConnectionId(id uint32)

+ type Below struct

+ func (Below) TypeAsLowerBound() RangeBoundType

+ func (Below) TypeAsUpperBound() RangeBoundType

+ func (b Below) Compare(c RangeCut, typ Type) (int, error)

+ func (b Below) String() string

+ type BelowAll struct

+ func (BelowAll) Compare(c RangeCut, typ Type) (int, error)

+ func (BelowAll) String() string

+ func (BelowAll) TypeAsLowerBound() RangeBoundType

+ func (BelowAll) TypeAsUpperBound() RangeBoundType

+ type BinaryNode interface

+ Left func() Node

+ Right func() Node

type Column

+ func (c *Column) Copy() *Column

type ColumnDefaultValue

+ func MustNewNullDefault(expr Expression, outType Type, representsLiteral bool, mayReturnNil bool) *ColumnDefaultValue

+ func NewUnresolvedColumnDefaultValue(expr string) *ColumnDefaultValue

+ func (e *ColumnDefaultValue) CheckType(ctx *Context) error

+ func (e *ColumnDefaultValue) DebugString() string

+ type ColumnExpressionType struct

+ Expression string

+ Type Type

type Context

+ func (c *Context) KillConnection(connID uint32) error

+ func (c *Context) LoadInfile(filename string) (io.ReadCloser, error)

+ func (c *Context) NewCtxWithClient(client Client) *Context

+ func (c Context) WithQuery(q string) *Context

type ContextOption

+ func WithServices(services Services) ContextOption

+ type Databaseable interface

+ Database func() string

type DecimalType

+ var InternalDecimalType DecimalType = decimalType{}

+ ConvertToNullDecimal func(v interface{}) (decimal.NullDecimal, error)

+ type DeferredType interface

+ IsDeferred func() bool

+ Name func() string

+ type ErrInsertIgnore struct

+ OffendingRow Row

+ func NewErrInsertIgnore(row Row) ErrInsertIgnore

+ func (e ErrInsertIgnore) Error() string

+ type Expression2 interface

+ Eval2 func(ctx *Context, row Row2) (Value, error)

+ Type2 func() Type2

+ type ExternalStoredProcedureDatabase interface

+ GetExternalStoredProcedures func(ctx *Context) ([]ExternalStoredProcedureDetails, error)

+ type ExternalStoredProcedureDetails struct

+ Function interface{}

+ Name string

+ Schema Schema

+ func (espd ExternalStoredProcedureDetails) Comment(dbName string) string

+ func (espd ExternalStoredProcedureDetails) FakeCreateProcedureStmt(dbName string) string

+ type FilteredIndex interface

+ HandledFilters func(filters []Expression) (handled []Expression)

type ForeignKeyConstraint

+ Database string

+ IsResolved bool

+ ParentColumns []string

+ ParentDatabase string

+ ParentTable string

+ Table string

+ func (f ForeignKeyConstraint) IsSelfReferential() bool

+ type ForeignKeyReferentialAction string

+ const ForeignKeyReferentialAction_Cascade

+ const ForeignKeyReferentialAction_DefaultAction

+ const ForeignKeyReferentialAction_NoAction

+ const ForeignKeyReferentialAction_Restrict

+ const ForeignKeyReferentialAction_SetDefault

+ const ForeignKeyReferentialAction_SetNull

type ForeignKeyTable

+ AddForeignKey func(ctx *Context, fk ForeignKeyConstraint) error

+ CreateIndexForForeignKey func(ctx *Context, indexName string, using IndexUsing, constraint IndexConstraint, ...) error

+ DropForeignKey func(ctx *Context, fkName string) error

+ GetDeclaredForeignKeys func(ctx *Context) ([]ForeignKeyConstraint, error)

+ GetForeignKeyUpdater func(ctx *Context) ForeignKeyUpdater

+ GetReferencedForeignKeys func(ctx *Context) ([]ForeignKeyConstraint, error)

+ UpdateForeignKey func(ctx *Context, fkName string, fk ForeignKeyConstraint) error

+ type ForeignKeyUpdater interface

type FunctionExpression

+ Description func() string

+ type GeometryType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t GeometryType) Compare(a any, b any) (int, error)

+ func (t GeometryType) Convert(v interface{}) (interface{}, error)

+ func (t GeometryType) Equals(otherType Type) (ok bool)

+ func (t GeometryType) GetSpatialTypeSRID() (uint32, bool)

+ func (t GeometryType) MatchSRID(v interface{}) error

+ func (t GeometryType) Promote() Type

+ func (t GeometryType) SQL(dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t GeometryType) SetSRID(v uint32) Type

+ func (t GeometryType) String() string

+ func (t GeometryType) Type() query.Type

+ func (t GeometryType) ValueType() reflect.Type

+ func (t GeometryType) Zero() interface{}

+ type GeometryValue interface

type Index

+ ColumnExpressionTypes func(ctx *Context) []ColumnExpressionType

+ NewLookup func(ctx *Context, ranges ...Range) (IndexLookup, error)

+ type IndexAddressable interface

+ WithIndexLookup func(IndexLookup) Table

+ type IndexBuilder struct

+ func NewIndexBuilder(ctx *Context, idx Index) *IndexBuilder

+ func (b *IndexBuilder) Build(ctx *Context) (IndexLookup, error)

+ func (b *IndexBuilder) Equals(ctx *Context, colExpr string, keys ...interface{}) *IndexBuilder

+ func (b *IndexBuilder) GreaterOrEqual(ctx *Context, colExpr string, key interface{}) *IndexBuilder

+ func (b *IndexBuilder) GreaterThan(ctx *Context, colExpr string, key interface{}) *IndexBuilder

+ func (b *IndexBuilder) IsNotNull(ctx *Context, colExpr string) *IndexBuilder

+ func (b *IndexBuilder) IsNull(ctx *Context, colExpr string) *IndexBuilder

+ func (b *IndexBuilder) LessOrEqual(ctx *Context, colExpr string, key interface{}) *IndexBuilder

+ func (b *IndexBuilder) LessThan(ctx *Context, colExpr string, key interface{}) *IndexBuilder

+ func (b *IndexBuilder) NotEquals(ctx *Context, colExpr string, key interface{}) *IndexBuilder

+ func (b *IndexBuilder) Ranges(ctx *Context) RangeCollection

type IndexLookup

+ Index func() Index

+ Ranges func() RangeCollection

+ type IndexOrder byte

+ const IndexOrderAsc

+ const IndexOrderDesc

+ const IndexOrderNone

type IndexRegistry

+ func (r *IndexRegistry) MatchingIndex(ctx *Context, db string, expr ...Expression) (index Index, prefixCount int, err error)

+ type LineString struct

+ Points []Point

+ SRID uint32

+ func WKBToLine(buf []byte, isBig bool, srid uint32) (LineString, error)

+ type LineStringType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t LineStringType) Compare(a interface{}, b interface{}) (int, error)

+ func (t LineStringType) Convert(v interface{}) (interface{}, error)

+ func (t LineStringType) Equals(otherType Type) bool

+ func (t LineStringType) GetSpatialTypeSRID() (uint32, bool)

+ func (t LineStringType) MatchSRID(v interface{}) error

+ func (t LineStringType) Promote() Type

+ func (t LineStringType) SQL(dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t LineStringType) SetSRID(v uint32) Type

+ func (t LineStringType) String() string

+ func (t LineStringType) Type() query.Type

+ func (t LineStringType) ValueType() reflect.Type

+ func (t LineStringType) Zero() interface{}

type MemoryManager

+ func (m *MemoryManager) NewRows2Cache() (Rows2Cache, DisposeFunc)

+ type MultiDatabaser interface

+ DatabaseProvider func() DatabaseProvider

+ WithDatabaseProvider func(DatabaseProvider) (Node, error)

type Node

+ CheckPrivileges func(ctx *Context, opChecker PrivilegedOperationChecker) bool

+ type Node2 interface

+ RowIter2 func(ctx *Context, f *RowFrame) (RowIter2, error)

+ type NullBound struct

+ func (NullBound) Compare(c RangeCut, typ Type) (int, error)

+ func (NullBound) String() string

+ func (NullBound) TypeAsLowerBound() RangeBoundType

+ func (NullBound) TypeAsUpperBound() RangeBoundType

+ type OrderedIndex interface

+ Order func() IndexOrder

+ type ParallelizedIndexAddressableTable interface

+ ShouldParallelizeAccess func() bool

type PartitionIter

+ func PartitionsToPartitionIter(partitions ...Partition) PartitionIter

+ type PersistableSession interface

+ GetPersistedValue func(k string) (interface{}, error)

+ PersistGlobal func(sysVarName string, value interface{}) error

+ RemoveAllPersistedGlobals func() error

+ RemovePersistedGlobal func(sysVarName string) error

+ type Point struct

+ SRID uint32

+ X float64

+ Y float64

+ func WKBToPoint(buf []byte, isBig bool, srid uint32) (Point, error)

+ type PointType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t PointType) Compare(a interface{}, b interface{}) (int, error)

+ func (t PointType) Convert(v interface{}) (interface{}, error)

+ func (t PointType) Equals(otherType Type) bool

+ func (t PointType) GetSpatialTypeSRID() (uint32, bool)

+ func (t PointType) MatchSRID(v interface{}) error

+ func (t PointType) Promote() Type

+ func (t PointType) SQL(dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t PointType) SetSRID(v uint32) Type

+ func (t PointType) String() string

+ func (t PointType) Type() query.Type

+ func (t PointType) ValueType() reflect.Type

+ func (t PointType) Zero() interface{}

+ type Polygon struct

+ Lines []LineString

+ SRID uint32

+ func WKBToPoly(buf []byte, isBig bool, srid uint32) (Polygon, error)

+ type PolygonType struct

+ DefinedSRID bool

+ SRID uint32

+ func (t PolygonType) Compare(a interface{}, b interface{}) (int, error)

+ func (t PolygonType) Convert(v interface{}) (interface{}, error)

+ func (t PolygonType) Equals(otherType Type) bool

+ func (t PolygonType) GetSpatialTypeSRID() (uint32, bool)

+ func (t PolygonType) MatchSRID(v interface{}) error

+ func (t PolygonType) Promote() Type

+ func (t PolygonType) SQL(dest []byte, v interface{}) (sqltypes.Value, error)

+ func (t PolygonType) SetSRID(v uint32) Type

+ func (t PolygonType) String() string

+ func (t PolygonType) Type() query.Type

+ func (t PolygonType) ValueType() reflect.Type

+ func (t PolygonType) Zero() interface{}

+ type PrimaryKeySchema struct

+ PkOrdinals []int

+ func NewPrimaryKeySchema(s Schema, pkOrds ...int) PrimaryKeySchema

+ func SchemaToPrimaryKeySchema(table Table, sch Schema) PrimaryKeySchema

+ type PrimaryKeySchemaTarget interface

+ WithPrimaryKeySchema func(schema PrimaryKeySchema) (Node, error)

+ type PrimaryKeyTable interface

+ PrimaryKeySchema func() PrimaryKeySchema

+ type PrivilegeType int

+ const PrivilegeType_Alter

+ const PrivilegeType_AlterRoutine

+ const PrivilegeType_Create

+ const PrivilegeType_CreateRole

+ const PrivilegeType_CreateRoutine

+ const PrivilegeType_CreateTablespace

+ const PrivilegeType_CreateTempTable

+ const PrivilegeType_CreateUser

+ const PrivilegeType_CreateView

+ const PrivilegeType_Delete

+ const PrivilegeType_Drop

+ const PrivilegeType_DropRole

+ const PrivilegeType_Event

+ const PrivilegeType_Execute

+ const PrivilegeType_File

+ const PrivilegeType_Grant

+ const PrivilegeType_Index

+ const PrivilegeType_Insert

+ const PrivilegeType_LockTables

+ const PrivilegeType_Process

+ const PrivilegeType_References

+ const PrivilegeType_Reload

+ const PrivilegeType_ReplicationClient

+ const PrivilegeType_ReplicationSlave

+ const PrivilegeType_Select

+ const PrivilegeType_ShowDB

+ const PrivilegeType_ShowView

+ const PrivilegeType_Shutdown

+ const PrivilegeType_Super

+ const PrivilegeType_Trigger

+ const PrivilegeType_Update

+ func PrivilegeTypeFromString(privilegeType string) (PrivilegeType, bool)

+ func (pt PrivilegeType) String() string

+ type PrivilegedOperation struct

+ Column string

+ Database string

+ Privileges []PrivilegeType

+ Table string

+ func NewPrivilegedOperation(dbName string, tblName string, colName string, privs ...PrivilegeType) PrivilegedOperation

+ type PrivilegedOperationChecker interface

+ UserHasPrivileges func(ctx *Context, operations ...PrivilegedOperation) bool

type ProjectedTable

+ Projections func() []string

+ WithProjections func(colNames []string) Table

+ type Range []RangeColumnExpr

+ func IntersectRanges(ranges ...Range) Range

+ func SortRanges(ranges ...Range) ([]Range, error)

+ func (rang Range) AsEmpty() Range

+ func (rang Range) Compare(otherRange Range) (int, error)

+ func (rang Range) Copy() Range

+ func (rang Range) DebugString() string

+ func (rang Range) Equals(otherRange Range) (bool, error)

+ func (rang Range) ExpressionByColumnName(idx Index, colExpr string) (RangeColumnExpr, bool)

+ func (rang Range) Intersect(otherRange Range) (Range, error)

+ func (rang Range) IsConnected(otherRange Range) (bool, error)

+ func (rang Range) IsSubsetOf(otherRange Range) (bool, error)

+ func (rang Range) IsSupersetOf(otherRange Range) (bool, error)

+ func (rang Range) Overlaps(otherRange Range) (bool, error)

+ func (rang Range) RemoveOverlap(otherRange Range) (RangeCollection, bool, error)

+ func (rang Range) String() string

+ func (rang Range) TryMerge(otherRange Range) (Range, bool, error)

+ type RangeBoundType int

+ const Closed

+ const Open

+ func (bt RangeBoundType) Inclusive() bool

+ type RangeCollection []Range

+ func RemoveOverlappingRanges(ranges ...Range) (RangeCollection, error)

+ func (ranges RangeCollection) DebugString() string

+ func (ranges RangeCollection) Equals(otherCollection RangeCollection) (bool, error)

+ func (ranges RangeCollection) Intersect(otherRanges RangeCollection) (RangeCollection, error)

+ func (ranges RangeCollection) String() string

+ type RangeColumnExpr struct

+ LowerBound RangeCut

+ Typ Type

+ UpperBound RangeCut

+ func AllRangeColumnExpr(typ Type) RangeColumnExpr

+ func ClosedRangeColumnExpr(lower, upper interface{}, typ Type) RangeColumnExpr

+ func CustomRangeColumnExpr(lower, upper interface{}, lowerBound, upperBound RangeBoundType, typ Type) RangeColumnExpr

+ func EmptyRangeColumnExpr(typ Type) RangeColumnExpr

+ func GreaterOrEqualRangeColumnExpr(lower interface{}, typ Type) RangeColumnExpr

+ func GreaterThanRangeColumnExpr(lower interface{}, typ Type) RangeColumnExpr

+ func LessOrEqualRangeColumnExpr(upper interface{}, typ Type) RangeColumnExpr

+ func LessThanRangeColumnExpr(upper interface{}, typ Type) RangeColumnExpr

+ func NotNullRangeColumnExpr(typ Type) RangeColumnExpr

+ func NullRangeColumnExpr() RangeColumnExpr

+ func OpenRangeColumnExpr(lower, upper interface{}, typ Type) RangeColumnExpr

+ func SimplifyRangeColumn(rces ...RangeColumnExpr) ([]RangeColumnExpr, error)

+ func (r RangeColumnExpr) DebugString() string

+ func (r RangeColumnExpr) Equals(other RangeColumnExpr) (bool, error)

+ func (r RangeColumnExpr) HasLowerBound() bool

+ func (r RangeColumnExpr) HasUpperBound() bool

+ func (r RangeColumnExpr) IsConnected(other RangeColumnExpr) (bool, error)

+ func (r RangeColumnExpr) IsEmpty() (bool, error)

+ func (r RangeColumnExpr) IsSubsetOf(other RangeColumnExpr) (bool, error)

+ func (r RangeColumnExpr) IsSupersetOf(other RangeColumnExpr) (bool, error)

+ func (r RangeColumnExpr) Overlaps(other RangeColumnExpr) (RangeColumnExpr, bool, error)

+ func (r RangeColumnExpr) RepresentsEquals() (bool, error)

+ func (r RangeColumnExpr) String() string

+ func (r RangeColumnExpr) Subtract(other RangeColumnExpr) ([]RangeColumnExpr, error)

+ func (r RangeColumnExpr) TryIntersect(other RangeColumnExpr) (RangeColumnExpr, bool, error)

+ func (r RangeColumnExpr) TryUnion(other RangeColumnExpr) (RangeColumnExpr, bool, error)

+ func (r RangeColumnExpr) Type() RangeType

+ type RangeColumnExprTree struct

+ func NewRangeColumnExprTree(initialRange Range, columnExprTypes []Type) (*RangeColumnExprTree, error)

+ func (tree *RangeColumnExprTree) FindConnections(rang Range, colExprIdx int) (RangeCollection, error)

+ func (tree *RangeColumnExprTree) GetRangeCollection() (RangeCollection, error)

+ func (tree *RangeColumnExprTree) Insert(rang Range) error

+ func (tree *RangeColumnExprTree) Iterator() *rangeTreeIter

+ func (tree *RangeColumnExprTree) Remove(rang Range) error

+ func (tree *RangeColumnExprTree) String() string

+ type RangeCut interface

+ Compare func(RangeCut, Type) (int, error)

+ String func() string

+ TypeAsLowerBound func() RangeBoundType

+ TypeAsUpperBound func() RangeBoundType

+ func GetRangeCutMax(typ Type, cuts ...RangeCut) (RangeCut, error)

+ func GetRangeCutMin(typ Type, cuts ...RangeCut) (RangeCut, error)

+ type RangeType int

+ type RewritableTable interface

+ RewriteInserter func(ctx *Context, oldSchema, newSchema PrimaryKeySchema, ...) (RowInserter, error)

+ ShouldRewriteTable func(ctx *Context, oldSchema, newSchema PrimaryKeySchema, ...) bool

type Row

+ func RowIter2ToRows(ctx *Context, sch Schema, i RowIter2) ([]Row, error)

+ type Row2 []Value

+ func (r Row2) GetField(i int) Value

+ func (r Row2) Len() int

+ type RowFrame struct

+ Types []querypb.Type

+ Values []ValueBytes

+ func NewRowFrame(vals ...Value) (f *RowFrame)

+ func (f *RowFrame) Append(vals ...Value)

+ func (f *RowFrame) AppendMany(types []querypb.Type, vals []ValueBytes)

+ func (f *RowFrame) Clear()

+ func (f *RowFrame) Recycle()

+ func (f *RowFrame) Row2() Row2

+ func (f *RowFrame) Row2Copy() Row2

+ type RowIter2 interface

+ Next2 func(ctx *Context, frame *RowFrame) error

+ type RowIterTypeSelector interface

+ IsNode2 func() bool

+ type Rows2Cache interface

+ Add2 func(Row2) error

+ Get2 func() []Row2

type Schema

+ func (s Schema) Copy() Schema

+ func (s Schema) IndexOfColName(column string) int

+ type SchemaTarget interface

+ TargetSchema func() Schema

+ WithTargetSchema func(Schema) (Node, error)

+ type Services struct

+ KillConnection func(connID uint32) error

+ LoadInfile func(filename string) (io.ReadCloser, error)

type Session

+ SetClient func(Client)

+ SetConnectionId func(connId uint32)

type SetType

+ BitsToString func(bits uint64) (string, error)

type SortField

+ Column2 Expression2

+ type SpatialColumnType interface

+ GetSpatialTypeSRID func() (uint32, bool)

+ MatchSRID func(interface{}) error

+ SetSRID func(uint32) Type

type SystemVariableScope

+ const SystemVariableScope_Persist

+ const SystemVariableScope_PersistOnly

+ const SystemVariableScope_ResetPersist

+ type Table2 interface

+ PartitionRows2 func(ctx *Context, part Partition) (RowIter2, error)

+ type TableFunction interface

+ FunctionName func() string

+ NewInstance func(ctx *Context, db Database, expressions []Expression) (Node, error)

+ type TableFunctionProvider interface

+ TableFunction func(ctx *Context, name string) (TableFunction, error)

type TableRowIter

+ func (i *TableRowIter) Next2(ctx *Context, frame *RowFrame) error

type TimeType

+ ConvertToTimespan func(v interface{}) (Timespan, error)

+ MicrosecondsToTimespan func(v int64) Timespan

+ type Timespan int64

+ func (t Timespan) Add(other Timespan) Timespan

+ func (t Timespan) AsMicroseconds() int64

+ func (t Timespan) AsTimeDuration() time.Duration

+ func (t Timespan) Compare(other Timespan) int

+ func (t Timespan) Equals(other Timespan) bool

+ func (t Timespan) Negate() Timespan

+ func (t Timespan) String() string

+ func (t Timespan) Subtract(other Timespan) Timespan

type TriggerDefinition

+ CreatedAt time.Time

+ type TupleType []Type

+ func (t TupleType) Compare(a, b interface{}) (int, error)

+ func (t TupleType) Convert(v interface{}) (interface{}, error)

+ func (t TupleType) Equals(otherType Type) bool

+ func (t TupleType) MustConvert(v interface{}) interface{}

+ func (t TupleType) Promote() Type

+ func (t TupleType) SQL([]byte, interface{}) (sqltypes.Value, error)

+ func (t TupleType) String() string

+ func (t TupleType) Type() query.Type

+ func (t TupleType) ValueType() reflect.Type

+ func (t TupleType) Zero() interface{}

type Type

+ func GetColExprTypes(ranges []Range) []Type

+ func NewDeferredType(name string) Type

+ Equals func(otherType Type) bool

+ ValueType func() reflect.Type

+ type Type2 interface

+ Compare2 func(Value, Value) (int, error)

+ Convert2 func(Value) (Value, error)

+ SQL2 func(Value) (sqltypes.Value, error)

+ Zero2 func() Value

+ type UnaryNode interface

+ Child func() Node

+ type UnresolvedColumnDefault struct

+ func (u UnresolvedColumnDefault) Children() []Expression

+ func (u UnresolvedColumnDefault) Eval(ctx *Context, row Row) (interface{}, error)

+ func (u UnresolvedColumnDefault) IsNullable() bool

+ func (u UnresolvedColumnDefault) Resolved() bool

+ func (u UnresolvedColumnDefault) String() string

+ func (u UnresolvedColumnDefault) Type() Type

+ func (u UnresolvedColumnDefault) WithChildren(children ...Expression) (Expression, error)

+ type UnresolvedTable interface

+ AsOf func() Expression

+ Database func() string

+ WithAsOf func(asOf Expression) (Node, error)

+ type UnsupportedFunctionStub interface

+ IsUnsupported func() bool

+ type Value struct

+ Typ querypb.Type

+ Val ValueBytes

+ func ConvertToValue(v interface{}) (Value, error)

+ func (v Value) IsNull() bool

+ type ValueBytes []byte

+ type WindowAdaptableExpression interface

+ NewWindowFunction func() (WindowFunction, error)

+ type WindowBuffer []Row

+ type WindowDefinition struct

+ Frame WindowFrame

+ Name string

+ OrderBy SortFields

+ PartitionBy []Expression

+ Ref string

+ func NewWindowDefinition(partitionBy []Expression, orderBy SortFields, frame WindowFrame, ...) *WindowDefinition

+ func (w *WindowDefinition) DebugString() string

+ func (w *WindowDefinition) FromExpressions(children []Expression) (*WindowDefinition, error)

+ func (w *WindowDefinition) PartitionId() (uint64, error)

+ func (w *WindowDefinition) String() string

+ func (w *WindowDefinition) ToExpressions() []Expression

+ type WindowFrame interface

+ EndCurrentRow func() bool

+ EndNFollowing func() Expression

+ EndNPreceding func() Expression

+ NewFramer func(*WindowDefinition) (WindowFramer, error)

+ StartCurrentRow func() bool

+ StartNFollowing func() Expression

+ StartNPreceding func() Expression

+ UnboundedFollowing func() bool

+ UnboundedPreceding func() bool

+ type WindowFramer interface

+ FirstIdx func() int

+ Interval func() (WindowInterval, error)

+ LastIdx func() int

+ NewFramer func(WindowInterval) (WindowFramer, error)

+ Next func(*Context, WindowBuffer) (WindowInterval, error)

+ type WindowFunction interface

+ Compute func(*Context, WindowInterval, WindowBuffer) interface{}

+ DefaultFramer func() WindowFramer

+ StartPartition func(*Context, WindowInterval, WindowBuffer) error

+ WithWindow func(w *WindowDefinition) (WindowFunction, error)

+ type WindowInterval struct

+ End int

+ Start int

+ type WrappedInsertError struct

+ Cause error

+ OffendingRow Row

+ func NewWrappedInsertError(r Row, err error) WrappedInsertError

+ func (w WrappedInsertError) Error() string

v0.11.0

Oct 20, 2021

Changes in this version

+ var Collations = map[string]Collation

+ var ErrCantDropFieldOrKey = errors.NewKind("error: can't drop '%s'; check that column/key exists")

+ var ErrCantDropIndex = errors.NewKind("error: can't drop index '%s': needed in a foreign key constraint")

+ var ErrForeignKeyNotResolved = errors.NewKind(...)

+ var ErrImmutableDatabaseProvider = errors.NewKind("error: can't modify database databaseProvider")

+ var ErrInvalidOperandColumns = errors.NewKind("operand should have %d columns, but has %d")

+ var ErrInvalidValue = errors.NewKind(`error: '%v' is not a valid value for '%v'`)

+ var ErrInvalidValueType = errors.NewKind(`error: '%T' is not a valid value type for '%v'`)

+ var ErrKeyColumnDoesNotExist = errors.NewKind("error: key column '%s' doesn't exist in table")

+ var ErrMultiplePrimaryKeysDefined = errors.NewKind("error: Multiple primary keys defined")

+ var ErrReadOnlyTransaction = errors.NewKind("cannot execute statement in a READ ONLY transaction")

+ var ErrTableCopyingNotSupported = errors.NewKind("error: Table copying not supported")

+ var ErrTemporaryTableNotSupported = errors.NewKind("database does not support temporary tables")

+ var ErrViewDoesNotExist = errors.NewKind("the view %s.%s does not exist")

+ var ErrWrongAutoKey = errors.NewKind(...)

+ func Dispose(i interface{})

+ func ErrIfMismatchedColumns(t1, t2 Type) error

+ func ErrIfMismatchedColumnsInTuple(t1, t2 Type) error

+ func IsKeyless(s Schema) bool

+ func IsOkResultSchema(schema Schema) bool

+ type AggregationBuffer interface

+ Eval func(*Context) (interface{}, error)

+ Update func(ctx *Context, row Row) error

type AutoIncrementTable

+ GetNextAutoIncrementValue func(ctx *Context, insertVal interface{}) (interface{}, error)

+ PeekNextAutoIncrementValue func(*Context) (interface{}, error)

type BaseSession

+ func (s *BaseSession) GetIndexRegistry() *IndexRegistry

+ func (s *BaseSession) GetLogger() *logrus.Entry

+ func (s *BaseSession) GetViewRegistry() *ViewRegistry

+ func (s *BaseSession) SetIndexRegistry(reg *IndexRegistry)

+ func (s *BaseSession) SetLogger(logger *logrus.Entry)

+ func (s *BaseSession) SetViewRegistry(reg *ViewRegistry)

type Catalog

+ CreateDatabase func(ctx *Context, dbName string) error

+ Function func(name string) (Function, error)

+ RegisterFunction func(fns ...Function)

type Client

+ Capabilities uint32

type Collation

+ CharSet CharacterSet

+ Compare func(as, bs string) int

+ LikeMatcher func(likeStr string) (regex.DisposableMatcher, error)

+ Name string

+ func (c Collation) Equals(other Collation) bool

type Context

+ ProcessList ProcessList

+ func (c *Context) NewErrgroup() (*errgroup.Group, *Context)

type ContextOption

+ func WithProcessList(p ProcessList) ContextOption

+ type DatabaseProvider interface

+ AllDatabases func() []Database

+ Database func(name string) (Database, error)

+ HasDatabase func(name string) bool

+ func NewDatabaseProvider(dbs ...Database) DatabaseProvider

+ type EmptyProcessList struct

+ func (e EmptyProcessList) AddPartitionProgress(pid uint64, tableName, partitionName string, total int64)

+ func (e EmptyProcessList) AddProcess(ctx *Context, query string) (*Context, error)

+ func (e EmptyProcessList) AddTableProgress(pid uint64, name string, total int64)

+ func (e EmptyProcessList) Done(pid uint64)

+ func (e EmptyProcessList) Kill(connID uint32)

+ func (e EmptyProcessList) Processes() []Process

+ func (e EmptyProcessList) RemovePartitionProgress(pid uint64, tableName, partitionName string)

+ func (e EmptyProcessList) RemoveTableProgress(pid uint64, name string)

+ func (e EmptyProcessList) UpdatePartitionProgress(pid uint64, tableName, partitionName string, delta int64)

+ func (e EmptyProcessList) UpdateTableProgress(pid uint64, name string, delta int64)

type Function

+ FunctionName func() string

type Function0

+ func (fn Function0) FunctionName() string

type Function1

+ func (fn Function1) FunctionName() string

type Function2

+ func (fn Function2) FunctionName() string

type Function3

+ func (fn Function3) FunctionName() string

type Function4

+ func (fn Function4) FunctionName() string

type Function5

+ func (fn Function5) FunctionName() string

type Function6

+ func (fn Function6) FunctionName() string

type Function7

+ func (fn Function7) FunctionName() string

type FunctionN

+ func (fn FunctionN) FunctionName() string

+ type FunctionProvider interface

+ Function func(name string) (Function, error)

type IndexConstraint

+ const IndexConstraint_Primary

+ type LikeMatcher interface

+ CreateMatcher func(likeStr string) (regex.DisposableMatcher, error)

type MemoryManager

+ func (m *MemoryManager) NumCaches() int

+ type MutableDatabaseProvider interface

+ CreateDatabase func(ctx *Context, name string) error

+ DropDatabase func(ctx *Context, name string) error

+ type PrimaryKeyAlterableTable interface

+ CreatePrimaryKey func(ctx *Context, columns []IndexColumn) error

+ DropPrimaryKey func(ctx *Context) error

+ type ReadOnlyDatabase interface

+ IsReadOnly func() bool

type Schema

+ func (s Schema) HasAutoIncrement() bool

type Session

+ GetIndexRegistry func() *IndexRegistry

+ GetLogger func() *logrus.Entry

+ GetViewRegistry func() *ViewRegistry

+ SetIndexRegistry func(*IndexRegistry)

+ SetLogger func(*logrus.Entry)

+ SetViewRegistry func(*ViewRegistry)

+ type TableCopierDatabase interface

+ CopyTableData func(ctx *Context, sourceTable string, destinationTable string) (uint64, error)

+ type TemporaryTable interface

+ IsTemporary func() bool

+ type TemporaryTableCreator interface

+ CreateTemporaryTable func(ctx *Context, name string, schema Schema) error

+ type TemporaryTableDatabase interface

+ GetAllTemporaryTables func(ctx *Context) ([]Table, error)

type Transaction

+ IsReadOnly func() bool

+ type TransactionCharacteristic int

+ const ReadOnly

+ const ReadWrite

+ type ViewDatabase interface

+ AllViews func(ctx *Context) ([]ViewDefinition, error)

+ CreateView func(ctx *Context, name string, selectStatement string) error

+ DropView func(ctx *Context, name string) error

+ GetView func(ctx *Context, viewName string) (string, bool, error)

+ type ViewDefinition struct

+ Name string

+ TextDefinition string

v0.10.0

Jun 2, 2021

Changes in this version

+ var ErrAlterTableNotSupported = errors.NewKind("table %s cannot be altered")

+ var ErrCheckConstraintViolated = errors.NewKind(ErrCheckConstraintViolatedFmtStr)

+ var ErrCheckConstraintViolatedFmtStr = "Check constraint %q violated"

+ var ErrDuplicateEntry = errors.NewKind("Duplicate entry for key '%s'")

+ var ErrExpectedSingleRow = errors.NewKind("the subquery returned more than 1 row")

+ var ErrForeignKeyChildViolation = errors.NewKind(...)

+ var ErrForeignKeyColumnCountMismatch = errors.NewKind("the foreign key must reference an equivalent number of columns")

+ var ErrForeignKeyParentViolation = errors.NewKind(...)

+ var ErrInsertIntoNonNullableDefaultNullColumn = errors.NewKind("Field '%s' doesn't have a default value")

+ var ErrInsertIntoNonNullableProvidedNull = errors.NewKind("column name '%v' is non-nullable but attempted to set a value of null")

+ var ErrInvalidArgument = errors.NewKind("Incorrect arguments to %s")

+ var ErrInvalidSyntax = errors.NewKind("Invalid syntax: %s")

+ var ErrInvalidSystemVariableValue = errors.NewKind("Variable '%s' can't be set to the value of '%v'")

+ var ErrPartitionNotFound = errors.NewKind("partition not found %q")

+ var ErrSavepointDoesNotExist = errors.NewKind("SAVEPOINT %s does not exist")

+ var ErrSubqueryMultipleColumns = errors.NewKind("operand contains more than one column")

+ var ErrSystemVariableCodeFail = errors.NewKind("unable to encode/decode value '%v' for '%s'")

+ var ErrSystemVariableGlobalOnly = errors.NewKind(`Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL`)

+ var ErrSystemVariableReadOnly = errors.NewKind(`Variable '%s' is a read only variable`)

+ var ErrSystemVariableSessionOnly = errors.NewKind(`Variable '%s' is a SESSION variable and can't be used with SET GLOBAL`)

+ var ErrUnknownConstraint = errors.NewKind("Constraint %q does not exist")

+ var ErrUnsupportedFeature = errors.NewKind("unsupported feature: %s")

+ var ErrUserVariableNoDefault = errors.NewKind(`User variable '%s' does not have a default value`)

+ var SystemVariables = &globalSystemVariables

+ func IsFalse(val interface{}) bool

+ func IsTrue(val interface{}) bool

+ func NewUniqueKeyErr(keyStr string, isPK bool, existing Row) error

type BaseSession

+ func (s *BaseSession) GetAllSessionVariables() map[string]interface{}

+ func (s *BaseSession) GetIgnoreAutoCommit() bool

+ func (s *BaseSession) GetSessionVariable(ctx *Context, sysVarName string) (interface{}, error)

+ func (s *BaseSession) GetTransaction() Transaction

+ func (s *BaseSession) GetUserVariable(ctx *Context, varName string) (Type, interface{}, error)

+ func (s *BaseSession) SetIgnoreAutoCommit(ignore bool)

+ func (s *BaseSession) SetSessionVariable(ctx *Context, sysVarName string, value interface{}) error

+ func (s *BaseSession) SetTransaction(tx Transaction)

+ func (s *BaseSession) SetUserVariable(ctx *Context, varName string, value interface{}) error

type CheckConstraint

+ func (c CheckConstraint) DebugString() string

+ type CheckConstraints []*CheckConstraint

+ func (checks CheckConstraints) FromExpressions(exprs []Expression) (CheckConstraints, error)

+ func (checks CheckConstraints) ToExpressions() []Expression

type CheckDefinition

+ CheckExpression string

+ Enforced bool

type Column

+ func (c *Column) DebugString() string

type ForeignKeyConstraint

+ func (f *ForeignKeyConstraint) DebugString() string

type Index

+ IsGenerated func() bool

type Session

+ GetAllSessionVariables func() map[string]interface{}

+ GetIgnoreAutoCommit func() bool

+ GetSessionVariable func(ctx *Context, sysVarName string) (interface{}, error)

+ GetTransaction func() Transaction

+ GetUserVariable func(ctx *Context, varName string) (Type, interface{}, error)

+ SetIgnoreAutoCommit func(ignore bool)

+ SetSessionVariable func(ctx *Context, sysVarName string, value interface{}) error

+ SetTransaction func(tx Transaction)

+ SetUserVariable func(ctx *Context, varName string, value interface{}) error

+ type SystemVariable struct

+ Default interface{}

+ Dynamic bool

+ Name string

+ Scope SystemVariableScope

+ SetVarHintApplies bool

+ Type Type

+ type SystemVariableScope byte

+ const SystemVariableScope_Both

+ const SystemVariableScope_Global

+ const SystemVariableScope_Session

+ func (s SystemVariableScope) String() string

+ type SystemVariableType interface

+ DecodeValue func(string) (interface{}, error)

+ EncodeValue func(interface{}) (string, error)

+ func NewSystemBoolType(varName string) SystemVariableType

+ func NewSystemDoubleType(varName string, lowerbound, upperbound float64) SystemVariableType

+ func NewSystemEnumType(varName string, values ...string) SystemVariableType

+ func NewSystemIntType(varName string, lowerbound, upperbound int64, negativeOne bool) SystemVariableType

+ func NewSystemSetType(varName string, values ...string) SystemVariableType

+ func NewSystemStringType(varName string) SystemVariableType

+ func NewSystemUintType(varName string, lowerbound, upperbound uint64) SystemVariableType

+ type TableEditor interface

+ DiscardChanges func(ctx *Context, errorEncountered error) error

+ StatementBegin func(ctx *Context)

+ StatementComplete func(ctx *Context) error

+ type Transaction interface

+ type TransactionDatabase interface

+ CommitTransaction func(ctx *Context, tx Transaction) error

+ CreateSavepoint func(ctx *Context, transaction Transaction, name string) error

+ ReleaseSavepoint func(ctx *Context, transaction Transaction, name string) error

+ Rollback func(ctx *Context, transaction Transaction) error

+ RollbackToSavepoint func(ctx *Context, transaction Transaction, name string) error

+ StartTransaction func(ctx *Context) (Transaction, error)

type Type

+ func ApproximateTypeFromValue(val interface{}) Type

+ type UniqueKeyError struct

+ Existing Row

+ IsPK bool

+ func (ue UniqueKeyError) Error() string

type WindowAggregation

+ Window func() *Window

v0.9.0

Apr 2, 2021

Changes in this version

+ const FoundRows

+ const LastInsertId

+ const RowCount

+ var ErrAmbiguousColumnInOrderBy = errors.NewKind("Column %q in order clause is ambiguous")

+ var ErrCallIncorrectParameterCount = errors.NewKind("`%s` expected `%d` parameters but got `%d`")

+ var ErrCannotCreateDatabaseExists = errors.NewKind("can't create database %s; database exists")

+ var ErrCannotDropDatabaseDoesntExist = errors.NewKind("can't drop database %s; database doesn't exist")

+ var ErrColumnCountMismatch = errors.NewKind(...)

+ var ErrConvertingToJSON = errors.NewKind("value %v is not valid JSON")

+ var ErrDeclareConditionDuplicate = errors.NewKind("duplicate condition '%s'")

+ var ErrDeclareConditionNotFound = errors.NewKind("condition %s does not exist")

+ var ErrDeclareOrderInvalid = errors.NewKind("DECLARE may only exist at the beginning of a BEGIN/END block")

+ var ErrInvalidColTypeDefinition = errors.NewKind("column %s type definition is invalid: %s")

+ var ErrInvalidConstraintFunctionsNotSupported = errors.NewKind("Invalid constraint expression, functions not supported: %s")

+ var ErrInvalidConstraintSubqueryNotSupported = errors.NewKind("Invalid constraint expression, sub-queries not supported: %s")

+ var ErrInvalidJSONText = errors.NewKind("Invalid JSON text: %s")

+ var ErrJSONObjectAggNullKey = errors.NewKind("JSON documents may not contain NULL member names")

+ var ErrLoadDataCannotOpen = errors.NewKind("LOAD DATA is unable to open file: %s")

+ var ErrLoadDataCharacterLength = errors.NewKind("%s must be 1 character long")

+ var ErrNoAutoIncrementCol = fmt.Errorf("this table has no AUTO_INCREMENT columns")

+ var ErrProcedureCreateStatementInvalid = errors.NewKind(`Invalid CREATE PROCEDURE statement: %s`)

+ var ErrProcedureDuplicateParameterName = errors.NewKind("duplicate parameter name `%s` on stored procedure `%s`")

+ var ErrProcedureInvalidBodyStatement = errors.NewKind("`%s` statements are invalid inside of stored procedures")

+ var ErrProcedureRecursiveCall = errors.NewKind("recursive CALL on stored procedure `%s`")

+ var ErrSecureFileDirNotSet = errors.NewKind("secure_file_priv needs to be set to a directory")

+ var ErrSignalOnlySqlState = errors.NewKind("SIGNAL/RESIGNAL can only use a condition defined with SQLSTATE")

+ var ErrStoredProcedureAlreadyExists = errors.NewKind(`stored procedure "%s" already exists`)

+ var ErrStoredProcedureDoesNotExist = errors.NewKind(`stored procedure "%s" does not exist`)

+ var ErrStoredProceduresNotSupported = errors.NewKind(`database "%s" doesn't support stored procedures`)

+ var ErrSyntaxError = errors.NewKind("%s")

+ var ErrUnableSort = errors.NewKind("unable to sort")

+ var ErrUuidUnableToParse = errors.NewKind("unable to parse '%s' to UUID: %s")

+ var SupportedCharsets = []CharacterSet

+ var SupportedEngines = []Engine

+ func CastSQLError(err error) (*mysql.SQLError, bool)

+ func GetTmpdirSessionVar() string

+ func IsJSON(t Type) bool

+ func IsOkResult(row Row) bool

+ func MustConvert(val interface{}, err error) interface

type BaseSession

+ func (s *BaseSession) GetLastQueryInfo(key string) int64

+ func (s *BaseSession) GetQueriedDatabase() string

+ func (s *BaseSession) SetLastQueryInfo(key string, value int64)

+ func (s *BaseSession) SetQueriedDatabase(dbName string)

type Catalog

+ func (c *Catalog) RemoveDatabase(dbName string)

+ type CheckAlterableTable interface

+ CreateCheck func(ctx *Context, check *CheckDefinition) error

+ DropCheck func(ctx *Context, chName string) error

+ type CheckConstraint struct

+ Enforced bool

+ Expr Expression

+ Name string

+ type CheckDefinition struct

+ AlterStatement string

+ Name string

+ type CheckTable interface

+ GetChecks func(ctx *Context) ([]CheckDefinition, error)

+ type CommentedNode interface

+ Comment func() string

+ WithComment func(string) Node

type Databases

+ func (d *Databases) Delete(dbName string)

+ type Engine struct

+ Name string

+ func (e Engine) Comment() string

+ func (e Engine) Savepoints() string

+ func (e Engine) String() string

+ func (e Engine) Support() string

+ func (e Engine) Transactions() string

+ func (e Engine) XA() string

type Expression

+ func NillaryWithChildren(expr Expression, children ...Expression) (Expression, error)

type Function

+ NewInstance func([]Expression) (Expression, error)

type Function0

+ func (fn Function0) NewInstance(args []Expression) (Expression, error)

type Function1

+ func (fn Function1) NewInstance(args []Expression) (Expression, error)

type Function2

+ func (fn Function2) NewInstance(args []Expression) (Expression, error)

type Function3

+ func (fn Function3) NewInstance(args []Expression) (Expression, error)

type Function4

+ func (fn Function4) NewInstance(args []Expression) (Expression, error)

type Function5

+ func (fn Function5) NewInstance(args []Expression) (Expression, error)

type Function6

+ func (fn Function6) NewInstance(args []Expression) (Expression, error)

type Function7

+ func (fn Function7) NewInstance(args []Expression) (Expression, error)

type FunctionN

+ func (fn FunctionN) NewInstance(args []Expression) (Expression, error)

+ type JSONDocument struct

+ Val interface{}

+ func MustJSON(s string) JSONDocument

+ func (doc JSONDocument) Compare(ctx *Context, v JSONValue) (int, error)

+ func (doc JSONDocument) Contains(ctx *Context, path string) (ok bool, err error)

+ func (doc JSONDocument) Extract(ctx *Context, path string) (JSONValue, error)

+ func (doc JSONDocument) Keys(ctx *Context, path string) (val JSONValue, err error)

+ func (doc JSONDocument) Overlaps(ctx *Context, val SearchableJSONValue) (ok bool, err error)

+ func (doc JSONDocument) Search(ctx *Context) (path string, err error)

+ func (doc JSONDocument) ToString(_ *Context) (string, error)

+ func (doc JSONDocument) Unmarshall(_ *Context) (JSONDocument, error)

+ type JSONValue interface

+ Compare func(ctx *Context, v JSONValue) (cmp int, err error)

+ ToString func(ctx *Context) (string, error)

+ Unmarshall func(ctx *Context) (val JSONDocument, err error)

+ func ConcatenateJSONValues(ctx *Context, vals ...JSONValue) (JSONValue, error)

+ type NullOrdering byte

+ const NullsFirst

+ const NullsLast

type OkResult

+ func GetOkResult(row Row) OkResult

+ type SearchableJSONValue interface

+ Contains func(ctx *Context, path string) (ok bool, err error)

+ Extract func(ctx *Context, path string) (val JSONValue, err error)

+ Keys func(ctx *Context, path string) (val JSONValue, err error)

+ Overlaps func(ctx *Context, val SearchableJSONValue) (ok bool, err error)

+ Search func(ctx *Context) (path string, err error)

type Session

+ GetLastQueryInfo func(key string) int64

+ GetQueriedDatabase func() string

+ SetLastQueryInfo func(key string, value int64)

+ SetQueriedDatabase func(dbName string)

+ type SortField struct

+ Column Expression

+ NullOrdering NullOrdering

+ Order SortOrder

+ func (s SortField) DebugString() string

+ func (s SortField) String() string

+ type SortFields []SortField

+ func (sf SortFields) FromExpressions(exprs []Expression) SortFields

+ func (sf SortFields) ToExpressions() []Expression

+ type SortOrder byte

+ const Ascending

+ const Descending

+ func (s SortOrder) String() string

type StatisticsTable

+ DataLength func(ctx *Context) (uint64, error)

+ type StoredProcedureDatabase interface

+ DropStoredProcedure func(ctx *Context, name string) error

+ GetStoredProcedures func(ctx *Context) ([]StoredProcedureDetails, error)

+ SaveStoredProcedure func(ctx *Context, spd StoredProcedureDetails) error

+ type StoredProcedureDetails struct

+ CreateStatement string

+ CreatedAt time.Time

+ ModifiedAt time.Time

+ Name string

+ type Window struct

+ OrderBy SortFields

+ PartitionBy []Expression

+ func NewWindow(partitionBy []Expression, orderBy []SortField) *Window

+ func (w *Window) DebugString() string

+ func (w *Window) FromExpressions(children []Expression) (*Window, error)

+ func (w *Window) String() string

+ func (w *Window) ToExpressions() []Expression

+ type WindowAggregation interface

+ Add func(ctx *Context, buffer, row Row) error

+ EvalRow func(i int, buffer Row) (interface{}, error)

+ Finish func(ctx *Context, buffer Row) error

+ NewBuffer func() Row

+ WithWindow func(window *Window) (WindowAggregation, error)

v0.8.0

Feb 1, 2021

Changes in this version

+ const AutoCommitSessionVar

+ const BitTypeMaxBits

+ const BitTypeMinBits

+ const CharacterSet_armscii8

+ const CharacterSet_ascii

+ const CharacterSet_big5

+ const CharacterSet_binary

+ const CharacterSet_cp1250

+ const CharacterSet_cp1251

+ const CharacterSet_cp1256

+ const CharacterSet_cp1257

+ const CharacterSet_cp850

+ const CharacterSet_cp852

+ const CharacterSet_cp866

+ const CharacterSet_cp932

+ const CharacterSet_dec8

+ const CharacterSet_eucjpms

+ const CharacterSet_euckr

+ const CharacterSet_gb18030

+ const CharacterSet_gb2312

+ const CharacterSet_gbk

+ const CharacterSet_geostd8

+ const CharacterSet_greek

+ const CharacterSet_hebrew

+ const CharacterSet_hp8

+ const CharacterSet_keybcs2

+ const CharacterSet_koi8r

+ const CharacterSet_koi8u

+ const CharacterSet_latin1

+ const CharacterSet_latin2

+ const CharacterSet_latin5

+ const CharacterSet_latin7

+ const CharacterSet_macce

+ const CharacterSet_macroman

+ const CharacterSet_sjis

+ const CharacterSet_swe7

+ const CharacterSet_tis620

+ const CharacterSet_ucs2

+ const CharacterSet_ujis

+ const CharacterSet_utf16

+ const CharacterSet_utf16le

+ const CharacterSet_utf32

+ const CharacterSet_utf8

+ const CharacterSet_utf8mb3

+ const CharacterSet_utf8mb4

+ const ChecksumKey

+ const Collation_Default

+ const Collation_armscii8_bin

+ const Collation_armscii8_general_ci

+ const Collation_ascii_bin

+ const Collation_ascii_general_ci

+ const Collation_big5_bin

+ const Collation_big5_chinese_ci

+ const Collation_binary

+ const Collation_cp1250_bin

+ const Collation_cp1250_croatian_ci

+ const Collation_cp1250_czech_cs

+ const Collation_cp1250_general_ci

+ const Collation_cp1250_polish_ci

+ const Collation_cp1251_bin

+ const Collation_cp1251_bulgarian_ci

+ const Collation_cp1251_general_ci

+ const Collation_cp1251_general_cs

+ const Collation_cp1251_ukrainian_ci

+ const Collation_cp1256_bin

+ const Collation_cp1256_general_ci

+ const Collation_cp1257_bin

+ const Collation_cp1257_general_ci

+ const Collation_cp1257_lithuanian_ci

+ const Collation_cp850_bin

+ const Collation_cp850_general_ci

+ const Collation_cp852_bin

+ const Collation_cp852_general_ci

+ const Collation_cp866_bin

+ const Collation_cp866_general_ci

+ const Collation_cp932_bin

+ const Collation_cp932_japanese_ci

+ const Collation_dec8_bin

+ const Collation_dec8_swedish_ci

+ const Collation_eucjpms_bin

+ const Collation_eucjpms_japanese_ci

+ const Collation_euckr_bin

+ const Collation_euckr_korean_ci

+ const Collation_gb18030_bin

+ const Collation_gb18030_chinese_ci

+ const Collation_gb18030_unicode_520_ci

+ const Collation_gb2312_bin

+ const Collation_gb2312_chinese_ci

+ const Collation_gbk_bin

+ const Collation_gbk_chinese_ci

+ const Collation_geostd8_bin

+ const Collation_geostd8_general_ci

+ const Collation_greek_bin

+ const Collation_greek_general_ci

+ const Collation_hebrew_bin

+ const Collation_hebrew_general_ci

+ const Collation_hp8_bin

+ const Collation_hp8_english_ci

+ const Collation_keybcs2_bin

+ const Collation_keybcs2_general_ci

+ const Collation_koi8r_bin

+ const Collation_koi8r_general_ci

+ const Collation_koi8u_bin

+ const Collation_koi8u_general_ci

+ const Collation_latin1_bin

+ const Collation_latin1_danish_ci

+ const Collation_latin1_general_ci

+ const Collation_latin1_general_cs

+ const Collation_latin1_german1_ci

+ const Collation_latin1_german2_ci

+ const Collation_latin1_spanish_ci

+ const Collation_latin1_swedish_ci

+ const Collation_latin2_bin

+ const Collation_latin2_croatian_ci

+ const Collation_latin2_czech_cs

+ const Collation_latin2_general_ci

+ const Collation_latin2_hungarian_ci

+ const Collation_latin5_bin

+ const Collation_latin5_turkish_ci

+ const Collation_latin7_bin

+ const Collation_latin7_estonian_cs

+ const Collation_latin7_general_ci

+ const Collation_latin7_general_cs

+ const Collation_macce_bin

+ const Collation_macce_general_ci

+ const Collation_macroman_bin

+ const Collation_macroman_general_ci

+ const Collation_sjis_bin

+ const Collation_sjis_japanese_ci

+ const Collation_swe7_bin

+ const Collation_swe7_swedish_ci

+ const Collation_tis620_bin

+ const Collation_tis620_thai_ci

+ const Collation_ucs2_bin

+ const Collation_ucs2_croatian_ci

+ const Collation_ucs2_czech_ci

+ const Collation_ucs2_danish_ci

+ const Collation_ucs2_esperanto_ci

+ const Collation_ucs2_estonian_ci

+ const Collation_ucs2_general_ci

+ const Collation_ucs2_general_mysql500_ci

+ const Collation_ucs2_german2_ci

+ const Collation_ucs2_hungarian_ci

+ const Collation_ucs2_icelandic_ci

+ const Collation_ucs2_latvian_ci

+ const Collation_ucs2_lithuanian_ci

+ const Collation_ucs2_persian_ci

+ const Collation_ucs2_polish_ci

+ const Collation_ucs2_roman_ci

+ const Collation_ucs2_romanian_ci

+ const Collation_ucs2_sinhala_ci

+ const Collation_ucs2_slovak_ci

+ const Collation_ucs2_slovenian_ci

+ const Collation_ucs2_spanish2_ci

+ const Collation_ucs2_spanish_ci

+ const Collation_ucs2_swedish_ci

+ const Collation_ucs2_turkish_ci

+ const Collation_ucs2_unicode_520_ci

+ const Collation_ucs2_unicode_ci

+ const Collation_ucs2_vietnamese_ci

+ const Collation_ujis_bin

+ const Collation_ujis_japanese_ci

+ const Collation_utf16_bin

+ const Collation_utf16_croatian_ci

+ const Collation_utf16_czech_ci

+ const Collation_utf16_danish_ci

+ const Collation_utf16_esperanto_ci

+ const Collation_utf16_estonian_ci

+ const Collation_utf16_general_ci

+ const Collation_utf16_german2_ci

+ const Collation_utf16_hungarian_ci

+ const Collation_utf16_icelandic_ci

+ const Collation_utf16_latvian_ci

+ const Collation_utf16_lithuanian_ci

+ const Collation_utf16_persian_ci

+ const Collation_utf16_polish_ci

+ const Collation_utf16_roman_ci

+ const Collation_utf16_romanian_ci

+ const Collation_utf16_sinhala_ci

+ const Collation_utf16_slovak_ci

+ const Collation_utf16_slovenian_ci

+ const Collation_utf16_spanish2_ci

+ const Collation_utf16_spanish_ci

+ const Collation_utf16_swedish_ci

+ const Collation_utf16_turkish_ci

+ const Collation_utf16_unicode_520_ci

+ const Collation_utf16_unicode_ci

+ const Collation_utf16_vietnamese_ci

+ const Collation_utf16le_bin

+ const Collation_utf16le_general_ci

+ const Collation_utf32_bin

+ const Collation_utf32_croatian_ci

+ const Collation_utf32_czech_ci

+ const Collation_utf32_danish_ci

+ const Collation_utf32_esperanto_ci

+ const Collation_utf32_estonian_ci

+ const Collation_utf32_general_ci

+ const Collation_utf32_german2_ci

+ const Collation_utf32_hungarian_ci

+ const Collation_utf32_icelandic_ci

+ const Collation_utf32_latvian_ci

+ const Collation_utf32_lithuanian_ci

+ const Collation_utf32_persian_ci

+ const Collation_utf32_polish_ci

+ const Collation_utf32_roman_ci

+ const Collation_utf32_romanian_ci

+ const Collation_utf32_sinhala_ci

+ const Collation_utf32_slovak_ci

+ const Collation_utf32_slovenian_ci

+ const Collation_utf32_spanish2_ci

+ const Collation_utf32_spanish_ci

+ const Collation_utf32_swedish_ci

+ const Collation_utf32_turkish_ci

+ const Collation_utf32_unicode_520_ci

+ const Collation_utf32_unicode_ci

+ const Collation_utf32_vietnamese_ci

+ const Collation_utf8_bin

+ const Collation_utf8_croatian_ci

+ const Collation_utf8_czech_ci

+ const Collation_utf8_danish_ci

+ const Collation_utf8_esperanto_ci

+ const Collation_utf8_estonian_ci

+ const Collation_utf8_general_ci

+ const Collation_utf8_general_mysql500_ci

+ const Collation_utf8_german2_ci

+ const Collation_utf8_hungarian_ci

+ const Collation_utf8_icelandic_ci

+ const Collation_utf8_latvian_ci

+ const Collation_utf8_lithuanian_ci

+ const Collation_utf8_persian_ci

+ const Collation_utf8_polish_ci

+ const Collation_utf8_roman_ci

+ const Collation_utf8_romanian_ci

+ const Collation_utf8_sinhala_ci

+ const Collation_utf8_slovak_ci

+ const Collation_utf8_slovenian_ci

+ const Collation_utf8_spanish2_ci

+ const Collation_utf8_spanish_ci

+ const Collation_utf8_swedish_ci

+ const Collation_utf8_tolower_ci

+ const Collation_utf8_turkish_ci

+ const Collation_utf8_unicode_520_ci

+ const Collation_utf8_unicode_ci

+ const Collation_utf8_vietnamese_ci

+ const Collation_utf8mb3_bin

+ const Collation_utf8mb3_croatian_ci

+ const Collation_utf8mb3_czech_ci

+ const Collation_utf8mb3_danish_ci

+ const Collation_utf8mb3_esperanto_ci

+ const Collation_utf8mb3_estonian_ci

+ const Collation_utf8mb3_general_ci

+ const Collation_utf8mb3_general_mysql500_ci

+ const Collation_utf8mb3_german2_ci

+ const Collation_utf8mb3_hungarian_ci

+ const Collation_utf8mb3_icelandic_ci

+ const Collation_utf8mb3_latvian_ci

+ const Collation_utf8mb3_lithuanian_ci

+ const Collation_utf8mb3_persian_ci

+ const Collation_utf8mb3_polish_ci

+ const Collation_utf8mb3_roman_ci

+ const Collation_utf8mb3_romanian_ci

+ const Collation_utf8mb3_sinhala_ci

+ const Collation_utf8mb3_slovak_ci

+ const Collation_utf8mb3_slovenian_ci

+ const Collation_utf8mb3_spanish2_ci

+ const Collation_utf8mb3_spanish_ci

+ const Collation_utf8mb3_swedish_ci

+ const Collation_utf8mb3_tolower_ci

+ const Collation_utf8mb3_turkish_ci

+ const Collation_utf8mb3_unicode_520_ci

+ const Collation_utf8mb3_unicode_ci

+ const Collation_utf8mb3_vietnamese_ci

+ const Collation_utf8mb4_0900_ai_ci

+ const Collation_utf8mb4_0900_as_ci

+ const Collation_utf8mb4_0900_as_cs

+ const Collation_utf8mb4_0900_bin

+ const Collation_utf8mb4_bin

+ const Collation_utf8mb4_croatian_ci

+ const Collation_utf8mb4_cs_0900_ai_ci

+ const Collation_utf8mb4_cs_0900_as_cs

+ const Collation_utf8mb4_czech_ci

+ const Collation_utf8mb4_da_0900_ai_ci

+ const Collation_utf8mb4_da_0900_as_cs

+ const Collation_utf8mb4_danish_ci

+ const Collation_utf8mb4_de_pb_0900_ai_ci

+ const Collation_utf8mb4_de_pb_0900_as_cs

+ const Collation_utf8mb4_eo_0900_ai_ci

+ const Collation_utf8mb4_eo_0900_as_cs

+ const Collation_utf8mb4_es_0900_ai_ci

+ const Collation_utf8mb4_es_0900_as_cs

+ const Collation_utf8mb4_es_trad_0900_ai_ci

+ const Collation_utf8mb4_es_trad_0900_as_cs

+ const Collation_utf8mb4_esperanto_ci

+ const Collation_utf8mb4_estonian_ci

+ const Collation_utf8mb4_et_0900_ai_ci

+ const Collation_utf8mb4_et_0900_as_cs

+ const Collation_utf8mb4_general_ci

+ const Collation_utf8mb4_german2_ci

+ const Collation_utf8mb4_hr_0900_ai_ci

+ const Collation_utf8mb4_hr_0900_as_cs

+ const Collation_utf8mb4_hu_0900_ai_ci

+ const Collation_utf8mb4_hu_0900_as_cs

+ const Collation_utf8mb4_hungarian_ci

+ const Collation_utf8mb4_icelandic_ci

+ const Collation_utf8mb4_is_0900_ai_ci

+ const Collation_utf8mb4_is_0900_as_cs

+ const Collation_utf8mb4_ja_0900_as_cs

+ const Collation_utf8mb4_ja_0900_as_cs_ks

+ const Collation_utf8mb4_la_0900_ai_ci

+ const Collation_utf8mb4_la_0900_as_cs

+ const Collation_utf8mb4_latvian_ci

+ const Collation_utf8mb4_lithuanian_ci

+ const Collation_utf8mb4_lt_0900_ai_ci

+ const Collation_utf8mb4_lt_0900_as_cs

+ const Collation_utf8mb4_lv_0900_ai_ci

+ const Collation_utf8mb4_lv_0900_as_cs

+ const Collation_utf8mb4_persian_ci

+ const Collation_utf8mb4_pl_0900_ai_ci

+ const Collation_utf8mb4_pl_0900_as_cs

+ const Collation_utf8mb4_polish_ci

+ const Collation_utf8mb4_ro_0900_ai_ci

+ const Collation_utf8mb4_ro_0900_as_cs

+ const Collation_utf8mb4_roman_ci

+ const Collation_utf8mb4_romanian_ci

+ const Collation_utf8mb4_ru_0900_ai_ci

+ const Collation_utf8mb4_ru_0900_as_cs

+ const Collation_utf8mb4_sinhala_ci

+ const Collation_utf8mb4_sk_0900_ai_ci

+ const Collation_utf8mb4_sk_0900_as_cs

+ const Collation_utf8mb4_sl_0900_ai_ci

+ const Collation_utf8mb4_sl_0900_as_cs

+ const Collation_utf8mb4_slovak_ci

+ const Collation_utf8mb4_slovenian_ci

+ const Collation_utf8mb4_spanish2_ci

+ const Collation_utf8mb4_spanish_ci

+ const Collation_utf8mb4_sv_0900_ai_ci

+ const Collation_utf8mb4_sv_0900_as_cs

+ const Collation_utf8mb4_swedish_ci

+ const Collation_utf8mb4_tr_0900_ai_ci

+ const Collation_utf8mb4_tr_0900_as_cs

+ const Collation_utf8mb4_turkish_ci

+ const Collation_utf8mb4_unicode_520_ci

+ const Collation_utf8mb4_unicode_ci

+ const Collation_utf8mb4_vi_0900_ai_ci

+ const Collation_utf8mb4_vi_0900_as_cs

+ const Collation_utf8mb4_vietnamese_ci

+ const Collation_utf8mb4_zh_0900_as_cs

+ const CurrentDBSessionVar

+ const DateLayout

+ const DecimalTypeMaxPrecision

+ const DecimalTypeMaxScale

+ const EnumTypeMaxElements

+ const EnumTypeMinElements

+ const False

+ const IndexBatchSize

+ const N

+ const NoPad

+ const OkResultColumnName

+ const PadSpace

+ const QueryKey

+ const SetTypeMaxElements

+ const TimestampDatetimeLayout

+ const True

+ const Y

+ var Blob = MustCreateBinary(sqltypes.Blob, textBlobMax)

+ var Boolean = Int8

+ var CollationToMySQLVals = map[Collation]mysqlCollationRow

+ var Date = MustCreateDatetimeType(sqltypes.Date)

+ var Datetime = MustCreateDatetimeType(sqltypes.Datetime)

+ var ErrAmbiguousColumnName = errors.NewKind("ambiguous column name %q, it's present in all these tables: %v")

+ var ErrAsOfNotSupported = errors.NewKind("AS OF not supported for database %s")

+ var ErrBinaryCollation = errors.NewKind("binary types must have the binary collation")

+ var ErrCharacterSetNotSupported = errors.NewKind("Unknown character set: %v")

+ var ErrChildrenAlreadyWritten = errors.New("treeprinter: children already written")

+ var ErrCollationNotSupported = errors.NewKind("Unknown collation: %v")

+ var ErrColumnDefaultDatetimeOnlyFunc = errors.NewKind(...)

+ var ErrColumnDefaultReturnedNull = errors.NewKind(`default value attempted to return null but column is non-nullable`)

+ var ErrColumnDefaultSubquery = errors.NewKind("default value on column `%s` may not contain subqueries")

+ var ErrColumnNotFound = errors.NewKind("column %q could not be found in any table in scope")

+ var ErrConvertToDecimalLimit = errors.NewKind("value of Decimal is too large for type")

+ var ErrConvertToSQL = errors.NewKind("incompatible conversion to SQL type: %s")

+ var ErrConvertingToDecimal = errors.NewKind("value %v is not a valid Decimal")

+ var ErrConvertingToEnum = errors.NewKind("value %v is not valid for this Enum")

+ var ErrConvertingToSet = errors.NewKind("value %v is not valid for this set")

+ var ErrConvertingToTime = errors.NewKind("value %q can't be converted to time.Time")

+ var ErrConvertingToTimeOutOfRange = errors.NewKind("value %q is outside of %v range")

+ var ErrDatabaseNotFound = errors.NewKind("database not found: %s")

+ var ErrDeleteRowNotFound = errors.NewKind("row was not found when attempting to delete")

+ var ErrDropColumnReferencedInDefault = errors.NewKind(`cannot drop column "%s" as default value of column "%s" references it`)

+ var ErrDuplicateAliasOrTable = errors.NewKind("Not unique table/alias: %s")

+ var ErrDuplicateEntrySet = errors.NewKind("duplicate entry: %v")

+ var ErrExistingView = errors.NewKind("the view %s.%s already exists in the registry")

+ var ErrFunctionAlreadyRegistered = errors.NewKind("function '%s' is already registered")

+ var ErrFunctionNotFound = errors.NewKind("function: '%s' not found")

+ var ErrIncompatibleAsOf = errors.NewKind("incompatible use of AS OF: %s")

+ var ErrIncompatibleDefaultType = errors.NewKind("incompatible type for default value")

+ var ErrIndexDeleteInvalidStatus = errors.NewKind("can't delete index %q because it's not ready for removal")

+ var ErrIndexExpressionAlreadyRegistered = errors.NewKind("there is already an index registered for the expressions: %s")

+ var ErrIndexIDAlreadyRegistered = errors.NewKind("an index with id %q has already been registered")

+ var ErrIndexNotFound = errors.NewKind("index %q was not found")

+ var ErrInvalidArgumentNumber = errors.NewKind("function '%s' expected %v arguments, %v received")

+ var ErrInvalidAsOfExpression = errors.NewKind("expression %s cannot be used in AS OF")

+ var ErrInvalidBaseType = errors.NewKind("%v is not a valid %v base type")

+ var ErrInvalidChildType = errors.NewKind("%T: invalid child type, got %T, expected %T")

+ var ErrInvalidChildrenNumber = errors.NewKind("%T: invalid children number, got %d, expected %d")

+ var ErrInvalidColumnDefaultFunction = errors.NewKind("function `%s` on column `%s` is not valid for usage in a default value")

+ var ErrInvalidColumnNumber = errors.NewKind("tuple should contain %d column(s), but has %d")

+ var ErrInvalidDefaultValueOrder = errors.NewKind(...)

+ var ErrInvalidSetValue = errors.NewKind("value %v was not found in the set")

+ var ErrInvalidTextBlobColumnDefault = errors.NewKind("text/blob types may only have expression default values")

+ var ErrInvalidType = errors.NewKind("invalid type: %s")

+ var ErrInvalidUpdateInAfterTrigger = errors.NewKind("Updating of new row is not allowed in after trigger")

+ var ErrInvalidUpdateOfOldRow = errors.NewKind("Updating of old row is not allowed in trigger")

+ var ErrInvalidUseOfOldNew = errors.NewKind("There is no %s row in on %s trigger")

+ var ErrKeyNotFound = errors.NewKind("memory: key %d not found in cache")

+ var ErrLengthBeyondLimit = errors.NewKind("string is too large for column")

+ var ErrLengthTooLarge = errors.NewKind("length is %v but max allowed is %v")

+ var ErrLockDoesNotExist = errors.NewKind("Lock '%s' does not exist.")

+ var ErrLockNotOwned = errors.NewKind("Operation '%s' failed as the lock '%s' has a different owner.")

+ var ErrLockTimeout = errors.NewKind("Timeout acquiring lock '%s'.")

+ var ErrMarshalNullDecimal = errors.NewKind("Decimal cannot marshal a null value")

+ var ErrMisusedAlias = errors.NewKind(...)

+ var ErrNoDatabaseSelected = errors.NewKind("no database selected")

+ var ErrNoMemoryAvailable = errors.NewKind("no memory available")

+ var ErrNodeAlreadyWritten = errors.New("treeprinter: node already written")

+ var ErrNodeNotWritten = errors.New("treeprinter: a child was written before the node")

+ var ErrNonExistingView = errors.NewKind("the view %s.%s does not exist in the registry")

+ var ErrNotArray = errors.NewKind("value of type %T is not an array")

+ var ErrNotGenerator = errors.NewKind("cannot convert value of type %T to a generator")

+ var ErrNotTuple = errors.NewKind("value of type %T is not a tuple")

+ var ErrOutOfRange = errors.NewKind("%v out of range for %v")

+ var ErrPidAlreadyUsed = errors.NewKind("pid %d is already in use")

+ var ErrPrimaryKeyViolation = errors.NewKind("duplicate primary key given: %s")

+ var ErrTableAlreadyExists = errors.NewKind("table with name %s already exists")

+ var ErrTableColumnNotFound = errors.NewKind("table %q does not have column %q")

+ var ErrTableNotFound = errors.NewKind("table not found: %s")

+ var ErrTooLargeForSet = errors.NewKind(`value "%v" is too large for this set`)

+ var ErrTriggerCannotBeDropped = errors.NewKind(`trigger "%s" cannot be dropped as it is referenced by trigger "%s"`)

+ var ErrTriggerCreateStatementInvalid = errors.NewKind(`Invalid CREATE TRIGGER statement: %s`)

+ var ErrTriggerDoesNotExist = errors.NewKind(`trigger "%s" does not exist`)

+ var ErrTriggerTableInUse = errors.NewKind(...)

+ var ErrTriggersNotSupported = errors.NewKind(`database "%s" doesn't support triggers`)

+ var ErrTruncateReferencedFromForeignKey = errors.NewKind("cannot truncate table %s as it is referenced in foreign key %s on table %s")

+ var ErrUnboundPreparedStatementVariable = errors.NewKind(`unbound variable "%s" in query`)

+ var ErrUnexpectedRowLength = errors.NewKind("expected %d values, got %d")

+ var ErrUnexpectedType = errors.NewKind("value at %d has unexpected type: %s")

+ var ErrUniqueKeyViolation = errors.NewKind("duplicate unique key given: %s")

+ var ErrUnknownSystemVariable = errors.NewKind(`Unknown system variable '%s'`)

+ var ErrUnmarshallingEnum = errors.NewKind("value %v is not a marshalled value for this Enum")

+ var Float32 = MustCreateNumberType(sqltypes.Float32)

+ var Float64 = MustCreateNumberType(sqltypes.Float64)

+ var Int16 = MustCreateNumberType(sqltypes.Int16)

+ var Int24 = MustCreateNumberType(sqltypes.Int24)

+ var Int32 = MustCreateNumberType(sqltypes.Int32)

+ var Int64 = MustCreateNumberType(sqltypes.Int64)

+ var Int8 = MustCreateNumberType(sqltypes.Int8)

+ var LongBlob = MustCreateBinary(sqltypes.Blob, longTextBlobMax)

+ var LongText = MustCreateStringWithDefaults(sqltypes.Text, longTextBlobMax)

+ var MediumBlob = MustCreateBinary(sqltypes.Blob, mediumTextBlobMax)

+ var MediumText = MustCreateStringWithDefaults(sqltypes.Text, ...)

+ var OkResultColumnType = Int64

+ var OkResultSchema = Schema

+ var Text = MustCreateStringWithDefaults(sqltypes.Text, textBlobMax / Collation_Default.CharacterSet().MaxLength())

+ var Timestamp = MustCreateDatetimeType(sqltypes.Timestamp)

+ var TimestampDatetimeLayouts = []string

+ var TinyBlob = MustCreateBinary(sqltypes.Blob, tinyTextBlobMax)

+ var TinyText = MustCreateStringWithDefaults(sqltypes.Text, tinyTextBlobMax / Collation_Default.CharacterSet().MaxLength())

+ var Uint16 = MustCreateNumberType(sqltypes.Uint16)

+ var Uint24 = MustCreateNumberType(sqltypes.Uint24)

+ var Uint32 = MustCreateNumberType(sqltypes.Uint32)

+ var Uint64 = MustCreateNumberType(sqltypes.Uint64)

+ var Uint8 = MustCreateNumberType(sqltypes.Uint8)

+ func AreComparable(types ...Type) bool

+ func ConvertToBool(v interface{}) (bool, error)

+ func DBTableIter(ctx *Context, db Database, cb func(Table) (cont bool, err error)) error

+ func DebugString(nodeOrExpression interface{}) string

+ func DefaultSessionConfig() map[string]TypedValue

+ func EvaluateCondition(ctx *Context, cond Expression, row Row) (bool, error)

+ func FormatRow(row Row) string

+ func GetTableNameInsensitive(tblName string, tableNames []string) (string, bool)

+ func HasAvailableMemory(r Reporter) bool

+ func HasDefaultValue(s Session, key string) (bool, interface{})

+ func HashOf(v Row) (uint64, error)

+ func Inspect(expr Expression, f func(expr Expression) bool)

+ func IsArray(t Type) bool

+ func IsBlob(t Type) bool

+ func IsDecimal(t Type) bool

+ func IsFloat(t Type) bool

+ func IsInteger(t Type) bool

+ func IsNull(ex Expression) bool

+ func IsNumber(t Type) bool

+ func IsSigned(t Type) bool

+ func IsText(t Type) bool

+ func IsTextBlob(t Type) bool

+ func IsTextOnly(t Type) bool

+ func IsTime(t Type) bool

+ func IsTuple(t Type) bool

+ func IsUnsigned(t Type) bool

+ func NewMapCache() mapCache

+ func NumColumns(t Type) int

+ func NumericUnaryValue(t Type) interface

+ func RunWithNowFunc(nowFunc func() time.Time, fn func() error) error

+ func TypesEqual(a, b Type) bool

+ func ValidateTime(t time.Time) interface

+ func Walk(v Visitor, expr Expression)

+ func WalkWithNode(v NodeVisitor, n Node, expr Expression)

+ type Aggregation interface

+ Merge func(ctx *Context, buffer, partial Row) error

+ NewBuffer func() Row

+ Update func(ctx *Context, buffer, row Row) error

+ type AlterableTable interface

+ AddColumn func(ctx *Context, column *Column, order *ColumnOrder) error

+ DropColumn func(ctx *Context, columnName string) error

+ ModifyColumn func(ctx *Context, columnName string, column *Column, order *ColumnOrder) error

+ type AscendIndex interface

+ AscendGreaterOrEqual func(keys ...interface{}) (IndexLookup, error)

+ AscendLessThan func(keys ...interface{}) (IndexLookup, error)

+ AscendRange func(greaterOrEqual, lessThan []interface{}) (IndexLookup, error)

+ type AsyncNode interface

+ IsAsync func() bool

+ type AutoIncrementSetter interface

+ SetAutoIncrementValue func(*Context, interface{}) error

+ type AutoIncrementTable interface

+ AutoIncrementSetter func(*Context) AutoIncrementSetter

+ GetAutoIncrementValue func(*Context) (interface{}, error)

+ type BaseSession struct

+ func (s *BaseSession) AddLock(lockName string) error

+ func (s *BaseSession) Address() string

+ func (s *BaseSession) ClearWarnings()

+ func (s *BaseSession) Client() Client

+ func (s *BaseSession) CommitTransaction(*Context) error

+ func (s *BaseSession) DelLock(lockName string) error

+ func (s *BaseSession) Get(key string) (Type, interface{})

+ func (s *BaseSession) GetAll() map[string]TypedValue

+ func (s *BaseSession) GetCurrentDatabase() string

+ func (s *BaseSession) ID() uint32

+ func (s *BaseSession) IterLocks(cb func(name string) error) error

+ func (s *BaseSession) Set(ctx context.Context, key string, typ Type, value interface{}) error

+ func (s *BaseSession) SetCurrentDatabase(dbName string)

+ func (s *BaseSession) Warn(warn *Warning)

+ func (s *BaseSession) WarningCount() uint16

+ func (s *BaseSession) Warnings() []*Warning

+ type BitType interface

+ NumberOfBits func() uint8

+ func CreateBitType(numOfBits uint8) (BitType, error)

+ func MustCreateBitType(numOfBits uint8) BitType

+ type Catalog struct

+ func NewCatalog() *Catalog

+ func (c *Catalog) AddDatabase(db Database)

+ func (c *Catalog) AllDatabases() Databases

+ func (c *Catalog) Database(db string) (Database, error)

+ func (c *Catalog) HasDB(db string) bool

+ func (c *Catalog) LockTable(ctx *Context, table string)

+ func (c *Catalog) Table(ctx *Context, db, table string) (Table, error)

+ func (c *Catalog) TableAsOf(ctx *Context, db, table string, time interface{}) (Table, error)

+ func (c *Catalog) UnlockTables(ctx *Context, id uint32) error

+ type CharacterSet string

+ func ParseCharacterSet(str string) (CharacterSet, error)

+ func (cs CharacterSet) BinaryCollation() Collation

+ func (cs CharacterSet) DefaultCollation() Collation

+ func (cs CharacterSet) Description() string

+ func (cs CharacterSet) MaxLength() int64

+ func (cs CharacterSet) String() string

+ type Checksumable interface

+ Checksum func() (string, error)

+ type Client struct

+ Address string

+ User string

+ type Closer interface

+ Close func(*Context) error

+ type Collation string

+ func ParseCollation(characterSetStr *string, collationStr *string, binaryAttribute bool) (Collation, error)

+ func (c Collation) CharacterSet() CharacterSet

+ func (c Collation) ID() int64

+ func (c Collation) IsCompiled() string

+ func (c Collation) IsDefault() string

+ func (c Collation) PadSpace() string

+ func (c Collation) SortLen() int64

+ func (c Collation) String() string

+ func (c Collation) WorksWithCharacterSet(cs CharacterSet) bool

+ type Column struct

+ AutoIncrement bool

+ Comment string

+ Default *ColumnDefaultValue

+ Extra string

+ Name string

+ Nullable bool

+ PrimaryKey bool

+ Source string

+ Type Type

+ func (c *Column) Check(v interface{}) bool

+ func (c *Column) Equals(c2 *Column) bool

+ type ColumnDefaultValue struct

+ func NewColumnDefaultValue(expr Expression, outType Type, representsLiteral bool, mayReturnNil bool) (*ColumnDefaultValue, error)

+ func (e *ColumnDefaultValue) Children() []Expression

+ func (e *ColumnDefaultValue) Eval(ctx *Context, r Row) (interface{}, error)

+ func (e *ColumnDefaultValue) IsLiteral() bool

+ func (e *ColumnDefaultValue) IsNullable() bool

+ func (e *ColumnDefaultValue) Resolved() bool

+ func (e *ColumnDefaultValue) String() string

+ func (e *ColumnDefaultValue) Type() Type

+ func (e *ColumnDefaultValue) WithChildren(children ...Expression) (Expression, error)

+ func (e *ColumnDefaultValue) WithType(outType Type) (*ColumnDefaultValue, error)

+ type ColumnOrder struct

+ AfterColumn string

+ First bool

+ type Context struct

+ Memory *MemoryManager

+ func NewContext(ctx context.Context, opts ...ContextOption) *Context

+ func NewEmptyContext() *Context

+ func (c *Context) ApplyOpts(opts ...ContextOption)

+ func (c *Context) Error(code int, msg string, args ...interface{})

+ func (c *Context) NewSubContext() (*Context, context.CancelFunc)

+ func (c *Context) Pid() uint64

+ func (c *Context) Query() string

+ func (c *Context) QueryTime() time.Time

+ func (c *Context) RootSpan() opentracing.Span

+ func (c *Context) Span(opName string, opts ...opentracing.StartSpanOption) (opentracing.Span, *Context)

+ func (c *Context) Warn(code int, msg string, args ...interface{})

+ func (c *Context) WithContext(ctx context.Context) *Context

+ func (c *Context) WithCurrentDB(db string) *Context

+ type ContextOption func(*Context)

+ func WithIndexRegistry(ir *IndexRegistry) ContextOption

+ func WithMemoryManager(m *MemoryManager) ContextOption

+ func WithPid(pid uint64) ContextOption

+ func WithQuery(q string) ContextOption

+ func WithRootSpan(s opentracing.Span) ContextOption

+ func WithSession(s Session) ContextOption

+ func WithTracer(t opentracing.Tracer) ContextOption

+ func WithViewRegistry(vr *ViewRegistry) ContextOption

+ type CreateFunc0Args func() Expression

+ type CreateFunc1Args func(e1 Expression) Expression

+ type CreateFunc2Args func(e1, e2 Expression) Expression

+ type CreateFunc3Args func(e1, e2, e3 Expression) Expression

+ type CreateFunc4Args func(e1, e2, e3, e4 Expression) Expression

+ type CreateFunc5Args func(e1, e2, e3, e4, e5 Expression) Expression

+ type CreateFunc6Args func(e1, e2, e3, e4, e5, e6 Expression) Expression

+ type CreateFunc7Args func(e1, e2, e3, e4, e5, e6, e7 Expression) Expression

+ type CreateFuncNArgs func(args ...Expression) (Expression, error)

+ type Database interface

+ GetTableInsensitive func(ctx *Context, tblName string) (Table, bool, error)

+ GetTableNames func(ctx *Context) ([]string, error)

+ type Databaser interface

+ Database func() Database

+ WithDatabase func(Database) (Node, error)

+ type Databases []Database

+ func (d *Databases) Add(db Database)

+ func (d Databases) Database(name string) (Database, error)

+ func (d Databases) Table(ctx *Context, dbName string, tableName string) (Table, error)

+ func (d Databases) TableAsOf(ctx *Context, dbName string, tableName string, asOf interface{}) (Table, error)

+ type DatetimeType interface

+ ConvertWithoutRangeCheck func(v interface{}) (time.Time, error)

+ MaximumTime func() time.Time

+ MinimumTime func() time.Time

+ func CreateDatetimeType(baseType query.Type) (DatetimeType, error)

+ func MustCreateDatetimeType(baseType query.Type) DatetimeType

+ type DebugStringer interface

+ DebugString func() string

+ type DecimalType interface

+ ConvertToDecimal func(v interface{}) (decimal.NullDecimal, error)

+ ExclusiveUpperBound func() decimal.Decimal

+ MaximumScale func() uint8

+ Precision func() uint8

+ Scale func() uint8

+ func CreateDecimalType(precision uint8, scale uint8) (DecimalType, error)

+ func MustCreateDecimalType(precision uint8, scale uint8) DecimalType

+ type DeletableTable interface

+ Deleter func(*Context) RowDeleter

+ type DescendIndex interface

+ DescendGreater func(keys ...interface{}) (IndexLookup, error)

+ DescendLessOrEqual func(keys ...interface{}) (IndexLookup, error)

+ DescendRange func(lessOrEqual, greaterThan []interface{}) (IndexLookup, error)

+ type Disposable interface

+ Dispose func()

+ type DisposeFunc func()

+ type DriverIndex interface

+ Driver func() string

+ type DriverIndexLookup interface

+ Indexes func() []string

+ Values func(Partition) (IndexValueIter, error)

+ type DriverIndexableTable interface

+ IndexKeyValues func(*Context, []string) (PartitionIndexKeyValueIter, error)

+ type EnumType interface

+ At func(index int) (string, bool)

+ CharacterSet func() CharacterSet

+ Collation func() Collation

+ ConvertToIndex func(v interface{}) (int, error)

+ IndexOf func(v string) int

+ Marshal func(v interface{}) (int64, error)

+ NumberOfElements func() uint16

+ Unmarshal func(v int64) (string, error)

+ Values func() []string

+ func CreateEnumType(values []string, collation Collation) (EnumType, error)

+ func MustCreateEnumType(values []string, collation Collation) EnumType

+ type EvalLogic func(*Context, Row) (interface{}, error)

+ type Expression interface

+ Children func() []Expression

+ Eval func(ctx *Context, row Row) (interface{}, error)

+ IsNullable func() bool

+ Type func() Type

+ WithChildren func(children ...Expression) (Expression, error)

+ type Expressioner interface

+ Expressions func() []Expression

+ WithExpressions func(...Expression) (Node, error)

+ type FilteredTable interface

+ HandledFilters func(filters []Expression) []Expression

+ WithFilters func(filters []Expression) Table

+ type ForeignKeyAlterableTable interface

+ CreateForeignKey func(ctx *Context, fkName string, columns []string, referencedTable string, ...) error

+ DropForeignKey func(ctx *Context, fkName string) error

+ type ForeignKeyConstraint struct

+ Columns []string

+ Name string

+ OnDelete ForeignKeyReferenceOption

+ OnUpdate ForeignKeyReferenceOption

+ ReferencedColumns []string

+ ReferencedTable string

+ type ForeignKeyReferenceOption string

+ const ForeignKeyReferenceOption_Cascade

+ const ForeignKeyReferenceOption_DefaultAction

+ const ForeignKeyReferenceOption_NoAction

+ const ForeignKeyReferenceOption_Restrict

+ const ForeignKeyReferenceOption_SetDefault

+ const ForeignKeyReferenceOption_SetNull

+ type ForeignKeyTable interface

+ GetForeignKeys func(ctx *Context) ([]ForeignKeyConstraint, error)

+ type Freeable interface

+ Free func()

+ type Function interface

+ Call func(...Expression) (Expression, error)

+ type Function0 struct

+ Fn CreateFunc0Args

+ Name string

+ func NewFunction0(name string, fn func() Expression) Function0

+ func (fn Function0) Call(args ...Expression) (Expression, error)

+ type Function1 struct

+ Fn CreateFunc1Args

+ Name string

+ func (fn Function1) Call(args ...Expression) (Expression, error)

+ type Function2 struct

+ Fn CreateFunc2Args

+ Name string

+ func (fn Function2) Call(args ...Expression) (Expression, error)

+ type Function3 struct

+ Fn CreateFunc3Args

+ Name string

+ func (fn Function3) Call(args ...Expression) (Expression, error)

+ type Function4 struct

+ Fn CreateFunc4Args

+ Name string

+ func (fn Function4) Call(args ...Expression) (Expression, error)

+ type Function5 struct

+ Fn CreateFunc5Args

+ Name string

+ func (fn Function5) Call(args ...Expression) (Expression, error)

+ type Function6 struct

+ Fn CreateFunc6Args

+ Name string

+ func (fn Function6) Call(args ...Expression) (Expression, error)

+ type Function7 struct

+ Fn CreateFunc7Args

+ Name string

+ func (fn Function7) Call(args ...Expression) (Expression, error)

+ type FunctionExpression interface

+ FunctionName func() string

+ type FunctionN struct

+ Fn CreateFuncNArgs

+ Name string

+ func (fn FunctionN) Call(args ...Expression) (Expression, error)

+ type FunctionRegistry map[string]Function

+ func NewFunctionRegistry() FunctionRegistry

+ func (r FunctionRegistry) Function(name string) (Function, error)

+ func (r FunctionRegistry) MustRegister(fn ...Function)

+ func (r FunctionRegistry) Register(fn ...Function) error

+ type Generator interface

+ Close func() error

+ Next func() (interface{}, error)

+ func NewArrayGenerator(array []interface{}) Generator

+ func ToGenerator(v interface{}) (Generator, error)

+ type Index interface

+ Comment func() string

+ Database func() string

+ Expressions func() []string

+ Get func(key ...interface{}) (IndexLookup, error)

+ Has func(partition Partition, key ...interface{}) (bool, error)

+ ID func() string

+ IndexType func() string

+ IsUnique func() bool

+ Table func() string

+ type IndexAddressableTable interface

+ WithIndexLookup func(IndexLookup) Table

+ type IndexAlterableTable interface

+ CreateIndex func(ctx *Context, indexName string, using IndexUsing, constraint IndexConstraint, ...) error

+ DropIndex func(ctx *Context, indexName string) error

+ RenameIndex func(ctx *Context, fromIndexName string, toIndexName string) error

+ type IndexColumn struct

+ Length int64

+ Name string

+ type IndexConstraint byte

+ const IndexConstraint_Fulltext

+ const IndexConstraint_None

+ const IndexConstraint_Spatial

+ const IndexConstraint_Unique

+ type IndexDriver interface

+ Create func(db, table, id string, expressions []Expression, config map[string]string) (DriverIndex, error)

+ Delete func(DriverIndex, PartitionIter) error

+ ID func() string

+ LoadAll func(ctx *Context, db, table string) ([]DriverIndex, error)

+ Save func(*Context, DriverIndex, PartitionIndexKeyValueIter) error

+ type IndexKeyValueIter interface

+ Next func() ([]interface{}, []byte, error)

+ type IndexLookup interface

+ type IndexRegistry struct

+ Root string

+ func NewIndexRegistry() *IndexRegistry

+ func (r *IndexRegistry) AddIndex(idx DriverIndex) (created chan<- struct{}, ready <-chan struct{}, err error)

+ func (r *IndexRegistry) CanRemoveIndex(idx Index) bool

+ func (r *IndexRegistry) CanUseIndex(idx Index) bool

+ func (r *IndexRegistry) DefaultIndexDriver() IndexDriver

+ func (r *IndexRegistry) DeleteIndex(db, id string, force bool) (<-chan struct{}, error)

+ func (r *IndexRegistry) ExpressionsWithIndexes(db string, exprs ...Expression) [][]Expression

+ func (r *IndexRegistry) HasIndexes() bool

+ func (r *IndexRegistry) Index(db, id string) DriverIndex

+ func (r *IndexRegistry) IndexByExpression(ctx *Context, db string, expr ...Expression) Index

+ func (r *IndexRegistry) IndexDriver(id string) IndexDriver

+ func (r *IndexRegistry) IndexesByTable(db, table string) []DriverIndex

+ func (r *IndexRegistry) LoadIndexes(ctx *Context, dbs Databases) error

+ func (r *IndexRegistry) MarkOutdated(idx Index)

+ func (r *IndexRegistry) RegisterIndexDriver(driver IndexDriver)

+ func (r *IndexRegistry) ReleaseIndex(idx Index)

+ type IndexStatus byte

+ const IndexNotReady

+ const IndexOutdated

+ const IndexReady

+ func (s IndexStatus) IsUsable() bool

+ func (s IndexStatus) String() string

+ type IndexUsing byte

+ const IndexUsing_BTree

+ const IndexUsing_Default

+ const IndexUsing_Hash

+ type IndexValueIter interface

+ Next func() ([]byte, error)

+ type IndexedTable interface

+ GetIndexes func(ctx *Context) ([]Index, error)

+ type InsertableTable interface

+ Inserter func(*Context) RowInserter

+ type JsonType interface

+ var JSON JsonType = jsonType{}

+ type KeyValueCache interface

+ Get func(uint64) (interface{}, error)

+ Put func(uint64, interface{}) error

+ Size func() int

+ type LockState int

+ const LockDoesNotExist

+ const LockFree

+ const LockInUse

+ type LockSubsystem struct

+ func NewLockSubsystem() *LockSubsystem

+ func (ls *LockSubsystem) GetLockState(name string) (state LockState, owner uint32)

+ func (ls *LockSubsystem) Lock(ctx *Context, name string, timeout time.Duration) error

+ func (ls *LockSubsystem) ReleaseAll(ctx *Context) (int, error)

+ func (ls *LockSubsystem) Unlock(ctx *Context, name string) error

+ type Lockable interface

+ Lock func(ctx *Context, write bool) error

+ Unlock func(ctx *Context, id uint32) error

+ type MemoryManager struct

+ func NewMemoryManager(r Reporter) *MemoryManager

+ func (m *MemoryManager) Free()

+ func (m *MemoryManager) HasAvailable() bool

+ func (m *MemoryManager) NewHistoryCache() (KeyValueCache, DisposeFunc)

+ func (m *MemoryManager) NewLRUCache(size uint) (KeyValueCache, DisposeFunc)

+ func (m *MemoryManager) NewRowsCache() (RowsCache, DisposeFunc)

+ type MergeableIndexLookup interface

+ Intersection func(...IndexLookup) (IndexLookup, error)

+ IsMergeable func(IndexLookup) bool

+ Union func(...IndexLookup) (IndexLookup, error)

+ type Nameable interface

+ Name func() string

+ type NegateIndex interface

+ Not func(keys ...interface{}) (IndexLookup, error)

+ type Node interface

+ Children func() []Node

+ RowIter func(ctx *Context, row Row) (RowIter, error)

+ Schema func() Schema

+ WithChildren func(...Node) (Node, error)

+ type NodeVisitor interface

+ Visit func(node Node, expression Expression) NodeVisitor

+ type NonDeterministicExpression interface

+ IsNonDeterministic func() bool

+ type NullType interface

+ var ErrValueNotNil = errors.NewKind("value not nil: %#v")

+ var Null NullType = nullType{}

+ type NumberType interface

+ IsFloat func() bool

+ IsSigned func() bool

+ func CreateNumberType(baseType query.Type) (NumberType, error)

+ func MustCreateNumberType(baseType query.Type) NumberType

+ type OkResult struct

+ Info fmt.Stringer

+ InsertID uint64

+ RowsAffected uint64

+ func NewOkResult(rowsAffected int) OkResult

+ type OpaqueNode interface

+ Opaque func() bool

+ type Partition interface

+ Key func() []byte

+ type PartitionCounter interface

+ PartitionCount func(*Context) (int64, error)

+ type PartitionIndexKeyValueIter interface

+ Next func() (Partition, IndexKeyValueIter, error)

+ type PartitionIter interface

+ Next func() (Partition, error)

+ type PartitionProgress struct

+ func (p PartitionProgress) String() string

+ type Process struct

+ Connection uint32

+ Kill context.CancelFunc

+ Pid uint64

+ Progress map[string]TableProgress

+ Query string

+ StartedAt time.Time

+ Type ProcessType

+ User string

+ func (p *Process) Done()

+ func (p *Process) Seconds() uint64

+ type ProcessList struct

+ func NewProcessList() *ProcessList

+ func (pl *ProcessList) AddPartitionProgress(pid uint64, tableName, partitionName string, total int64)

+ func (pl *ProcessList) AddProcess(ctx *Context, typ ProcessType, query string) (*Context, error)

+ func (pl *ProcessList) AddTableProgress(pid uint64, name string, total int64)

+ func (pl *ProcessList) Done(pid uint64)

+ func (pl *ProcessList) Kill(connID uint32)

+ func (pl *ProcessList) KillOnlyQueries(connID uint32)

+ func (pl *ProcessList) Processes() []Process

+ func (pl *ProcessList) RemovePartitionProgress(pid uint64, tableName, partitionName string)

+ func (pl *ProcessList) RemoveTableProgress(pid uint64, name string)

+ func (pl *ProcessList) UpdatePartitionProgress(pid uint64, tableName, partitionName string, delta int64)

+ func (pl *ProcessList) UpdateTableProgress(pid uint64, name string, delta int64)

+ type ProcessType byte

+ const CreateIndexProcess

+ const QueryProcess

+ func (p ProcessType) String() string

+ type Progress struct

+ Done int64

+ Name string

+ Total int64

+ type ProjectedTable interface

+ WithProjection func(colNames []string) Table

+ type ReplaceableTable interface

+ Replacer func(ctx *Context) RowReplacer

+ type Reporter interface

+ MaxMemory func() uint64

+ UsedMemory func() uint64

+ var ProcessMemory Reporter = new(processReporter)

+ type Resolvable interface

+ Resolved func() bool

+ type Row []interface

+ func (r Row) Append(r2 Row) Row

+ func (r Row) Copy() Row

+ func (r Row) Equals(row Row, schema Schema) (bool, error)

+ func NewRow(values ...interface{}) Row

+ func NodeToRows(ctx *Context, n Node) ([]Row, error)

+ func RowIterToRows(i RowIter) ([]Row, error)

+ type RowDeleter interface

+ Delete func(*Context, Row) error

+ type RowInserter interface

+ Insert func(*Context, Row) error

+ type RowIter interface

+ Close func() error

+ Next func() (Row, error)

+ func NewSpanIter(span opentracing.Span, iter RowIter) RowIter

+ func RowsToRowIter(rows ...Row) RowIter

+ type RowReplacer interface

+ Delete func(*Context, Row) error

+ Insert func(*Context, Row) error

+ type RowUpdater interface

+ Update func(ctx *Context, old Row, new Row) error

+ type RowsCache interface

+ Add func(Row) error

+ Get func() []Row

+ type Schema []*Column

+ func (s Schema) CheckRow(row Row) error

+ func (s Schema) Contains(column string, source string) bool

+ func (s Schema) Equals(s2 Schema) bool

+ func (s Schema) IndexOf(column, source string) int

+ type Session interface

+ AddLock func(lockName string) error

+ Address func() string

+ ClearWarnings func()

+ Client func() Client

+ CommitTransaction func(*Context) error

+ DelLock func(lockName string) error

+ Get func(key string) (Type, interface{})

+ GetAll func() map[string]TypedValue

+ GetCurrentDatabase func() string

+ ID func() uint32

+ IterLocks func(cb func(name string) error) error

+ Set func(ctx context.Context, key string, typ Type, value interface{}) error

+ SetCurrentDatabase func(dbName string)

+ Warn func(warn *Warning)

+ WarningCount func() uint16

+ Warnings func() []*Warning

+ func NewBaseSession() Session

+ func NewSession(server, client, user string, id uint32) Session

+ type SetType interface

+ CharacterSet func() CharacterSet

+ Collation func() Collation

+ Marshal func(v interface{}) (uint64, error)

+ NumberOfElements func() uint16

+ Unmarshal func(bits uint64) (string, error)

+ Values func() []string

+ func CreateSetType(values []string, collation Collation) (SetType, error)

+ func MustCreateSetType(values []string, collation Collation) SetType

+ type StatisticsTable interface

+ NumRows func(*Context) (uint64, error)

+ type StringType interface

+ CharacterSet func() CharacterSet

+ Collation func() Collation

+ MaxByteLength func() int64

+ MaxCharacterLength func() int64

+ func CreateBinary(baseType query.Type, lengthHint int64) (StringType, error)

+ func CreateLongText(collation Collation) StringType

+ func CreateMediumText(collation Collation) StringType

+ func CreateString(baseType query.Type, length int64, collation Collation) (StringType, error)

+ func CreateStringWithDefaults(baseType query.Type, length int64) (StringType, error)

+ func CreateText(collation Collation) StringType

+ func CreateTinyText(collation Collation) StringType

+ func MustCreateBinary(baseType query.Type, lengthHint int64) StringType

+ func MustCreateString(baseType query.Type, length int64, collation Collation) StringType

+ func MustCreateStringWithDefaults(baseType query.Type, length int64) StringType

+ type Table interface

+ PartitionRows func(*Context, Partition) (RowIter, error)

+ Partitions func(*Context) (PartitionIter, error)

+ Schema func() Schema

+ String func() string

+ func GetTableInsensitive(tblName string, tables map[string]Table) (Table, bool)

+ type TableCreator interface

+ CreateTable func(ctx *Context, name string, schema Schema) error

+ type TableDropper interface

+ DropTable func(ctx *Context, name string) error

+ type TableProgress struct

+ PartitionsProgress map[string]PartitionProgress

+ func NewTableProgress(name string, total int64) TableProgress

+ func (p TableProgress) String() string

+ type TableRenamer interface

+ RenameTable func(ctx *Context, oldName, newName string) error

+ type TableRowIter struct

+ func NewTableRowIter(ctx *Context, table Table, partitions PartitionIter) *TableRowIter

+ func (i *TableRowIter) Close() error

+ func (i *TableRowIter) Next() (Row, error)

+ type TableWrapper interface

+ Underlying func() Table

+ type Tableable interface

+ Table func() string

+ type TimeType interface

+ ConvertToTimeDuration func(v interface{}) (time.Duration, error)

+ Marshal func(v interface{}) (int64, error)

+ Unmarshal func(v int64) string

+ var ErrConvertingToTimeType = errors.NewKind("value %v is not a valid Time")

+ var Time TimeType = timespanType{}

+ type TransformExprFunc func(Expression) (Expression, error)

+ type TransformNodeFunc func(Node) (Node, error)

+ type TreePrinter struct

+ func NewTreePrinter() *TreePrinter

+ func (p *TreePrinter) String() string

+ func (p *TreePrinter) WriteChildren(children ...string) error

+ func (p *TreePrinter) WriteNode(format string, args ...interface{}) error

+ type TriggerDatabase interface

+ CreateTrigger func(ctx *Context, definition TriggerDefinition) error

+ DropTrigger func(ctx *Context, name string) error

+ GetTriggers func(ctx *Context) ([]TriggerDefinition, error)

+ type TriggerDefinition struct

+ CreateStatement string

+ Name string

+ type TruncateableTable interface

+ Truncate func(*Context) (int, error)

+ type Type interface

+ Compare func(interface{}, interface{}) (int, error)

+ Convert func(interface{}) (interface{}, error)

+ MustConvert func(interface{}) interface{}

+ Promote func() Type

+ SQL func(interface{}) (sqltypes.Value, error)

+ Type func() query.Type

+ Zero func() interface{}

+ func ColumnTypeToType(ct *sqlparser.ColumnType) (Type, error)

+ func CreateArray(underlying Type) Type

+ func CreateTuple(types ...Type) Type

+ func UnderlyingType(t Type) Type

+ type TypedValue struct

+ Typ Type

+ Value interface{}

+ type UnresolvedDatabase string

+ func (UnresolvedDatabase) GetTableInsensitive(ctx *Context, tblName string) (Table, bool, error)

+ func (UnresolvedDatabase) GetTableNames(ctx *Context) ([]string, error)

+ func (UnresolvedDatabase) Tables() map[string]Table

+ func (d UnresolvedDatabase) Name() string

+ type UpdatableTable interface

+ Updater func(ctx *Context) RowUpdater

+ type VersionedDatabase interface

+ GetTableInsensitiveAsOf func(ctx *Context, tblName string, asOf interface{}) (Table, bool, error)

+ GetTableNamesAsOf func(ctx *Context, asOf interface{}) ([]string, error)

+ type View struct

+ func NewView(name string, definition Node, textDefinition string) View

+ func (v *View) Definition() Node

+ func (v *View) Name() string

+ func (v *View) TextDefinition() string

+ type ViewCreator interface

+ CreateView func(ctx *Context, name string, selectStatement string) error

+ type ViewDropper interface

+ DropView func(ctx *Context, name string) error

+ type ViewKey struct

+ func NewViewKey(databaseName, viewName string) ViewKey

+ type ViewRegistry struct

+ func NewViewRegistry() *ViewRegistry

+ func (r *ViewRegistry) AllViews() map[ViewKey]View

+ func (r *ViewRegistry) Delete(databaseName, viewName string) error

+ func (r *ViewRegistry) DeleteList(keys []ViewKey, errIfNotExists bool) error

+ func (r *ViewRegistry) Exists(databaseName, viewName string) bool

+ func (r *ViewRegistry) Register(database string, view View) error

+ func (r *ViewRegistry) View(databaseName, viewName string) (*View, error)

+ func (r *ViewRegistry) ViewsInDatabase(databaseName string) (views []View)

+ type Visitor interface

+ Visit func(expr Expression) Visitor

+ type Warning struct

+ Code int

+ Level string

+ Message string

+ type YearType interface

+ var ErrConvertingToYear = errors.NewKind("value %v is not a valid Year")

+ var Year YearType = yearType{}

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL