sql

package
Version: v0.14.0 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Nov 1, 2022 License: Apache-2.0 Imports: 41 Imported by: 50

Documentation

Index

Constants

View Source
const (
	// BitTypeMinBits returns the minimum number of bits for Bit.
	BitTypeMinBits = 1
	// BitTypeMaxBits returns the maximum number of bits for Bit.
	BitTypeMaxBits = 64
)
View Source
const (
	// DateLayout is the layout of the MySQL date format in the representation
	// Go understands.
	DateLayout = "2006-01-02"

	// TimestampDatetimeLayout is the formatting string with the layout of the timestamp
	// using the format of Go "time" package.
	TimestampDatetimeLayout = "2006-01-02 15:04:05.999999"
)
View Source
const (
	// DecimalTypeMaxPrecision returns the maximum precision allowed for the Decimal type.
	DecimalTypeMaxPrecision = 65
	// DecimalTypeMaxScale returns the maximum scale allowed for the Decimal type, assuming the
	// maximum precision is used. For a maximum scale that is relative to the precision of a given
	// decimal type, use its MaximumScale function.
	DecimalTypeMaxScale = 30
)
View Source
const (
	// EnumTypeMinElements returns the minimum number of enumerations for the Enum type.
	EnumTypeMinElements = 1
	// EnumTypeMaxElements returns the maximum number of enumerations for the Enum type.
	EnumTypeMaxElements = 65535
)
View Source
const (
	CartesianSRID  = uint32(0)
	GeoSpatialSRID = uint32(4326)
)
View Source
const (
	SRIDSize       = 4
	EndianSize     = 1
	TypeSize       = 4
	EWKBHeaderSize = SRIDSize + EndianSize + TypeSize
	WKBHeaderSize  = EndianSize + TypeSize

	PointSize             = 16
	CountSize             = 4
	GeometryMaxByteLength = 4*(1024*1024*1024) - 1
)
View Source
const (
	WKBUnknown = iota
	WKBPointID
	WKBLineID
	WKBPolyID
	WKBMultiPointID
	WKBMultiLineID
	WKBMultiPolyID
	WKBGeomCollID
)

Type IDs

View Source
const (
	ConnectionIdLogField = "connectionID"
	ConnectionDbLogField = "connectionDb"
	ConnectTimeLogKey    = "connectTime"
)
View Source
const (
	// Numeric representation of False as defined by MySQL.
	False = int8(0)
	// Numeric representation of True as defined by MySQL.
	True = int8(1)
)
View Source
const (
	CurrentDBSessionVar  = "current_database"
	AutoCommitSessionVar = "autocommit"
)
View Source
const (
	RowCount     = "row_count"
	FoundRows    = "found_rows"
	LastInsertId = "last_insert_id"
)
View Source
const ChecksumKey = "checksum"

ChecksumKey is the key in an index config to store the checksum.

View Source
const IndexBatchSize = uint64(10000)

IndexBatchSize is the number of rows to save at a time when creating indexes.

View Source
const OkResultColumnName = "__ok_result__"

OkResultColumnName should be used as the schema column name for Nodes that return an OkResult

View Source
const (
	// QueryKey to access query in the context.
	QueryKey key = iota
)
View Source
const (
	// SetTypeMaxElements returns the maximum number of elements for the Set type.
	SetTypeMaxElements = 64
)

Variables

View Source
var (
	// ErrConvertingToTime is thrown when a value cannot be converted to a Time
	ErrConvertingToTime = errors.NewKind("Incorrect datetime value: '%s'")

	ErrConvertingToTimeOutOfRange = errors.NewKind("value %q is outside of %v range")

	// TimestampDatetimeLayouts hold extra timestamps allowed for parsing. It does
	// not have all the layouts supported by mysql. Missing are two digit year
	// versions of common cases and dates that use non common separators.
	//
	// https://github.com/MariaDB/server/blob/mysql-5.5.36/sql-common/my_time.c#L124
	TimestampDatetimeLayouts = []string{
		"2006-01-02 15:4",
		"2006-01-02 15:04",
		"2006-01-02 15:04:",
		"2006-01-02 15:04:.",
		"2006-01-02 15:04:05.",
		"2006-01-02 15:04:05.999999",
		"2006-01-02",
		"2006-1-2",
		"2006-1-2 15:4:5.999999",
		time.RFC3339,
		time.RFC3339Nano,
		"2006-01-02T15:04:05",
		"20060102150405",
		"20060102",
		"2006/01/02",
		"2006-01-02 15:04:05.999999999 -0700 MST",
	}

	// Date is a date with day, month and year.
	Date = MustCreateDatetimeType(sqltypes.Date)
	// Datetime is a date and a time
	Datetime = MustCreateDatetimeType(sqltypes.Datetime)
	// Timestamp is an UNIX timestamp.
	Timestamp = MustCreateDatetimeType(sqltypes.Timestamp)
)
View Source
var (
	ErrConvertingToDecimal   = errors.NewKind("value %v is not a valid Decimal")
	ErrConvertToDecimalLimit = errors.NewKind("Out of range value for column of Decimal type ")
	ErrMarshalNullDecimal    = errors.NewKind("Decimal cannot marshal a null value")
)
View Source
var (
	ErrConvertingToEnum  = errors.NewKind("value %v is not valid for this Enum")
	ErrUnmarshallingEnum = errors.NewKind("value %v is not a marshalled value for this Enum")
	ErrTemporaryEnum     = errors.NewKind("attempted to use temporary enum")
)
View Source
var (
	// ErrSyntaxError is returned when a syntax error in vitess is encountered.
	ErrSyntaxError = errors.NewKind("%s")

	// ErrUnsupportedFeature is thrown when a feature is not already supported
	ErrUnsupportedFeature = errors.NewKind("unsupported feature: %s")

	// ErrReadOnly is returned when the engine has been set to Read Only but a write operation was attempted.
	ErrReadOnly = errors.NewKind("database server is set to read only mode")

	// ErrInvalidSystemVariableValue is returned when a system variable is assigned a value that it does not accept.
	ErrInvalidSystemVariableValue = errors.NewKind("Variable '%s' can't be set to the value of '%v'")

	// ErrSystemVariableCodeFail is returned when failing to encode/decode a system variable.
	ErrSystemVariableCodeFail = errors.NewKind("unable to encode/decode value '%v' for '%s'")

	// ErrInvalidType is thrown when there is an unexpected type at some part of
	// the execution tree.
	ErrInvalidType = errors.NewKind("invalid type: %s")

	// ErrTableAlreadyExists is thrown when someone tries to create a
	// table with a name of an existing one
	ErrTableAlreadyExists = errors.NewKind("table with name %s already exists")

	// ErrTableNotFound is returned when the table is not available from the
	// current scope.
	ErrTableNotFound = errors.NewKind("table not found: %s")

	// ErrTableColumnNotFound is thrown when a column named cannot be found in scope
	ErrTableColumnNotFound = errors.NewKind("table %q does not have column %q")

	// ErrColumnNotFound is returned when the column does not exist in any
	// table in scope.
	ErrColumnNotFound = errors.NewKind("column %q could not be found in any table in scope")

	// ErrAmbiguousColumnName is returned when there is a column reference that
	// is present in more than one table.
	ErrAmbiguousColumnName = errors.NewKind("ambiguous column name %q, it's present in all these tables: %v")

	// ErrAmbiguousColumnOrAliasName is returned when a column or alias name can't be qualified to a table or alias definition
	ErrAmbiguousColumnOrAliasName = errors.NewKind("ambiguous column or alias name %q")

	// ErrAmbiguousColumnInOrderBy is returned when an order by column is ambiguous
	ErrAmbiguousColumnInOrderBy = errors.NewKind("Column %q in order clause is ambiguous")

	// ErrColumnExists is returned when an ALTER TABLE statement would create a duplicate column
	ErrColumnExists = errors.NewKind("Column %q already exists")

	// ErrCreateTableNotSupported is thrown when the database doesn't support table creation
	ErrCreateTableNotSupported = errors.NewKind("tables cannot be created on database %s")

	// ErrDropTableNotSupported is thrown when the database doesn't support dropping tables
	ErrDropTableNotSupported = errors.NewKind("tables cannot be dropped on database %s")

	// ErrRenameTableNotSupported is thrown when the database doesn't support renaming tables
	ErrRenameTableNotSupported = errors.NewKind("tables cannot be renamed on database %s")

	// ErrDatabaseCollationsNotSupported is thrown when a database does not allow updating its collation
	ErrDatabaseCollationsNotSupported = errors.NewKind("database %s does not support collation operations")

	// ErrTableCreatedNotFound is thrown when a table is created from CREATE TABLE but cannot be found immediately afterward
	ErrTableCreatedNotFound = errors.NewKind("table was created but could not be found")

	// ErrUnexpectedRowLength is thrown when the obtained row has more columns than the schema
	ErrUnexpectedRowLength = errors.NewKind("expected %d values, got %d")

	// ErrInvalidChildrenNumber is returned when the WithChildren method of a
	// node or expression is called with an invalid number of arguments.
	ErrInvalidChildrenNumber = errors.NewKind("%T: invalid children number, got %d, expected %d")

	// ErrInvalidExpressionNumber is returned when the WithExpression method of a node
	// is called with an invalid number of arguments.
	ErrInvalidExpressionNumber = errors.NewKind("%T: invalid expression number, got %d, expected %d")

	// ErrInvalidChildType is returned when the WithChildren method of a
	// node or expression is called with an invalid child type. This error is indicative of a bug.
	ErrInvalidChildType = errors.NewKind("%T: invalid child type, got %T, expected %T")

	// ErrInvalidJSONText is returned when a JSON string cannot be parsed or unmarshalled
	ErrInvalidJSONText = errors.NewKind("Invalid JSON text: %s")

	// ErrDeleteRowNotFound
	ErrDeleteRowNotFound = errors.NewKind("row was not found when attempting to delete")

	// ErrDuplicateAlias should be returned when a query contains a duplicate alias / table name.
	ErrDuplicateAliasOrTable = errors.NewKind("Not unique table/alias: %s")

	// ErrPrimaryKeyViolation is returned when a primary key constraint is violated
	// This is meant to wrap a sql.UniqueKey error, which provides the key string
	ErrPrimaryKeyViolation = errors.NewKind("duplicate primary key given")

	// ErrUniqueKeyViolation is returned when a unique key constraint is violated
	// This is meant to wrap a sql.UniqueKey error, which provides the key string
	ErrUniqueKeyViolation = errors.NewKind("duplicate unique key given")

	// ErrMisusedAlias is returned when a alias is defined and used in the same projection.
	ErrMisusedAlias = errors.NewKind("column %q does not exist in scope, but there is an alias defined in" +
		" this projection with that name. Aliases cannot be used in the same projection they're defined in")

	// ErrInvalidAsOfExpression is returned when an expression for AS OF cannot be used
	ErrInvalidAsOfExpression = errors.NewKind("expression %s cannot be used in AS OF")

	// ErrIncompatibleDefaultType is returned when a provided default cannot be coerced into the type of the column
	ErrIncompatibleDefaultType = errors.NewKind("incompatible type for default value")

	// ErrInvalidTextBlobColumnDefault is returned when a column of type text/blob (or related) has a literal default set.
	ErrInvalidTextBlobColumnDefault = errors.NewKind("TEXT, BLOB, GEOMETRY, and JSON types may only have expression default values")

	// ErrInvalidColumnDefaultFunction is returned when an invalid function is used in a default value.
	ErrInvalidColumnDefaultFunction = errors.NewKind("function `%s` on column `%s` is not valid for usage in a default value")

	// ErrColumnDefaultDatetimeOnlyFunc is returned when a non datetime/timestamp column attempts to declare now/current_timestamp as a default value literal.
	ErrColumnDefaultDatetimeOnlyFunc = errors.NewKind("only datetime/timestamp may declare default values of now()/current_timestamp() without surrounding parentheses")

	// ErrColumnDefaultSubquery is returned when a default value contains a subquery.
	ErrColumnDefaultSubquery = errors.NewKind("default value on column `%s` may not contain subqueries")

	// ErrInvalidColumnDefaultValue is returned when column default function value is not wrapped in parentheses for column types excluding datetime and timestamp
	ErrInvalidColumnDefaultValue = errors.NewKind("Invalid default value for '%s'")

	// ErrInvalidDefaultValueOrder is returned when a default value references a column that comes after it and contains a default expression.
	ErrInvalidDefaultValueOrder = errors.NewKind(`default value of column "%s" cannot refer to a column defined after it if those columns have an expression default value`)

	// ErrColumnDefaultReturnedNull is returned when a default expression evaluates to nil but the column is non-nullable.
	ErrColumnDefaultReturnedNull = errors.NewKind(`default value attempted to return null but column is non-nullable`)

	// ErrDropColumnReferencedInDefault is returned when a column cannot be dropped as it is referenced by another column's default value.
	ErrDropColumnReferencedInDefault = errors.NewKind(`cannot drop column "%s" as default value of column "%s" references it`)

	// ErrTriggersNotSupported is returned when attempting to create a trigger on a database that doesn't support them
	ErrTriggersNotSupported = errors.NewKind(`database "%s" doesn't support triggers`)

	// ErrTriggerCreateStatementInvalid is returned when a TriggerDatabase returns a CREATE TRIGGER statement that is invalid
	ErrTriggerCreateStatementInvalid = errors.NewKind(`Invalid CREATE TRIGGER statement: %s`)

	// ErrTriggerDoesNotExist is returned when a trigger does not exist.
	ErrTriggerDoesNotExist = errors.NewKind(`trigger "%s" does not exist`)

	// ErrTriggerTableInUse is returned when trigger execution calls for a table that invoked a trigger being updated by it
	ErrTriggerTableInUse = errors.NewKind("Can't update table %s in stored function/trigger because it is already used by statement which invoked this stored function/trigger")

	// ErrTriggerCannotBeDropped is returned when dropping a trigger would cause another trigger to reference a non-existent trigger.
	ErrTriggerCannotBeDropped = errors.NewKind(`trigger "%s" cannot be dropped as it is referenced by trigger "%s"`)

	// ErrStoredProceduresNotSupported is returned when attempting to create a stored procedure on a database that doesn't support them.
	ErrStoredProceduresNotSupported = errors.NewKind(`database "%s" doesn't support stored procedures`)

	// ErrTriggerDoesNotExist is returned when a stored procedure does not exist.
	ErrStoredProcedureAlreadyExists = errors.NewKind(`stored procedure "%s" already exists`)

	// ErrTriggerDoesNotExist is returned when a stored procedure does not exist.
	ErrStoredProcedureDoesNotExist = errors.NewKind(`stored procedure "%s" does not exist`)

	// ErrProcedureCreateStatementInvalid is returned when a StoredProcedureDatabase returns a CREATE PROCEDURE statement that is invalid.
	ErrProcedureCreateStatementInvalid = errors.NewKind(`Invalid CREATE PROCEDURE statement: %s`)

	// ErrProcedureDuplicateParameterName is returned when a stored procedure has two (or more) parameters with the same name.
	ErrProcedureDuplicateParameterName = errors.NewKind("duplicate parameter name `%s` on stored procedure `%s`")

	// ErrProcedureRecursiveCall is returned when a stored procedure has a CALL statement that refers to itself.
	ErrProcedureRecursiveCall = errors.NewKind("recursive CALL on stored procedure `%s`")

	// ErrProcedureInvalidBodyStatement is returned when a stored procedure has a statement that is invalid inside of procedures.
	ErrProcedureInvalidBodyStatement = errors.NewKind("`%s` statements are invalid inside of stored procedures")

	// ErrExternalProcedureAmbiguousOverload is returned when an external stored procedure is overloaded and has two
	// functions with the same number of parameters.
	ErrExternalProcedureAmbiguousOverload = errors.NewKind("overloaded stored procedure `%s` may only have a single variant with `%d` parameters")

	// ErrExternalProcedureNonFunction is returned when an external stored procedure is given something other than the
	// expected function type.
	ErrExternalProcedureNonFunction = errors.NewKind("received `%T` in place of a function for an external stored procedure")

	// ErrExternalProcedureMissingContextParam is returned when an external stored procedure's first parameter is not
	// the context.
	ErrExternalProcedureMissingContextParam = errors.NewKind("external stored procedures require the first parameter to be the context")

	// ErrExternalProcedurePointerVariadic is returned when an external stored procedure's variadic parameter has a pointer type.
	ErrExternalProcedurePointerVariadic = errors.NewKind("an external stored procedures's variadiac parameter may not have a pointer type")

	// ErrExternalProcedureReturnTypes is returned when an external stored procedure's return types are incorrect.
	ErrExternalProcedureReturnTypes = errors.NewKind("external stored procedures must return a RowIter and error")

	// ErrExternalProcedureFirstReturn is returned when an external stored procedure's first return type is incorrect.
	ErrExternalProcedureFirstReturn = errors.NewKind("external stored procedures require the first return value to be the RowIter")

	// ErrExternalProcedureSecondReturn is returned when an external stored procedure's second return type is incorrect.
	ErrExternalProcedureSecondReturn = errors.NewKind("external stored procedures require the second return value to be the error")

	// ErrExternalProcedureInvalidParamType is returned when one of an external stored procedure's parameters have an
	// invalid type.
	ErrExternalProcedureInvalidParamType = errors.NewKind("external stored procedures do not support parameters with type `%s`")

	// ErrCallIncorrectParameterCount is returned when a CALL statement has the incorrect number of parameters.
	ErrCallIncorrectParameterCount = errors.NewKind("`%s` expected `%d` parameters but got `%d`")

	// ErrUnknownSystemVariable is returned when a query references a system variable that doesn't exist
	ErrUnknownSystemVariable = errors.NewKind(`Unknown system variable '%s'`)

	// ErrSystemVariableReadOnly is returned when attempting to set a value to a non-Dynamic system variable.
	ErrSystemVariableReadOnly = errors.NewKind(`Variable '%s' is a read only variable`)

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

	// ErrSystemVariableSessionOnly is returned when attempting to set a SESSION-only variable using SET GLOBAL.
	ErrSystemVariableSessionOnly = errors.NewKind(`Variable '%s' is a SESSION variable and can't be used with SET GLOBAL`)

	// ErrSystemVariableGlobalOnly is returned when attempting to set a GLOBAL-only variable using SET SESSION.
	ErrSystemVariableGlobalOnly = errors.NewKind(`Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL`)

	// ErrUserVariableNoDefault is returned when attempting to set the default value on a user variable.
	ErrUserVariableNoDefault = errors.NewKind(`User variable '%s' does not have a default value`)

	// ErrInvalidUseOfOldNew is returned when a trigger attempts to make use of OLD or NEW references when they don't exist
	ErrInvalidUseOfOldNew = errors.NewKind("There is no %s row in on %s trigger")

	// ErrInvalidUpdateOfOldRow is returned when a trigger attempts to assign to an old row's value with SET
	ErrInvalidUpdateOfOldRow = errors.NewKind("Updating of old row is not allowed in trigger")

	// ErrInvalidUpdateInAfterTrigger is returned when a trigger attempts to assign to a new row in an AFTER trigger
	ErrInvalidUpdateInAfterTrigger = errors.NewKind("Updating of new row is not allowed in after trigger")

	// ErrUnknownColumn is returned when the given column is not found in referenced table
	ErrUnknownColumn = errors.NewKind("Unknown column '%s' in '%s'")

	// ErrUnboundPreparedStatementVariable is returned when a query is executed without a binding for one its variables.
	ErrUnboundPreparedStatementVariable = errors.NewKind(`unbound variable "%s" in query`)

	// ErrTruncateReferencedFromForeignKey is returned when a table is referenced in a foreign key and TRUNCATE is called on it.
	ErrTruncateReferencedFromForeignKey = errors.NewKind("cannot truncate table %s as it is referenced in foreign key %s on table %s")

	// ErrInvalidColTypeDefinition is returned when a column type-definition has argument violations.
	ErrInvalidColTypeDefinition = errors.NewKind("column %s type definition is invalid: %s")

	// ErrDatabaseExists is returned when CREATE DATABASE attempts to create a database that already exists.
	ErrDatabaseExists = errors.NewKind("can't create database %s; database exists")

	// ErrInvalidConstraintFunctionNotSupported is returned when a CONSTRAINT CHECK is called with an unsupported function expression.
	ErrInvalidConstraintFunctionNotSupported = errors.NewKind("Invalid constraint expression, function not supported: %s")

	// ErrInvalidConstraintSubqueryNotSupported is returned when a CONSTRAINT CHECK is called with a sub-query expression.
	ErrInvalidConstraintSubqueryNotSupported = errors.NewKind("Invalid constraint expression, sub-queries not supported: %s")

	// ErrCheckConstraintViolated is returned when a CONSTRAINT CHECK is called with a sub-query expression.
	ErrCheckConstraintViolated = errors.NewKind("Check constraint %q violated")

	// ErrCheckConstraintInvalidatedByColumnAlter is returned when an alter column statement would invalidate a check constraint.
	ErrCheckConstraintInvalidatedByColumnAlter = errors.NewKind("can't alter column %q because it would invalidate check constraint %q")

	// ErrColumnCountMismatch is returned when a view, derived table or common table expression has a declared column
	// list with a different number of columns than the schema of the table.
	ErrColumnCountMismatch = errors.NewKind("In definition of view, derived table or common table expression, SELECT list and column names list have different column counts")

	// ErrUuidUnableToParse is returned when a UUID is unable to be parsed.
	ErrUuidUnableToParse = errors.NewKind("unable to parse '%s' to UUID: %s")

	// ErrLoadDataCannotOpen is returned when a LOAD DATA operation is unable to open the file specified.
	ErrLoadDataCannotOpen = errors.NewKind("LOAD DATA is unable to open file: %s")

	// ErrLoadDataCharacterLength is returned when a symbol is of the wrong character length for a LOAD DATA operation.
	ErrLoadDataCharacterLength = errors.NewKind("%s must be 1 character long")

	// ErrJSONObjectAggNullKey is returned when JSON_OBJECTAGG is run on a table with NULL keys
	ErrJSONObjectAggNullKey = errors.NewKind("JSON documents may not contain NULL member names")

	// ErrDeclareOrderInvalid is returned when a DECLARE statement is at an invalid location.
	ErrDeclareOrderInvalid = errors.NewKind("DECLARE may only exist at the beginning of a BEGIN/END block")

	// ErrDeclareConditionNotFound is returned when SIGNAL/RESIGNAL references a non-existent DECLARE CONDITION.
	ErrDeclareConditionNotFound = errors.NewKind("condition %s does not exist")

	// ErrDeclareConditionDuplicate is returned when a DECLARE CONDITION statement with the same name was declared in the current scope.
	ErrDeclareConditionDuplicate = errors.NewKind("duplicate condition '%s'")

	// ErrSignalOnlySqlState is returned when SIGNAL/RESIGNAL references a DECLARE CONDITION for a MySQL error code.
	ErrSignalOnlySqlState = errors.NewKind("SIGNAL/RESIGNAL can only use a condition defined with SQLSTATE")

	// ErrExpectedSingleRow is returned when a subquery executed in normal queries or aggregation function returns
	// more than 1 row without an attached IN clause.
	ErrExpectedSingleRow = errors.NewKind("the subquery returned more than 1 row")

	// ErrUnknownConstraint is returned when a DROP CONSTRAINT statement refers to a constraint that doesn't exist
	ErrUnknownConstraint = errors.NewKind("Constraint %q does not exist")

	// ErrInsertIntoNonNullableDefaultNullColumn is returned when an INSERT excludes a field which is non-nullable and has no default/autoincrement.
	ErrInsertIntoNonNullableDefaultNullColumn = errors.NewKind("Field '%s' doesn't have a default value")

	// ErrAlterTableNotSupported is thrown when the table doesn't support ALTER TABLE statements
	ErrAlterTableNotSupported = errors.NewKind("table %s cannot be altered")

	// ErrPartitionNotFound is thrown when a partition key on a table is not found
	ErrPartitionNotFound = errors.NewKind("partition not found %q")

	// ErrInsertIntoNonNullableProvidedNull is called when a null value is inserted into a non-nullable column
	ErrInsertIntoNonNullableProvidedNull = errors.NewKind("column name '%v' is non-nullable but attempted to set a value of null")

	// ErrForeignKeyChildViolation is called when a rows is added but there is no parent row, and a foreign key constraint fails. Add the parent row first.
	ErrForeignKeyChildViolation = errors.NewKind("cannot add or update a child row - Foreign key violation on fk: `%s`, table: `%s`, referenced table: `%s`, key: `%s`")

	// ErrForeignKeyParentViolation is called when a parent row that is deleted has children, and a foreign key constraint fails. Delete the children first.
	ErrForeignKeyParentViolation = errors.NewKind("cannot delete or update a parent row - Foreign key violation on fk: `%s`, table: `%s`, referenced table: `%s`, key: `%s`")

	// ErrForeignKeyColumnCountMismatch is called when the declared column and referenced column counts do not match.
	ErrForeignKeyColumnCountMismatch = errors.NewKind("the foreign key must reference an equivalent number of columns")

	// ErrForeignKeyColumnTypeMismatch is returned when the declared column's type and referenced column's type do not match.
	ErrForeignKeyColumnTypeMismatch = errors.NewKind("column type mismatch on `%s` and `%s`")

	// ErrForeignKeyNotResolved is called when an add or update is attempted on a foreign key that has not been resolved yet.
	ErrForeignKeyNotResolved = errors.NewKind("cannot add or update a child row: a foreign key constraint fails (`%s`.`%s`, CONSTRAINT `%s` FOREIGN KEY (`%s`) REFERENCES `%s` (`%s`))")

	// ErrNoForeignKeySupport is returned when the table does not support FOREIGN KEY operations.
	ErrNoForeignKeySupport = errors.NewKind("the table does not support foreign key operations: %s")

	// ErrForeignKeyMissingColumns is returned when an ALTER TABLE ADD FOREIGN KEY statement does not provide any columns
	ErrForeignKeyMissingColumns = errors.NewKind("cannot create a foreign key without columns")

	// ErrForeignKeyDropColumn is returned when attempting to drop a column used in a foreign key
	ErrForeignKeyDropColumn = errors.NewKind("cannot drop column `%s` as it is used in foreign key `%s`")

	// ErrForeignKeyDropTable is returned when attempting to drop a table used in a foreign key
	ErrForeignKeyDropTable = errors.NewKind("cannot drop table `%s` as it is referenced in foreign key `%s`")

	// ErrForeignKeyDropIndex is returned when attempting to drop an index used in a foreign key when there are no other
	// indexes which may be used in its place.
	ErrForeignKeyDropIndex = errors.NewKind("cannot drop index: `%s` is used by foreign key `%s`")

	// ErrForeignKeyDuplicateName is returned when a foreign key already exists with the given name.
	ErrForeignKeyDuplicateName = errors.NewKind("duplicate foreign key constraint name `%s`")

	// ErrAddForeignKeyDuplicateColumn is returned when an ALTER TABLE ADD FOREIGN KEY statement has the same column multiple times
	ErrAddForeignKeyDuplicateColumn = errors.NewKind("cannot have duplicates of columns in a foreign key: `%v`")

	// ErrTemporaryTablesForeignKeySupport is returned when a user tries to create a temporary table with a foreign key
	ErrTemporaryTablesForeignKeySupport = errors.NewKind("temporary tables do not support foreign keys")

	// ErrForeignKeyNotFound is returned when a foreign key was not found.
	ErrForeignKeyNotFound = errors.NewKind("foreign key `%s` was not found on the table `%s`")

	// ErrForeignKeySetDefault is returned when attempting to set a referential action as SET DEFAULT.
	ErrForeignKeySetDefault = errors.NewKind(`"SET DEFAULT" is not supported`)

	// ErrForeignKeySetNullNonNullable is returned when attempting to set a referential action as SET NULL when the
	// column is non-nullable.
	ErrForeignKeySetNullNonNullable = errors.NewKind("cannot use SET NULL as column `%s` is non-nullable")

	// ErrForeignKeyTypeChangeSetNull is returned when attempting to change a column's type to disallow NULL values when
	// a foreign key referential action is SET NULL.
	ErrForeignKeyTypeChangeSetNull = errors.NewKind("column `%s` must allow NULL values as foreign key `%s` has SET NULL")

	// ErrForeignKeyMissingReferenceIndex is returned when the referenced columns in a foreign key do not have an index.
	ErrForeignKeyMissingReferenceIndex = errors.NewKind("missing index for foreign key `%s` on the referenced table `%s`")

	// ErrForeignKeyTextBlob is returned when a TEXT or BLOB column is used in a foreign key, which are not valid types.
	ErrForeignKeyTextBlob = errors.NewKind("TEXT/BLOB are not valid types for foreign keys")

	// ErrForeignKeyTypeChange is returned when attempting to change the type of some column used in a foreign key.
	ErrForeignKeyTypeChange = errors.NewKind("unable to change type of column `%s` as it is used by foreign keys")

	// ErrForeignKeyDepthLimit is returned when the CASCADE depth limit has been reached.
	ErrForeignKeyDepthLimit = errors.NewKind("Foreign key cascade delete/update exceeds max depth of 15.")

	// ErrDuplicateEntry is returns when a duplicate entry is placed on an index such as a UNIQUE or a Primary Key.
	ErrDuplicateEntry = errors.NewKind("Duplicate entry for key '%s'")

	// ErrInvalidArgument is returned when an argument to a function is invalid.
	ErrInvalidArgument = errors.NewKind("Invalid argument to %s")

	// ErrInvalidArgumentDetails is returned when the argument is invalid with details of a specific function
	ErrInvalidArgumentDetails = errors.NewKind("Invalid argument to %s: %s")

	// ErrSavepointDoesNotExist is returned when a RELEASE SAVEPOINT or ROLLBACK TO SAVEPOINT statement references a
	// non-existent savepoint identifier
	ErrSavepointDoesNotExist = errors.NewKind("SAVEPOINT %s does not exist")

	// ErrTemporaryTableNotSupported is thrown when an integrator attempts to create a temporary tables without temporary table
	// support.
	ErrTemporaryTableNotSupported = errors.NewKind("database does not support temporary tables")

	// ErrInvalidSyntax is returned for syntax errors that aren't picked up by the parser, e.g. the wrong type of
	// expression used in part of statement.
	ErrInvalidSyntax = errors.NewKind("Invalid syntax: %s")

	// ErrTableCopyingNotSupported is returned when a table invokes the TableCopierDatabase interface's
	// CopyTableData method without supporting the interface
	ErrTableCopyingNotSupported = errors.NewKind("error: Table copying not supported")

	// ErrMultiplePrimaryKeysDefined is returned when a table invokes CreatePrimaryKey with a primary key already
	// defined.
	ErrMultiplePrimaryKeysDefined = errors.NewKind("error: Multiple primary keys defined")

	// ErrWrongAutoKey is returned when a table invokes DropPrimaryKey without first removing the auto increment property
	// (if it exists) on it.
	ErrWrongAutoKey = errors.NewKind("error: incorrect table definition: there can be only one auto column and it must be defined as a key")

	// ErrKeyColumnDoesNotExist is returned when a table invoked CreatePrimaryKey with a non-existent column.
	ErrKeyColumnDoesNotExist = errors.NewKind("error: key column '%s' doesn't exist in table")

	// ErrCantDropFieldOrKey is returned when a table invokes DropPrimaryKey on a keyless table.
	ErrCantDropFieldOrKey = errors.NewKind("error: can't drop '%s'; check that column/key exists")

	// ErrCantDropIndex is return when a table can't drop an index due to a foreign key relationship.
	ErrCantDropIndex = errors.NewKind("error: can't drop index '%s': needed in a foreign key constraint")

	// ErrImmutableDatabaseProvider is returned when attempting to edit an immutable database databaseProvider.
	ErrImmutableDatabaseProvider = errors.NewKind("error: can't modify database databaseProvider")

	// ErrInvalidValue is returned when a given value does not match what is expected.
	ErrInvalidValue = errors.NewKind(`error: '%v' is not a valid value for '%v'`)

	// ErrInvalidValueType is returned when a given value's type does not match what is expected.
	ErrInvalidValueType = errors.NewKind(`error: '%T' is not a valid value type for '%v'`)

	// ErrFunctionNotFound is thrown when a function is not found
	ErrFunctionNotFound = errors.NewKind("function: '%s' not found")

	// ErrConflictingExternalQuery is thrown when a scope's parent has a conflicting sort or limit node
	ErrConflictingExternalQuery = errors.NewKind("found external scope with conflicting ORDER BY/LIMIT")

	// ErrTableFunctionNotFound is thrown when a table function is not found
	ErrTableFunctionNotFound = errors.NewKind("table function: '%s' not found")

	// ErrInvalidArgumentNumber is returned when the number of arguments to call a
	// function is different from the function arity.
	ErrInvalidArgumentNumber = errors.NewKind("function '%s' expected %v arguments, %v received")

	// ErrDatabaseNotFound is thrown when a database is not found
	ErrDatabaseNotFound = errors.NewKind("database not found: %s")

	// ErrNoDatabaseSelected is thrown when a database is not selected and the query requires one
	ErrNoDatabaseSelected = errors.NewKind("no database selected")

	// ErrAsOfNotSupported is thrown when an AS OF query is run on a database that can't support it
	ErrAsOfNotSupported = errors.NewKind("AS OF not supported for database %s")

	// ErrIncompatibleAsOf is thrown when an AS OF clause is used in an incompatible manner, such as when using an AS OF
	// expression with a view when the view definition has its own AS OF expressions.
	ErrIncompatibleAsOf = errors.NewKind("incompatible use of AS OF: %s")

	// ErrPidAlreadyUsed is returned when the pid is already registered.
	ErrPidAlreadyUsed = errors.NewKind("pid %d is already in use")

	// ErrInvalidOperandColumns is returned when the columns in the left
	// operand and the elements of the right operand don't match. Also
	// returned for invalid number of columns in projections, filters,
	// joins, etc.
	ErrInvalidOperandColumns = errors.NewKind("operand should have %d columns, but has %d")

	// ErrReadOnlyTransaction is returned when a write query is executed in a READ ONLY transaction.
	ErrReadOnlyTransaction = errors.NewKind("cannot execute statement in a READ ONLY transaction")

	// ErrLockDeadlock is the go-mysql-server equivalent of ER_LOCK_DEADLOCK. Transactions throwing this error
	// are automatically rolled back. Clients receiving this error must retry the transaction.
	ErrLockDeadlock = errors.NewKind("serialization failure: %s, try restarting transaction.")

	// ErrExistingView is returned when a CREATE VIEW statement uses a name that already exists
	ErrExistingView = errors.NewKind("the view %s.%s already exists")

	// ErrViewDoesNotExist is returned when a DROP VIEW statement drops a view that does not exist
	ErrViewDoesNotExist = errors.NewKind("the view %s.%s does not exist")

	// ErrSessionDoesNotSupportPersistence is thrown when a feature is not already supported
	ErrSessionDoesNotSupportPersistence = errors.NewKind("session does not support persistence")

	// ErrInvalidGISData is thrown when a "ST_<spatial_type>FromText" function receives a malformed string
	ErrInvalidGISData = errors.NewKind("invalid GIS data provided to function %s")

	// ErrIllegalGISValue is thrown when a spatial type constructor receives a non-geometric when one should be provided
	ErrIllegalGISValue = errors.NewKind("illegal non geometric '%v' value found during parsing")

	// ErrUnsupportedGISType is thrown when attempting to convert an unsupported geospatial value to a geometry struct
	ErrUnsupportedGISType = errors.NewKind("unsupported geospatial type: %s from value: 0x%s")

	// ErrUnsupportedSyntax is returned when syntax that parses correctly is not supported
	ErrUnsupportedSyntax = errors.NewKind("unsupported syntax: %s")

	// ErrInvalidSQLValType is returned when a SQL value is of the incorrect type during parsing
	ErrInvalidSQLValType = errors.NewKind("invalid SQLVal of type: %d")

	// ErrInvalidIndexPrefix is returned when an index prefix is outside the accepted range
	ErrInvalidIndexPrefix = errors.NewKind("invalid index prefix: %v")

	// ErrUnknownIndexColumn is returned when a column in an index is not in the table
	ErrUnknownIndexColumn = errors.NewKind("unknown column: '%s' in index '%s'")

	// ErrInvalidAutoIncCols is returned when an auto_increment column cannot be applied
	ErrInvalidAutoIncCols = errors.NewKind("there can be only one auto_increment column and it must be defined as a key")

	// ErrUnknownConstraintDefinition is returned when an unknown constraint type is used
	ErrUnknownConstraintDefinition = errors.NewKind("unknown constraint definition: %s, %T")

	// ErrInvalidCheckConstraint is returned when a check constraint is defined incorrectly
	ErrInvalidCheckConstraint = errors.NewKind("invalid constraint definition: %s")

	// ErrUserCreationFailure is returned when attempting to create a user and it fails for any reason.
	ErrUserCreationFailure = errors.NewKind("Operation CREATE USER failed for %s")

	// ErrRoleCreationFailure is returned when attempting to create a role and it fails for any reason.
	ErrRoleCreationFailure = errors.NewKind("Operation CREATE ROLE failed for %s")

	// ErrUserDeletionFailure is returned when attempting to create a user and it fails for any reason.
	ErrUserDeletionFailure = errors.NewKind("Operation DROP USER failed for %s")

	// ErrRoleDeletionFailure is returned when attempting to create a role and it fails for any reason.
	ErrRoleDeletionFailure = errors.NewKind("Operation DROP ROLE failed for %s")

	// ErrDatabaseAccessDeniedForUser is returned when attempting to access a database that the user does not have
	// permission for, regardless of whether that database actually exists.
	ErrDatabaseAccessDeniedForUser = errors.NewKind("Access denied for user %s to database '%s'")

	// ErrTableAccessDeniedForUser is returned when attempting to access a table that the user does not have permission
	// for, regardless of whether that table actually exists.
	ErrTableAccessDeniedForUser = errors.NewKind("Access denied for user %s to table '%s'")

	// ErrPrivilegeCheckFailed is returned when a user does not have the correct privileges to perform an operation.
	ErrPrivilegeCheckFailed = errors.NewKind("command denied to user %s")

	// ErrGrantUserDoesNotExist is returned when a user does not exist when attempting to grant them privileges.
	ErrGrantUserDoesNotExist = errors.NewKind("You are not allowed to create a user with GRANT")

	// ErrRevokeUserDoesNotExist is returned when a user does not exist when attempting to revoke privileges from them.
	ErrRevokeUserDoesNotExist = errors.NewKind("There is no such grant defined for user '%s' on host '%s'")

	// ErrGrantRevokeRoleDoesNotExist is returned when a user or role does not exist when attempting to grant or revoke roles.
	ErrGrantRevokeRoleDoesNotExist = errors.NewKind("Unknown authorization ID %s")

	// ErrShowGrantsUserDoesNotExist is returned when a user does not exist when attempting to show their grants.
	ErrShowGrantsUserDoesNotExist = errors.NewKind("There is no such grant defined for user '%s' on host '%s'")

	// ErrInvalidRecursiveCteUnion is returned when a recursive CTE is not a UNION or UNION ALL node.
	ErrInvalidRecursiveCteUnion = errors.NewKind("recursive cte top-level query must be a union; found: %v")

	// ErrInvalidRecursiveCteInitialQuery is returned when the recursive CTE base clause is not supported.
	ErrInvalidRecursiveCteInitialQuery = errors.NewKind("recursive cte initial query must be non-recursive projection; found: %v")

	// ErrInvalidRecursiveCteRecursiveQuery is returned when the recursive CTE recursion clause is not supported.
	ErrInvalidRecursiveCteRecursiveQuery = errors.NewKind("recursive cte recursive query must be a recursive projection; found: %v")

	// ErrCteRecursionLimitExceeded is returned when a recursive CTE's execution stack depth exceeds the static limit.
	ErrCteRecursionLimitExceeded = errors.NewKind("WITH RECURSIVE iteration limit exceeded")

	// ErrGrantRevokeIllegalPrivilege is returned when a GRANT or REVOKE statement is malformed, or attempts to use privilege incorrectly.
	ErrGrantRevokeIllegalPrivilege = errors.NewKind("Illegal GRANT/REVOKE command")

	// ErrInvalidWindowInheritance is returned when a window and its dependency contains conflicting partitioning, ordering, or framing clauses
	ErrInvalidWindowInheritance = errors.NewKind("window '%s' cannot inherit '%s' since %s")

	// ErrCircularWindowInheritance is returned when a WINDOW clause has a circular dependency
	ErrCircularWindowInheritance = errors.NewKind("there is a circularity in the window dependency graph")

	// ErrCannotCopyWindowFrame is returned when we inherit a window frame with a frame clause (replacement without parenthesis is OK)
	ErrCannotCopyWindowFrame = errors.NewKind("cannot copy window '%s' because it has a frame clause")

	// ErrUnknownWindowName is returned when an over by clause references an unknown window definition
	ErrUnknownWindowName = errors.NewKind("named window not found: '%s'")

	// ErrUnexpectedNilRow is returned when an invalid operation is applied to an empty row
	ErrUnexpectedNilRow = errors.NewKind("unexpected nil row")

	// ErrMoreThanOneRow is returned when the result consists of multiple rows, when only one row is expected
	ErrMoreThanOneRow = errors.NewKind("Result consisted of more than one row")

	// ErrColumnNumberDoesNotMatch is returned when the number of columns in result does not match expected number of variables
	ErrColumnNumberDoesNotMatch = errors.NewKind("The used SELECT statements have a different number of columns")

	// ErrUnsupportedJoinFactorCount is returned for a query with more commutable join tables than we support
	ErrUnsupportedJoinFactorCount = errors.NewKind("unsupported join factor count: expected fewer than %d tables, found %d")

	// ErrNotMatchingSRID is returned for SRID values not matching
	ErrNotMatchingSRID = errors.NewKind("The SRID of the geometry is %v, but the SRID of the column is %v. Consider changing the SRID of the geometry or the SRID property of the column.")

	// ErrNotMatchingSRIDWithColName is returned for error of SRID values not matching with column name detail
	ErrNotMatchingSRIDWithColName = errors.NewKind("The SRID of the geometry does not match the SRID of the column '%s'. %v")

	// ErrSpatialTypeConversion is returned when one spatial type cannot be converted to the other spatial type
	ErrSpatialTypeConversion = errors.NewKind("Cannot get geometry object from data you sent to the GEOMETRY field")

	// ErrInvalidBytePrimaryKey is returned when attempting to create a primary key with a byte column
	ErrInvalidBytePrimaryKey = errors.NewKind("invalid primary key on byte column '%s'")

	// ErrInvalidByteIndex is returned for an index on a byte column with no prefix or an invalid prefix
	ErrInvalidByteIndex = errors.NewKind("index on byte column '%s' unsupported")

	// ErrInvalidTextIndex is returned for an index on a byte column with no prefix or an invalid prefix
	ErrInvalidTextIndex = errors.NewKind("index on text column '%s' unsupported")

	// ErrDatabaseWriteLocked is returned when a database is locked in read-only mode to avoid
	// conflicts with an active server
	ErrDatabaseWriteLocked = errors.NewKind("database is locked to writes")

	// ErrCollationMalformedString is returned when a malformed string is encountered during a collation-related operation.
	ErrCollationMalformedString = errors.NewKind("malformed string encountered while %s")

	// ErrCollatedExprWrongType is returned when the wrong type is given to a CollatedExpression.
	ErrCollatedExprWrongType = errors.NewKind("wrong type in collated expression")

	// ErrCollationInvalidForCharSet is returned when the wrong collation is given for the character set when parsing.
	ErrCollationInvalidForCharSet = errors.NewKind("COLLATION '%s' is not valid for CHARACTER SET '%s'")

	// ErrCollationUnknown is returned when the collation is not a recognized MySQL collation.
	ErrCollationUnknown = errors.NewKind("Unknown collation: %v")

	// ErrCollationNotYetImplementedTemp is returned when the collation is valid but has not yet been implemented.
	// This error is temporary, and will be removed once all collations have been added.
	ErrCollationNotYetImplementedTemp = errors.NewKind("The collation `%s` has not yet been implemented, " +
		"please create an issue at https://github.com/dolthub/go-mysql-server/issues/new and the DoltHub developers will implement it")

	// ErrCollationIllegalMix is returned when two different collations are used in a scenario where they are not compatible.
	ErrCollationIllegalMix = errors.NewKind("Illegal mix of collations (%v) and (%v)")

	// ErrCharSetIntroducer is returned when a character set introducer is not attached to a string
	ErrCharSetIntroducer = errors.NewKind("CHARACTER SET introducer must be attached to a string")

	// ErrCharSetInvalidString is returned when an invalid string is given for a character set.
	ErrCharSetInvalidString = errors.NewKind("invalid string for character set `%s`: \"%s\"")

	// ErrCharSetFailedToEncode is returned when a character set fails encoding
	ErrCharSetFailedToEncode = errors.NewKind("failed to encode `%s`")

	// ErrCharSetUnknown is returned when the character set is not a recognized MySQL character set
	ErrCharSetUnknown = errors.NewKind("Unknown character set: %v")

	// ErrCharSetNotYetImplementedTemp is returned when the character set is valid but has not yet been implemented.
	// This error is temporary, and will be removed once all character sets have been added.
	ErrCharSetNotYetImplementedTemp = errors.NewKind("The character set `%s` has not yet been implemented, " +
		"please create an issue at https://github.com/dolthub/go-mysql-server/issues/new and the DoltHub developers will implement it")

	// ErrNoTablesUsed is returned when there is no table provided or dual table is defined with column access.
	ErrNoTablesUsed = errors.NewKind("No tables used")
)
View Source
var (
	ErrInvalidColExpr      = errors.NewKind("the expression `%s` could not be found from the index `%s`")
	ErrRangeSimplification = errors.NewKind("attempting to simplify ranges has removed all ranges")
	ErrInvalidRangeType    = errors.NewKind("encountered the RangeType_Invalid")
)
View Source
var (
	// ErrIndexIDAlreadyRegistered is the error returned when there is already
	// an index with the same ID.
	ErrIndexIDAlreadyRegistered = errors.NewKind("an index with id %q has already been registered")

	// ErrIndexExpressionAlreadyRegistered is the error returned when there is
	// already an index with the same expression.
	ErrIndexExpressionAlreadyRegistered = errors.NewKind("there is already an index registered for the expressions: %s")

	// ErrIndexNotFound is returned when the index could not be found.
	ErrIndexNotFound = errors.NewKind("index %q	was not found")

	// ErrIndexDeleteInvalidStatus is returned when the index trying to delete
	// does not have a ready or outdated state.
	ErrIndexDeleteInvalidStatus = errors.NewKind("can't delete index %q because it's not ready for removal")
)
View Source
var (
	ErrOutOfRange = errors.NewKind("%v out of range for %v")

	// Boolean is a synonym for TINYINT
	Boolean = Int8
	// Int8 is an integer of 8 bits
	Int8 = MustCreateNumberType(sqltypes.Int8)
	// Uint8 is an unsigned integer of 8 bits
	Uint8 = MustCreateNumberType(sqltypes.Uint8)
	// Int16 is an integer of 16 bits
	Int16 = MustCreateNumberType(sqltypes.Int16)
	// Uint16 is an unsigned integer of 16 bits
	Uint16 = MustCreateNumberType(sqltypes.Uint16)
	// Int24 is an integer of 24 bits.
	Int24 = MustCreateNumberType(sqltypes.Int24)
	// Uint24 is an unsigned integer of 24 bits.
	Uint24 = MustCreateNumberType(sqltypes.Uint24)
	// Int32 is an integer of 32 bits.
	Int32 = MustCreateNumberType(sqltypes.Int32)
	// Uint32 is an unsigned integer of 32 bits.
	Uint32 = MustCreateNumberType(sqltypes.Uint32)
	// Int64 is an integer of 64 bytes.
	Int64 = MustCreateNumberType(sqltypes.Int64)
	// Uint64 is an unsigned integer of 64 bits.
	Uint64 = MustCreateNumberType(sqltypes.Uint64)
	// Float32 is a floating point number of 32 bits.
	Float32 = MustCreateNumberType(sqltypes.Float32)
	// Float64 is a floating point number of 64 bits.
	Float64 = MustCreateNumberType(sqltypes.Float64)
)
View Source
var (
	ErrConvertingToSet   = errors.NewKind("value %v is not valid for this set")
	ErrDuplicateEntrySet = errors.NewKind("duplicate entry: %v")
	ErrInvalidSetValue   = errors.NewKind("value %v was not found in the set")
	ErrTooLargeForSet    = errors.NewKind(`value "%v" is too large for this set`)
)
View Source
var (
	// ErrLengthTooLarge is thrown when a string's length is too large given the other parameters.
	ErrLengthTooLarge    = errors.NewKind("length is %v but max allowed is %v")
	ErrLengthBeyondLimit = errors.NewKind("string '%v' is too large for column '%v'")
	ErrBinaryCollation   = errors.NewKind("binary types must have the binary collation")

	TinyText   = MustCreateStringWithDefaults(sqltypes.Text, tinyTextBlobMax)
	Text       = MustCreateStringWithDefaults(sqltypes.Text, textBlobMax)
	MediumText = MustCreateStringWithDefaults(sqltypes.Text, mediumTextBlobMax)
	LongText   = MustCreateStringWithDefaults(sqltypes.Text, longTextBlobMax)
	TinyBlob   = MustCreateBinary(sqltypes.Blob, tinyTextBlobMax)
	Blob       = MustCreateBinary(sqltypes.Blob, textBlobMax)
	MediumBlob = MustCreateBinary(sqltypes.Blob, mediumTextBlobMax)
	LongBlob   = MustCreateBinary(sqltypes.Blob, longTextBlobMax)
)
View Source
var (
	// ErrNodeNotWritten is returned when the children are printed before the node.
	ErrNodeNotWritten = errors.New("treeprinter: a child was written before the node")
	// ErrNodeAlreadyWritten is returned when the node has already been written.
	ErrNodeAlreadyWritten = errors.New("treeprinter: node already written")
	// ErrChildrenAlreadyWritten is returned when the children have already been written.
	ErrChildrenAlreadyWritten = errors.New("treeprinter: children already written")
)
View Source
var (
	// ErrNotTuple is returned when the value is not a tuple.
	ErrNotTuple = errors.NewKind("value of type %T is not a tuple")

	// ErrInvalidColumnNumber is returned when a tuple has an invalid number of
	// arguments.
	ErrInvalidColumnNumber = errors.NewKind("tuple should contain %d column(s), but has %d")

	ErrInvalidBaseType = errors.NewKind("%v is not a valid %v base type")

	// ErrNotArray is returned when the value is not an array.
	ErrNotArray = errors.NewKind("value of type %T is not an array")

	// ErrConvertToSQL is returned when Convert failed.
	// It makes an error less verbose comparing to what spf13/cast returns.
	ErrConvertToSQL = errors.NewKind("incompatible conversion to SQL type: %s")
)
View Source
var ErrCannotAddToClosedBackgroundThreads = errors.New("cannot add to a close background threads instance")
View Source
var ErrKeyNotFound = errors.NewKind("memory: key %d not found in cache")

ErrKeyNotFound is returned when the key could not be found in the cache.

View Source
var ErrLockDoesNotExist = errors.NewKind("Lock '%s' does not exist.")

ErrLockDoesNotExist is the kind of error returned when a named lock does not exist and the operation does not created it

View Source
var ErrLockNotOwned = errors.NewKind("Operation '%s' failed as the lock '%s' has a different owner.")

ErrLockNotOwned is the kind of error returned when attempting an operation against a lock that the given context does not own.

View Source
var ErrLockTimeout = errors.NewKind("Timeout acquiring lock '%s'.")

ErrLockTimeout is the kind of error returned when acquiring a lock takes longer than the user specified timeout

View Source
var ErrNoAutoIncrementCol = fmt.Errorf("this table has no AUTO_INCREMENT columns")
View Source
var ErrNoMemoryAvailable = errors.NewKind("no memory available")

ErrNoMemoryAvailable is returned when there is no more available memory.

View Source
var ErrNotGenerator = errors.NewKind("cannot convert value of type %T to a generator")

ErrNotGenerator is returned when the value cannot be converted to a generator.

View Source
var (
	ErrNotGeomColl = errors.NewKind("value of type %T is not a point")
)
View Source
var (
	ErrNotGeometry = errors.NewKind("Value of type %T is not a geometry")
)
View Source
var (
	ErrNotLineString = errors.NewKind("value of type %T is not a linestring")
)
View Source
var (
	ErrNotMultiLineString = errors.NewKind("value of type %T is not a multilinestring")
)
View Source
var (
	ErrNotMultiPoint = errors.NewKind("value of type %T is not a multipoint")
)
View Source
var (
	ErrNotMultiPolygon = errors.NewKind("value of type %T is not a multipolygon")
)
View Source
var (
	ErrNotPoint = errors.NewKind("value of type %T is not a point")
)
View Source
var (
	ErrNotPolygon = errors.NewKind("value of type %T is not a polygon")
)
View Source
var ErrUnableSort = errors.NewKind("unable to sort")

ErrUnableSort is thrown when something happens on sorting

View Source
var (
	// ErrUnexpectedType is thrown when a received type is not the expected
	ErrUnexpectedType = errors.NewKind("value at %d has unexpected type: %s")
)
View Source
var (
	MaxJsonFieldByteLength = int64(1024) * int64(1024) * int64(1024)
)
View Source
var NoopTracer = trace.NewNoopTracerProvider().Tracer("github.com/dolthub/go-mysql-server/sql")
View Source
var OkResultColumnType = Int64

OkResultColumnType should be used as the schema column type for Nodes that return an OkResult

View Source
var OkResultSchema = Schema{
	{
		Name: OkResultColumnName,
		Type: OkResultColumnType,
	},
}

OkResultSchema should be used as the schema of Nodes that return an OkResult

View Source
var SupportedCharsets = []CharacterSetID{
	CharacterSet_utf8mb4,
}

SupportedCharsets contains all non-binary character sets that are currently supported.

View Source
var SupportedEngines = []Engine{
	{Name: "InnoDB", /* contains filtered or unexported fields */},
}
View Source
var SystemVariables = &globalSystemVariables{&sync.RWMutex{}, make(map[string]interface{})}

SystemVariables is the collection of system variables for this process.

Functions

func AreComparable

func AreComparable(types ...Type) bool

AreComparable returns whether the given types are either the same or similar enough that values can meaningfully be compared across all permutations. Int8 and Int64 are comparable types, where as VarChar and Int64 are not. In the case of the latter example, not all possible values of a VarChar are comparable to an Int64, while this is true for the former example.

func CastSQLError added in v0.9.0

func CastSQLError(err error) *mysql.SQLError

CastSQLError returns a *mysql.SQLError with the error code and in some cases, also a SQL state, populated for the specified error object. Using this method enables Vitess to return an error code, instead of just "unknown error". Many tools (e.g. ORMs, SQL workbenches) rely on this error metadata to work correctly. If the specified error is nil, nil will be returned. If the error is already of type *mysql.SQLError, the error will be returned as is.

func ConvertToBool

func ConvertToBool(v interface{}) (bool, error)

func ConvertToString added in v0.14.0

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

func ConvertToTime added in v0.14.0

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

func DBTableIter

func DBTableIter(ctx *Context, db Database, cb func(Table) (cont bool, err error)) error

DBTableIter iterates over all tables returned by db.GetTableNames() calling cb for each one until all tables have been processed, or an error is returned from the callback, or the cont flag is false when returned from the callback.

func DebugString

func DebugString(nodeOrExpression interface{}) string

DebugString returns a debug string for the Node or Expression given.

func DeepCopyJson added in v0.12.0

func DeepCopyJson(v interface{}) interface{}

DeepCopyJson implements deep copy of JSON document

func DeserializeEWKBHeader added in v0.14.0

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

DeserializeEWKBHeader parses the header portion of a byte array in EWKB format to extract endianness and type

func DeserializeWKBHeader added in v0.14.0

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

DeserializeWKBHeader parses the header potion of a byte array in WKB format There is no SRID

func Dispose added in v0.11.0

func Dispose(i interface{})

func ErrIfMismatchedColumns added in v0.11.0

func ErrIfMismatchedColumns(t1, t2 Type) error

ErrIfMismatchedColumns returns an operand error if the number of columns in t1 is not equal to the number of columns in t2. If the number of columns is equal, and both types are tuple types, it recurses into each subtype, asserting that those subtypes are structurally identical as well.

func ErrIfMismatchedColumnsInTuple added in v0.11.0

func ErrIfMismatchedColumnsInTuple(t1, t2 Type) error

ErrIfMismatchedColumnsInTuple returns an operand error is t2 is not a tuple type whose subtypes are structurally identical to t1.

func EvaluateCondition

func EvaluateCondition(ctx *Context, cond Expression, row Row) (interface{}, error)

EvaluateCondition evaluates a condition, which is an expression whose value will be nil or coerced boolean.

func FormatRow

func FormatRow(row Row) string

FormatRow returns a formatted string representing this row's values

func GetRangeCutKey added in v0.12.0

func GetRangeCutKey(c RangeCut) interface{}

GetRangeCutKey returns the inner value from the given RangeCut.

func GetTableNameInsensitive

func GetTableNameInsensitive(tblName string, tableNames []string) (string, bool)

GetTableNameInsensitive implements a case insensitive search of a slice of table names. It looks for exact matches first. If no exact matches are found then any table matching the name case insensitively should be returned. If there is more than one table that matches a case insensitive comparison the resolution strategy is not defined.

func HasAvailableMemory

func HasAvailableMemory(r Reporter) bool

HasAvailableMemory reports whether more memory is available to the program if it hasn't reached the max memory limit.

func HasDefaultValue

func HasDefaultValue(ctx *Context, s Session, key string) (bool, interface{})

HasDefaultValue checks if session variable value is the default one.

func HashOf

func HashOf(v Row) (uint64, error)

HashOf returns a hash of the given value to be used as key in a cache.

func InitSystemVariables added in v0.12.0

func InitSystemVariables()

InitSystemVariables resets the systemVars singleton

func Inspect

func Inspect(expr Expression, f func(expr Expression) bool)

Inspect traverses the plan in depth-first order: It starts by calling f(expr); expr must not be nil. If f returns true, Inspect invokes f recursively for each of the children of expr, followed by a call of f(nil).

func IsBinaryType added in v0.14.0

func IsBinaryType(t Type) bool

IsBinaryType checks if t is BINARY, VARBINARY, or BLOB

func IsByteType added in v0.14.0

func IsByteType(t Type) bool

IsByteType checks if t is BINARY, VARBINARY, or BLOB

func IsDecimal

func IsDecimal(t Type) bool

IsDecimal checks if t is a DECIMAL type.

func IsDeferredType added in v0.12.0

func IsDeferredType(t Type) bool

func IsEnum added in v0.14.0

func IsEnum(t Type) bool

IsEnum checks if t is a enum

func IsFalse added in v0.10.0

func IsFalse(val interface{}) bool

IsFalse coerces EvaluateCondition interface{} response to boolean

func IsFloat

func IsFloat(t Type) bool

IsFloat checks if t is float type.

func IsGeometry added in v0.14.0

func IsGeometry(t Type) bool

IsGeometry returns true if the specified type is a Geometry type.

func IsInteger

func IsInteger(t Type) bool

IsInteger checks if t is an integer type.

func IsJSON added in v0.9.0

func IsJSON(t Type) bool

IsJSON returns true if the specified type is a JSON type.

func IsKeyless added in v0.11.0

func IsKeyless(s Schema) bool

func IsNull

func IsNull(ex Expression) bool

IsNull returns true if expression is nil or is Null Type, otherwise false.

func IsNumber

func IsNumber(t Type) bool

IsNumber checks if t is a number type

func IsOkResult added in v0.9.0

func IsOkResult(row Row) bool

IsOkResult returns whether the given row represents an OkResult.

func IsOkResultSchema added in v0.11.0

func IsOkResultSchema(schema Schema) bool

func IsSet added in v0.14.0

func IsSet(t Type) bool

IsEnum checks if t is a set

func IsSigned

func IsSigned(t Type) bool

IsSigned checks if t is a signed type.

func IsText

func IsText(t Type) bool

IsText checks if t is a CHAR, VARCHAR, TEXT, BINARY, VARBINARY, or BLOB (including TEXT and BLOB variants).

func IsTextBlob

func IsTextBlob(t Type) bool

IsTextBlob checks if t is one of the TEXTs or BLOBs.

func IsTextOnly

func IsTextOnly(t Type) bool

IsTextOnly checks if t is CHAR, VARCHAR, or one of the TEXTs.

func IsTime

func IsTime(t Type) bool

IsTime checks if t is a timestamp, date or datetime

func IsTrue added in v0.10.0

func IsTrue(val interface{}) bool

IsTrue coerces EvaluateCondition interface{} response to boolean

func IsTuple

func IsTuple(t Type) bool

IsTuple checks if t is a tuple type. Note that TupleType instances with just 1 value are not considered as a tuple, but a parenthesized value.

func IsUnsigned

func IsUnsigned(t Type) bool

IsUnsigned checks if t is an unsigned type.

func MustConvert added in v0.9.0

func MustConvert(val interface{}, err error) interface{}

func NewMapCache

func NewMapCache() mapCache

func NewUniqueKeyErr added in v0.10.0

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

func NumColumns

func NumColumns(t Type) int

NumColumns returns the number of columns in a type. This is one for all types, except tuples.

func NumericUnaryValue

func NumericUnaryValue(t Type) interface{}

func OrderedCuts added in v0.12.0

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

OrderedCuts returns the given Cuts in order from lowest-touched values to highest-touched values.

func RangeCutIsBinding added in v0.12.0

func RangeCutIsBinding(c RangeCut) bool

func RunWithNowFunc

func RunWithNowFunc(nowFunc func() time.Time, fn func() error) error

func TypesEqual

func TypesEqual(a, b Type) bool

TypesEqual compares two Types and returns whether they are equivalent.

func UnwrapError added in v0.14.0

func UnwrapError(err error) error

UnwrapError removes any wrapping errors (e.g. WrappedInsertError) around the specified error and returns the first non-wrapped error type.

func ValidateTime

func ValidateTime(t time.Time) interface{}

ValidateTime receives a time and returns either that time or nil if it's not a valid time.

func Walk

func Walk(v Visitor, expr Expression)

Walk traverses the expression tree in depth-first order. It starts by calling v.Visit(expr); expr must not be nil. If the visitor returned by v.Visit(expr) is not nil, Walk is invoked recursively with the returned visitor for each children of the expr, followed by a call of v.Visit(nil) to the returned visitor.

func WalkWithNode

func WalkWithNode(v NodeVisitor, n Node, expr Expression)

WalkWithNode traverses the expression tree in depth-first order. It starts by calling v.Visit(node, expr); expr must not be nil. If the visitor returned by v.Visit(node, expr) is not nil, Walk is invoked recursively with the returned visitor for each children of the expr, followed by a call of v.Visit(nil, nil) to the returned visitor.

func WriteEWKBHeader added in v0.14.0

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

WriteEWKBHeader will write EWKB header to the given buffer

func WriteWKBHeader added in v0.14.0

func WriteWKBHeader(buf []byte, typ uint32)

WriteWKBHeader will write WKB header to the given buffer

Types

type Above added in v0.12.0

type Above struct {
	Key interface{}
}

Above represents the position immediately above the contained key.

func (Above) Compare added in v0.12.0

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

Compare implements RangeCut.

func (Above) String added in v0.12.0

func (a Above) String() string

String implements RangeCut.

func (Above) TypeAsLowerBound added in v0.12.0

func (Above) TypeAsLowerBound() RangeBoundType

TypeAsLowerBound implements RangeCut.

func (Above) TypeAsUpperBound added in v0.12.0

func (Above) TypeAsUpperBound() RangeBoundType

TypeAsUpperBound implements RangeCut.

type AboveAll added in v0.12.0

type AboveAll struct{}

AboveAll represents the position beyond the maximum possible value.

func (AboveAll) Compare added in v0.12.0

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

Compare implements RangeCut.

func (AboveAll) String added in v0.12.0

func (AboveAll) String() string

String implements RangeCut.

func (AboveAll) TypeAsLowerBound added in v0.12.0

func (AboveAll) TypeAsLowerBound() RangeBoundType

TypeAsLowerBound implements RangeCut.

func (AboveAll) TypeAsUpperBound added in v0.12.0

func (AboveAll) TypeAsUpperBound() RangeBoundType

TypeAsUpperBound implements RangeCut.

type AboveNull added in v0.14.0

type AboveNull struct{}

AboveNull represents the position just above NULL, lower than every possible value in the domain.

func (AboveNull) Compare added in v0.14.0

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

Compare implements RangeCut.

func (AboveNull) String added in v0.14.0

func (AboveNull) String() string

String implements RangeCut.

func (AboveNull) TypeAsLowerBound added in v0.14.0

func (AboveNull) TypeAsLowerBound() RangeBoundType

TypeAsLowerBound implements RangeCut.

func (AboveNull) TypeAsUpperBound added in v0.14.0

func (AboveNull) TypeAsUpperBound() RangeBoundType

TypeAsUpperBound implements RangeCut.

type Aggregation

type Aggregation interface {
	WindowAdaptableExpression
	// NewBuffer creates a new aggregation buffer and returns it as a Row.
	NewBuffer() (AggregationBuffer, error)
	// WithWindow returns a version of this aggregation with the WindowDefinition given
	WithWindow(window *WindowDefinition) (Aggregation, error)
	// Window returns this expression's window
	Window() *WindowDefinition
}

Aggregation implements an aggregation expression, where an aggregation buffer is created for each grouping (NewBuffer). Rows for the grouping should be fed to the buffer with |Update| and the buffer should be eval'd with |Eval|. Calling |Eval| directly on an Aggregation expression is typically an error.

type AggregationBuffer added in v0.11.0

type AggregationBuffer interface {
	Disposable

	// Eval the given buffer.
	Eval(*Context) (interface{}, error)
	// Update the given buffer with the given row.
	Update(ctx *Context, row Row) error
}

type AlterableTable

type AlterableTable interface {
	Table
	UpdatableTable

	// AddColumn adds a column to this table as given. If non-nil, order specifies where in the schema to add the column.
	AddColumn(ctx *Context, column *Column, order *ColumnOrder) error
	// DropColumn drops the column with the name given.
	DropColumn(ctx *Context, columnName string) error
	// ModifyColumn modifies the column with the name given, replacing with the new column definition provided (which may
	// include a name change). If non-nil, order specifies where in the schema to move the column.
	ModifyColumn(ctx *Context, columnName string, column *Column, order *ColumnOrder) error
}

AlterableTable should be implemented by tables that can receive ALTER TABLE statements to modify their schemas.

type AutoIncrementSetter

type AutoIncrementSetter interface {
	// SetAutoIncrementValue sets a new AUTO_INCREMENT value.
	SetAutoIncrementValue(*Context, uint64) error
	// Close finalizes the set operation, persisting the result.
	Closer
}

AutoIncrementSetter provides support for altering a table's AUTO_INCREMENT sequence, eg 'ALTER TABLE t AUTO_INCREMENT = 10;'

type AutoIncrementTable

type AutoIncrementTable interface {
	Table
	// GetNextAutoIncrementValue gets the next AUTO_INCREMENT value. In the case that a table with an autoincrement
	// column is passed in a row with the autoinc column failed, the next auto increment value must
	// update its internal state accordingly and use the insert val at runtime.
	// Implementations are responsible for updating their state to provide the correct values.
	GetNextAutoIncrementValue(ctx *Context, insertVal interface{}) (uint64, error)
	// AutoIncrementSetter returns an AutoIncrementSetter.
	AutoIncrementSetter(*Context) AutoIncrementSetter
}

AutoIncrementTable is a table that supports AUTO_INCREMENT. Getter and Setter methods access the table's AUTO_INCREMENT sequence. These methods should only be used for tables with and AUTO_INCREMENT column in their schema.

type BackgroundThreads added in v0.12.0

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

func NewBackgroundThreads added in v0.12.0

func NewBackgroundThreads() *BackgroundThreads

func (*BackgroundThreads) Add added in v0.12.0

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

Add starts a background goroutine wrapped by a top-level sync.WaitGroup. [f] must return when its [ctx] argument is cancelled, otherwise Shutdown will hang.

func (*BackgroundThreads) Shutdown added in v0.12.0

func (bt *BackgroundThreads) Shutdown() error

Shutdown cancels the parent context for every async thread, and waits for each goroutine to drain and return before exiting.

type BaseSession

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

BaseSession is the basic session type.

func NewBaseSession

func NewBaseSession() *BaseSession

NewBaseSession creates a new empty session.

func NewBaseSessionWithClientServer added in v0.12.0

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

NewBaseSessionWithClientServer creates a new session with data.

func (*BaseSession) AddLock

func (s *BaseSession) AddLock(lockName string) error

AddLock adds a lock to the set of locks owned by this user which will need to be released if this session terminates

func (*BaseSession) Address

func (s *BaseSession) Address() string

Address returns the server address.

func (*BaseSession) ClearWarnings

func (s *BaseSession) ClearWarnings()

ClearWarnings cleans up session warnings

func (*BaseSession) Client

func (s *BaseSession) Client() Client

Client returns session's client information.

func (*BaseSession) CommitTransaction

func (s *BaseSession) CommitTransaction(*Context, string, Transaction) error

CommitTransaction commits the current transaction for the current database.

func (*BaseSession) DelLock

func (s *BaseSession) DelLock(lockName string) error

DelLock removes a lock from the set of locks owned by this user

func (*BaseSession) GetAllSessionVariables added in v0.10.0

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

GetAllSessionVariables implements the Session interface.

func (*BaseSession) GetCharacterSet added in v0.14.0

func (s *BaseSession) GetCharacterSet() CharacterSetID

GetCharacterSet returns the character set for this session (defined by the system variable `character_set_connection`).

func (*BaseSession) GetCharacterSetResults added in v0.14.0

func (s *BaseSession) GetCharacterSetResults() CharacterSetID

GetCharacterSetResults returns the result character set for this session (defined by the system variable `character_set_results`).

func (*BaseSession) GetCollation added in v0.14.0

func (s *BaseSession) GetCollation() CollationID

GetCollation returns the collation for this session (defined by the system variable `collation_connection`).

func (*BaseSession) GetCurrentDatabase

func (s *BaseSession) GetCurrentDatabase() string

GetCurrentDatabase gets the current database for this session

func (*BaseSession) GetIgnoreAutoCommit added in v0.10.0

func (s *BaseSession) GetIgnoreAutoCommit() bool

func (*BaseSession) GetIndexRegistry added in v0.11.0

func (s *BaseSession) GetIndexRegistry() *IndexRegistry

func (*BaseSession) GetLastQueryInfo added in v0.9.0

func (s *BaseSession) GetLastQueryInfo(key string) int64

func (*BaseSession) GetLogger added in v0.11.0

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

func (*BaseSession) GetQueriedDatabase added in v0.9.0

func (s *BaseSession) GetQueriedDatabase() string

GetQueriedDatabase implements the Session interface.

func (*BaseSession) GetSessionVariable added in v0.10.0

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

GetSessionVariable implements the Session interface.

func (*BaseSession) GetTransaction added in v0.10.0

func (s *BaseSession) GetTransaction() Transaction

func (*BaseSession) GetUserVariable added in v0.10.0

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

GetUserVariable implements the Session interface.

func (*BaseSession) GetViewRegistry added in v0.11.0

func (s *BaseSession) GetViewRegistry() *ViewRegistry

func (*BaseSession) ID

func (s *BaseSession) ID() uint32

ID implements the Session interface.

func (*BaseSession) InitSessionVariable added in v0.14.0

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

InitSessionVariable implements the Session interface and is used to initialize variables (Including read-only variables)

func (*BaseSession) IterLocks

func (s *BaseSession) IterLocks(cb func(name string) error) error

IterLocks iterates through all locks owned by this user

func (*BaseSession) SetClient added in v0.12.0

func (s *BaseSession) SetClient(c Client)

SetClient implements the Session interface.

func (*BaseSession) SetConnectionId added in v0.12.0

func (s *BaseSession) SetConnectionId(id uint32)

SetConnectionId sets the [id] for this session

func (*BaseSession) SetCurrentDatabase

func (s *BaseSession) SetCurrentDatabase(dbName string)

SetCurrentDatabase sets the current database for this session

func (*BaseSession) SetIgnoreAutoCommit added in v0.10.0

func (s *BaseSession) SetIgnoreAutoCommit(ignore bool)

func (*BaseSession) SetIndexRegistry added in v0.11.0

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

func (*BaseSession) SetLastQueryInfo added in v0.9.0

func (s *BaseSession) SetLastQueryInfo(key string, value int64)

func (*BaseSession) SetLogger added in v0.11.0

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

func (*BaseSession) SetQueriedDatabase added in v0.9.0

func (s *BaseSession) SetQueriedDatabase(dbName string)

SetQueriedDatabase implements the Session interface.

func (*BaseSession) SetSessionVariable added in v0.10.0

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

SetSessionVariable implements the Session interface.

func (*BaseSession) SetTransaction added in v0.10.0

func (s *BaseSession) SetTransaction(tx Transaction)

func (*BaseSession) SetUserVariable added in v0.10.0

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

SetUserVariable implements the Session interface.

func (*BaseSession) SetViewRegistry added in v0.11.0

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

func (*BaseSession) ValidateSession added in v0.14.0

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

ValidateSession provides integrators a chance to do any custom validation of this session before any query is executed in it.

func (*BaseSession) Warn

func (s *BaseSession) Warn(warn *Warning)

Warn stores the warning in the session.

func (*BaseSession) WarningCount

func (s *BaseSession) WarningCount() uint16

WarningCount returns a number of session warnings

func (*BaseSession) Warnings

func (s *BaseSession) Warnings() []*Warning

Warnings returns a copy of session warnings (from the most recent - the last one) The function implements sql.Session interface

type Below added in v0.12.0

type Below struct {
	Key interface{}
}

Below represents the position immediately below the contained key.

func (Below) Compare added in v0.12.0

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

Compare implements RangeCut.

func (Below) String added in v0.12.0

func (b Below) String() string

String implements RangeCut.

func (Below) TypeAsLowerBound added in v0.12.0

func (Below) TypeAsLowerBound() RangeBoundType

TypeAsLowerBound implements RangeCut.

func (Below) TypeAsUpperBound added in v0.12.0

func (Below) TypeAsUpperBound() RangeBoundType

TypeAsUpperBound implements RangeCut.

type BelowNull added in v0.14.0

type BelowNull struct{}

BelowNull represents the position below NULL, which sorts before |AboveNull| and every non-NULL value in the domain.

func (BelowNull) Compare added in v0.14.0

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

Compare implements RangeCut.

func (BelowNull) String added in v0.14.0

func (BelowNull) String() string

String implements RangeCut.

func (BelowNull) TypeAsLowerBound added in v0.14.0

func (BelowNull) TypeAsLowerBound() RangeBoundType

TypeAsLowerBound implements RangeCut.

func (BelowNull) TypeAsUpperBound added in v0.14.0

func (BelowNull) TypeAsUpperBound() RangeBoundType

TypeAsUpperBound implements RangeCut.

type BinaryNode added in v0.12.0

type BinaryNode interface {
	Left() Node
	Right() Node
}

BinaryNode has two children

type BitType

type BitType interface {
	Type
	NumberOfBits() uint8
}

BitType represents the BIT type. https://dev.mysql.com/doc/refman/8.0/en/bit-type.html The type of the returned value is uint64.

func CreateBitType

func CreateBitType(numOfBits uint8) (BitType, error)

CreateBitType creates a BitType.

func MustCreateBitType

func MustCreateBitType(numOfBits uint8) BitType

MustCreateBitType is the same as CreateBitType except it panics on errors.

type Catalog

type Catalog interface {
	// AllDatabases returns all databases known to this catalog
	AllDatabases(ctx *Context) []Database

	// HasDB returns whether a db with the name given exists, case-insensitive
	HasDB(ctx *Context, db string) bool

	// Database returns the database with the name given, case-insensitive, or an error if it doesn't exist
	Database(ctx *Context, db string) (Database, error)

	// CreateDatabase creates a new database, or returns an error if the operation isn't supported or fails.
	CreateDatabase(ctx *Context, dbName string, collation CollationID) error

	// RemoveDatabase removes the  database named, or returns an error if the operation isn't supported or fails.
	RemoveDatabase(ctx *Context, dbName string) error

	// Table returns the table with the name given in the db with the name given
	Table(ctx *Context, dbName, tableName string) (Table, Database, error)

	// TableAsOf returns the table with the name given in the db with the name given, as of the given marker
	TableAsOf(ctx *Context, dbName, tableName string, asOf interface{}) (Table, Database, error)

	// Function returns the function with the name given, or sql.ErrFunctionNotFound if it doesn't exist
	Function(ctx *Context, name string) (Function, error)

	// RegisterFunction registers the functions given, adding them to the built-in functions.
	// Integrators with custom functions should typically use the FunctionProvider interface to register their functions.
	RegisterFunction(ctx *Context, fns ...Function)

	// LockTable locks the table named
	LockTable(ctx *Context, table string)

	// UnlockTables unlocks all tables locked by the session id given
	UnlockTables(ctx *Context, id uint32) error
}

type CharacterSet

type CharacterSet struct {
	ID               CharacterSetID
	Name             string
	DefaultCollation CollationID
	BinaryCollation  CollationID
	Description      string
	MaxLength        uint8
	Encoder          encodings.Encoder
}

CharacterSet represents the character set of a string.

type CharacterSetID added in v0.14.0

type CharacterSetID uint16

CharacterSetID represents a character set. Unlike collations, this ID is not intended for storage and may change as new character sets are added. It is recommended to use the character set's name if persistence is desired.

const (
	CharacterSet_armscii8 CharacterSetID = 1
	CharacterSet_ascii    CharacterSetID = 2
	CharacterSet_big5     CharacterSetID = 3
	CharacterSet_binary   CharacterSetID = 4
	CharacterSet_cp1250   CharacterSetID = 5
	CharacterSet_cp1251   CharacterSetID = 6
	CharacterSet_cp1256   CharacterSetID = 7
	CharacterSet_cp1257   CharacterSetID = 8
	CharacterSet_cp850    CharacterSetID = 9
	CharacterSet_cp852    CharacterSetID = 10
	CharacterSet_cp866    CharacterSetID = 11
	CharacterSet_cp932    CharacterSetID = 12
	CharacterSet_dec8     CharacterSetID = 13
	CharacterSet_eucjpms  CharacterSetID = 14
	CharacterSet_euckr    CharacterSetID = 15
	CharacterSet_gb18030  CharacterSetID = 16
	CharacterSet_gb2312   CharacterSetID = 17
	CharacterSet_gbk      CharacterSetID = 18
	CharacterSet_geostd8  CharacterSetID = 19
	CharacterSet_greek    CharacterSetID = 20
	CharacterSet_hebrew   CharacterSetID = 21
	CharacterSet_hp8      CharacterSetID = 22
	CharacterSet_keybcs2  CharacterSetID = 23
	CharacterSet_koi8r    CharacterSetID = 24
	CharacterSet_koi8u    CharacterSetID = 25
	CharacterSet_latin1   CharacterSetID = 26
	CharacterSet_latin2   CharacterSetID = 27
	CharacterSet_latin5   CharacterSetID = 28
	CharacterSet_latin7   CharacterSetID = 29
	CharacterSet_macce    CharacterSetID = 30
	CharacterSet_macroman CharacterSetID = 31
	CharacterSet_sjis     CharacterSetID = 32
	CharacterSet_swe7     CharacterSetID = 33
	CharacterSet_tis620   CharacterSetID = 34
	CharacterSet_ucs2     CharacterSetID = 35
	CharacterSet_ujis     CharacterSetID = 36
	CharacterSet_utf16    CharacterSetID = 37
	CharacterSet_utf16le  CharacterSetID = 38
	CharacterSet_utf32    CharacterSetID = 39
	CharacterSet_utf8mb3  CharacterSetID = 40
	CharacterSet_utf8mb4  CharacterSetID = 41

	CharacterSet_utf8 = CharacterSet_utf8mb3

	// CharacterSet_Unspecified is used when a character set has not been specified, either explicitly or implicitly.
	// This is usually used as an intermediate character set to be later replaced by an analyzer pass or a plan,
	// although it is valid to use it directly. When used, behaves identically to the character set belonging to the
	// default collation, although it will NOT match the aforementioned character set.
	CharacterSet_Unspecified CharacterSetID = 0
)

func ParseCharacterSet

func ParseCharacterSet(str string) (CharacterSetID, error)

ParseCharacterSet takes in a string representing a CharacterSet and returns the result if a match is found, or an error if not.

func (CharacterSetID) BinaryCollation added in v0.14.0

func (cs CharacterSetID) BinaryCollation() CollationID

BinaryCollation returns the binary CollationID for this CharacterSet.

func (CharacterSetID) DefaultCollation added in v0.14.0

func (cs CharacterSetID) DefaultCollation() CollationID

DefaultCollation returns the default CollationID for this CharacterSet.

func (CharacterSetID) Description added in v0.14.0

func (cs CharacterSetID) Description() string

Description returns the plain-English description of the CharacterSet.

func (CharacterSetID) Encoder added in v0.14.0

func (cs CharacterSetID) Encoder() encodings.Encoder

Encoder returns this CharacterSet's encoder. As character sets are a work-in-progress, it is recommended to check if it is nil before allowing the character set to be set within a table.

func (CharacterSetID) MaxLength added in v0.14.0

func (cs CharacterSetID) MaxLength() int64

MaxLength returns the maximum size of a single character in the CharacterSet.

func (CharacterSetID) Name added in v0.14.0

func (cs CharacterSetID) Name() string

Name returns the name of this CharacterSet.

func (CharacterSetID) String added in v0.14.0

func (cs CharacterSetID) String() string

String returns the string representation of the CharacterSet.

type CharacterSetsIterator added in v0.14.0

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

CharacterSetsIterator iterates over every character set available.

func NewCharacterSetsIterator added in v0.14.0

func NewCharacterSetsIterator() *CharacterSetsIterator

NewCharacterSetsIterator returns a new CharacterSetsIterator.

func (*CharacterSetsIterator) Next added in v0.14.0

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

Next returns the next character set. If all character sets have been iterated over, returns false.

type CheckAlterableTable added in v0.9.0

type CheckAlterableTable interface {
	Table
	// CreateCheck creates an check constraint for this table, using the provided parameters.
	// Returns an error if the constraint name already exists.
	CreateCheck(ctx *Context, check *CheckDefinition) error
	// DropCheck removes a check constraint from the database.
	DropCheck(ctx *Context, chName string) error
}

CheckAlterableTable represents a table that supports check constraints.

type CheckConstraint added in v0.9.0

type CheckConstraint struct {
	Name     string
	Expr     Expression
	Enforced bool
}

CheckConstraint declares a boolean-eval constraint.

func (CheckConstraint) DebugString added in v0.10.0

func (c CheckConstraint) DebugString() string

type CheckConstraints added in v0.10.0

type CheckConstraints []*CheckConstraint

func (CheckConstraints) FromExpressions added in v0.10.0

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

FromExpressions takes a slice of sql.Expression in the same order as these constraints, and returns a new slice of constraints with the expressions given, holding names and other properties constant.

func (CheckConstraints) ToExpressions added in v0.10.0

func (checks CheckConstraints) ToExpressions() []Expression

ToExpressions returns the check expressions in these constraints as a slice of sql.Expression

type CheckDefinition added in v0.9.0

type CheckDefinition struct {
	Name            string // The name of this check. Check names in a database are unique.
	CheckExpression string // String serialization of the check expression
	Enforced        bool   // Whether this constraint is enforced
}

CheckDefinition defines a trigger. Integrators are not expected to parse or understand the trigger definitions, but must store and return them when asked.

type CheckTable added in v0.9.0

type CheckTable interface {
	Table
	// GetChecks returns the check constraints on this table.
	GetChecks(ctx *Context) ([]CheckDefinition, error)
}

CheckTable is a table that can declare its check constraints.

type Checksumable

type Checksumable interface {
	// Checksum returns a checksum and an error if there was any problem
	// computing or obtaining the checksum.
	Checksum() (string, error)
}

Checksumable provides the checksum of some data.

type Client

type Client struct {
	// User of the session.
	User string
	// Address of the client.
	Address string
	// Capabilities of the client
	Capabilities uint32
}

Client holds session user information.

type Closer

type Closer interface {
	Close(*Context) error
}

type CollatedDatabase added in v0.14.0

type CollatedDatabase interface {
	Database

	// GetCollation returns this database's collation.
	GetCollation(ctx *Context) CollationID

	// SetCollation updates this database's collation.
	SetCollation(ctx *Context, collation CollationID) error
}

CollatedDatabase is a Database that may store and update its collation.

type CollatedDatabaseProvider added in v0.14.0

type CollatedDatabaseProvider interface {
	MutableDatabaseProvider

	// CreateCollatedDatabase creates a collated database and adds it to the provider's collection.
	CreateCollatedDatabase(ctx *Context, name string, collation CollationID) error
}

type Collation

type Collation struct {
	ID           CollationID
	Name         string
	CharacterSet CharacterSetID
	IsDefault    bool
	IsCompiled   bool
	SortLength   uint8
	PadAttribute string
	Sorter       func(r rune) int32
}

Collation represents the collation of a string.

type CollationID added in v0.14.0

type CollationID uint16

CollationID represents the collation's unique identifier. May be safely converted to and from an uint16 for storage.

const (
	Collation_armscii8_bin                CollationID = 64
	Collation_armscii8_general_ci         CollationID = 32
	Collation_ascii_bin                   CollationID = 65
	Collation_ascii_general_ci            CollationID = 11
	Collation_big5_bin                    CollationID = 84
	Collation_big5_chinese_ci             CollationID = 1
	Collation_binary                      CollationID = 63
	Collation_cp1250_bin                  CollationID = 66
	Collation_cp1250_croatian_ci          CollationID = 44
	Collation_cp1250_czech_cs             CollationID = 34
	Collation_cp1250_general_ci           CollationID = 26
	Collation_cp1250_polish_ci            CollationID = 99
	Collation_cp1251_bin                  CollationID = 50
	Collation_cp1251_bulgarian_ci         CollationID = 14
	Collation_cp1251_general_ci           CollationID = 51
	Collation_cp1251_general_cs           CollationID = 52
	Collation_cp1251_ukrainian_ci         CollationID = 23
	Collation_cp1256_bin                  CollationID = 67
	Collation_cp1256_general_ci           CollationID = 57
	Collation_cp1257_bin                  CollationID = 58
	Collation_cp1257_general_ci           CollationID = 59
	Collation_cp1257_lithuanian_ci        CollationID = 29
	Collation_cp850_bin                   CollationID = 80
	Collation_cp850_general_ci            CollationID = 4
	Collation_cp852_bin                   CollationID = 81
	Collation_cp852_general_ci            CollationID = 40
	Collation_cp866_bin                   CollationID = 68
	Collation_cp866_general_ci            CollationID = 36
	Collation_cp932_bin                   CollationID = 96
	Collation_cp932_japanese_ci           CollationID = 95
	Collation_dec8_bin                    CollationID = 69
	Collation_dec8_swedish_ci             CollationID = 3
	Collation_eucjpms_bin                 CollationID = 98
	Collation_eucjpms_japanese_ci         CollationID = 97
	Collation_euckr_bin                   CollationID = 85
	Collation_euckr_korean_ci             CollationID = 19
	Collation_gb18030_bin                 CollationID = 249
	Collation_gb18030_chinese_ci          CollationID = 248
	Collation_gb18030_unicode_520_ci      CollationID = 250
	Collation_gb2312_bin                  CollationID = 86
	Collation_gb2312_chinese_ci           CollationID = 24
	Collation_gbk_bin                     CollationID = 87
	Collation_gbk_chinese_ci              CollationID = 28
	Collation_geostd8_bin                 CollationID = 93
	Collation_geostd8_general_ci          CollationID = 92
	Collation_greek_bin                   CollationID = 70
	Collation_greek_general_ci            CollationID = 25
	Collation_hebrew_bin                  CollationID = 71
	Collation_hebrew_general_ci           CollationID = 16
	Collation_hp8_bin                     CollationID = 72
	Collation_hp8_english_ci              CollationID = 6
	Collation_keybcs2_bin                 CollationID = 73
	Collation_keybcs2_general_ci          CollationID = 37
	Collation_koi8r_bin                   CollationID = 74
	Collation_koi8r_general_ci            CollationID = 7
	Collation_koi8u_bin                   CollationID = 75
	Collation_koi8u_general_ci            CollationID = 22
	Collation_latin1_bin                  CollationID = 47
	Collation_latin1_danish_ci            CollationID = 15
	Collation_latin1_general_ci           CollationID = 48
	Collation_latin1_general_cs           CollationID = 49
	Collation_latin1_german1_ci           CollationID = 5
	Collation_latin1_german2_ci           CollationID = 31
	Collation_latin1_spanish_ci           CollationID = 94
	Collation_latin1_swedish_ci           CollationID = 8
	Collation_latin2_bin                  CollationID = 77
	Collation_latin2_croatian_ci          CollationID = 27
	Collation_latin2_czech_cs             CollationID = 2
	Collation_latin2_general_ci           CollationID = 9
	Collation_latin2_hungarian_ci         CollationID = 21
	Collation_latin5_bin                  CollationID = 78
	Collation_latin5_turkish_ci           CollationID = 30
	Collation_latin7_bin                  CollationID = 79
	Collation_latin7_estonian_cs          CollationID = 20
	Collation_latin7_general_ci           CollationID = 41
	Collation_latin7_general_cs           CollationID = 42
	Collation_macce_bin                   CollationID = 43
	Collation_macce_general_ci            CollationID = 38
	Collation_macroman_bin                CollationID = 53
	Collation_macroman_general_ci         CollationID = 39
	Collation_sjis_bin                    CollationID = 88
	Collation_sjis_japanese_ci            CollationID = 13
	Collation_swe7_bin                    CollationID = 82
	Collation_swe7_swedish_ci             CollationID = 10
	Collation_tis620_bin                  CollationID = 89
	Collation_tis620_thai_ci              CollationID = 18
	Collation_ucs2_bin                    CollationID = 90
	Collation_ucs2_croatian_ci            CollationID = 149
	Collation_ucs2_czech_ci               CollationID = 138
	Collation_ucs2_danish_ci              CollationID = 139
	Collation_ucs2_esperanto_ci           CollationID = 145
	Collation_ucs2_estonian_ci            CollationID = 134
	Collation_ucs2_general_ci             CollationID = 35
	Collation_ucs2_general_mysql500_ci    CollationID = 159
	Collation_ucs2_german2_ci             CollationID = 148
	Collation_ucs2_hungarian_ci           CollationID = 146
	Collation_ucs2_icelandic_ci           CollationID = 129
	Collation_ucs2_latvian_ci             CollationID = 130
	Collation_ucs2_lithuanian_ci          CollationID = 140
	Collation_ucs2_persian_ci             CollationID = 144
	Collation_ucs2_polish_ci              CollationID = 133
	Collation_ucs2_roman_ci               CollationID = 143
	Collation_ucs2_romanian_ci            CollationID = 131
	Collation_ucs2_sinhala_ci             CollationID = 147
	Collation_ucs2_slovak_ci              CollationID = 141
	Collation_ucs2_slovenian_ci           CollationID = 132
	Collation_ucs2_spanish2_ci            CollationID = 142
	Collation_ucs2_spanish_ci             CollationID = 135
	Collation_ucs2_swedish_ci             CollationID = 136
	Collation_ucs2_turkish_ci             CollationID = 137
	Collation_ucs2_unicode_520_ci         CollationID = 150
	Collation_ucs2_unicode_ci             CollationID = 128
	Collation_ucs2_vietnamese_ci          CollationID = 151
	Collation_ujis_bin                    CollationID = 91
	Collation_ujis_japanese_ci            CollationID = 12
	Collation_utf16_bin                   CollationID = 55
	Collation_utf16_croatian_ci           CollationID = 122
	Collation_utf16_czech_ci              CollationID = 111
	Collation_utf16_danish_ci             CollationID = 112
	Collation_utf16_esperanto_ci          CollationID = 118
	Collation_utf16_estonian_ci           CollationID = 107
	Collation_utf16_general_ci            CollationID = 54
	Collation_utf16_german2_ci            CollationID = 121
	Collation_utf16_hungarian_ci          CollationID = 119
	Collation_utf16_icelandic_ci          CollationID = 102
	Collation_utf16_latvian_ci            CollationID = 103
	Collation_utf16_lithuanian_ci         CollationID = 113
	Collation_utf16_persian_ci            CollationID = 117
	Collation_utf16_polish_ci             CollationID = 106
	Collation_utf16_roman_ci              CollationID = 116
	Collation_utf16_romanian_ci           CollationID = 104
	Collation_utf16_sinhala_ci            CollationID = 120
	Collation_utf16_slovak_ci             CollationID = 114
	Collation_utf16_slovenian_ci          CollationID = 105
	Collation_utf16_spanish2_ci           CollationID = 115
	Collation_utf16_spanish_ci            CollationID = 108
	Collation_utf16_swedish_ci            CollationID = 109
	Collation_utf16_turkish_ci            CollationID = 110
	Collation_utf16_unicode_520_ci        CollationID = 123
	Collation_utf16_unicode_ci            CollationID = 101
	Collation_utf16_vietnamese_ci         CollationID = 124
	Collation_utf16le_bin                 CollationID = 62
	Collation_utf16le_general_ci          CollationID = 56
	Collation_utf32_bin                   CollationID = 61
	Collation_utf32_croatian_ci           CollationID = 181
	Collation_utf32_czech_ci              CollationID = 170
	Collation_utf32_danish_ci             CollationID = 171
	Collation_utf32_esperanto_ci          CollationID = 177
	Collation_utf32_estonian_ci           CollationID = 166
	Collation_utf32_general_ci            CollationID = 60
	Collation_utf32_german2_ci            CollationID = 180
	Collation_utf32_hungarian_ci          CollationID = 178
	Collation_utf32_icelandic_ci          CollationID = 161
	Collation_utf32_latvian_ci            CollationID = 162
	Collation_utf32_lithuanian_ci         CollationID = 172
	Collation_utf32_persian_ci            CollationID = 176
	Collation_utf32_polish_ci             CollationID = 165
	Collation_utf32_roman_ci              CollationID = 175
	Collation_utf32_romanian_ci           CollationID = 163
	Collation_utf32_sinhala_ci            CollationID = 179
	Collation_utf32_slovak_ci             CollationID = 173
	Collation_utf32_slovenian_ci          CollationID = 164
	Collation_utf32_spanish2_ci           CollationID = 174
	Collation_utf32_spanish_ci            CollationID = 167
	Collation_utf32_swedish_ci            CollationID = 168
	Collation_utf32_turkish_ci            CollationID = 169
	Collation_utf32_unicode_520_ci        CollationID = 182
	Collation_utf32_unicode_ci            CollationID = 160
	Collation_utf32_vietnamese_ci         CollationID = 183
	Collation_utf8mb3_bin                 CollationID = 83
	Collation_utf8mb3_croatian_ci         CollationID = 213
	Collation_utf8mb3_czech_ci            CollationID = 202
	Collation_utf8mb3_danish_ci           CollationID = 203
	Collation_utf8mb3_esperanto_ci        CollationID = 209
	Collation_utf8mb3_estonian_ci         CollationID = 198
	Collation_utf8mb3_general_ci          CollationID = 33
	Collation_utf8mb3_general_mysql500_ci CollationID = 223
	Collation_utf8mb3_german2_ci          CollationID = 212
	Collation_utf8mb3_hungarian_ci        CollationID = 210
	Collation_utf8mb3_icelandic_ci        CollationID = 193
	Collation_utf8mb3_latvian_ci          CollationID = 194
	Collation_utf8mb3_lithuanian_ci       CollationID = 204
	Collation_utf8mb3_persian_ci          CollationID = 208
	Collation_utf8mb3_polish_ci           CollationID = 197
	Collation_utf8mb3_roman_ci            CollationID = 207
	Collation_utf8mb3_romanian_ci         CollationID = 195
	Collation_utf8mb3_sinhala_ci          CollationID = 211
	Collation_utf8mb3_slovak_ci           CollationID = 205
	Collation_utf8mb3_slovenian_ci        CollationID = 196
	Collation_utf8mb3_spanish2_ci         CollationID = 206
	Collation_utf8mb3_spanish_ci          CollationID = 199
	Collation_utf8mb3_swedish_ci          CollationID = 200
	Collation_utf8mb3_tolower_ci          CollationID = 76
	Collation_utf8mb3_turkish_ci          CollationID = 201
	Collation_utf8mb3_unicode_520_ci      CollationID = 214
	Collation_utf8mb3_unicode_ci          CollationID = 192
	Collation_utf8mb3_vietnamese_ci       CollationID = 215
	Collation_utf8mb4_0900_ai_ci          CollationID = 255
	Collation_utf8mb4_0900_as_ci          CollationID = 305
	Collation_utf8mb4_0900_as_cs          CollationID = 278
	Collation_utf8mb4_0900_bin            CollationID = 309
	Collation_utf8mb4_bin                 CollationID = 46
	Collation_utf8mb4_croatian_ci         CollationID = 245
	Collation_utf8mb4_cs_0900_ai_ci       CollationID = 266
	Collation_utf8mb4_cs_0900_as_cs       CollationID = 289
	Collation_utf8mb4_czech_ci            CollationID = 234
	Collation_utf8mb4_da_0900_ai_ci       CollationID = 267
	Collation_utf8mb4_da_0900_as_cs       CollationID = 290
	Collation_utf8mb4_danish_ci           CollationID = 235
	Collation_utf8mb4_de_pb_0900_ai_ci    CollationID = 256
	Collation_utf8mb4_de_pb_0900_as_cs    CollationID = 279
	Collation_utf8mb4_eo_0900_ai_ci       CollationID = 273
	Collation_utf8mb4_eo_0900_as_cs       CollationID = 296
	Collation_utf8mb4_es_0900_ai_ci       CollationID = 263
	Collation_utf8mb4_es_0900_as_cs       CollationID = 286
	Collation_utf8mb4_es_trad_0900_ai_ci  CollationID = 270
	Collation_utf8mb4_es_trad_0900_as_cs  CollationID = 293
	Collation_utf8mb4_esperanto_ci        CollationID = 241
	Collation_utf8mb4_estonian_ci         CollationID = 230
	Collation_utf8mb4_et_0900_ai_ci       CollationID = 262
	Collation_utf8mb4_et_0900_as_cs       CollationID = 285
	Collation_utf8mb4_general_ci          CollationID = 45
	Collation_utf8mb4_german2_ci          CollationID = 244
	Collation_utf8mb4_hr_0900_ai_ci       CollationID = 275
	Collation_utf8mb4_hr_0900_as_cs       CollationID = 298
	Collation_utf8mb4_hu_0900_ai_ci       CollationID = 274
	Collation_utf8mb4_hu_0900_as_cs       CollationID = 297
	Collation_utf8mb4_hungarian_ci        CollationID = 242
	Collation_utf8mb4_icelandic_ci        CollationID = 225
	Collation_utf8mb4_is_0900_ai_ci       CollationID = 257
	Collation_utf8mb4_is_0900_as_cs       CollationID = 280
	Collation_utf8mb4_ja_0900_as_cs       CollationID = 303
	Collation_utf8mb4_ja_0900_as_cs_ks    CollationID = 304
	Collation_utf8mb4_la_0900_ai_ci       CollationID = 271
	Collation_utf8mb4_la_0900_as_cs       CollationID = 294
	Collation_utf8mb4_latvian_ci          CollationID = 226
	Collation_utf8mb4_lithuanian_ci       CollationID = 236
	Collation_utf8mb4_lt_0900_ai_ci       CollationID = 268
	Collation_utf8mb4_lt_0900_as_cs       CollationID = 291
	Collation_utf8mb4_lv_0900_ai_ci       CollationID = 258
	Collation_utf8mb4_lv_0900_as_cs       CollationID = 281
	Collation_utf8mb4_persian_ci          CollationID = 240
	Collation_utf8mb4_pl_0900_ai_ci       CollationID = 261
	Collation_utf8mb4_pl_0900_as_cs       CollationID = 284
	Collation_utf8mb4_polish_ci           CollationID = 229
	Collation_utf8mb4_ro_0900_ai_ci       CollationID = 259
	Collation_utf8mb4_ro_0900_as_cs       CollationID = 282
	Collation_utf8mb4_roman_ci            CollationID = 239
	Collation_utf8mb4_romanian_ci         CollationID = 227
	Collation_utf8mb4_ru_0900_ai_ci       CollationID = 306
	Collation_utf8mb4_ru_0900_as_cs       CollationID = 307
	Collation_utf8mb4_sinhala_ci          CollationID = 243
	Collation_utf8mb4_sk_0900_ai_ci       CollationID = 269
	Collation_utf8mb4_sk_0900_as_cs       CollationID = 292
	Collation_utf8mb4_sl_0900_ai_ci       CollationID = 260
	Collation_utf8mb4_sl_0900_as_cs       CollationID = 283
	Collation_utf8mb4_slovak_ci           CollationID = 237
	Collation_utf8mb4_slovenian_ci        CollationID = 228
	Collation_utf8mb4_spanish2_ci         CollationID = 238
	Collation_utf8mb4_spanish_ci          CollationID = 231
	Collation_utf8mb4_sv_0900_ai_ci       CollationID = 264
	Collation_utf8mb4_sv_0900_as_cs       CollationID = 287
	Collation_utf8mb4_swedish_ci          CollationID = 232
	Collation_utf8mb4_tr_0900_ai_ci       CollationID = 265
	Collation_utf8mb4_tr_0900_as_cs       CollationID = 288
	Collation_utf8mb4_turkish_ci          CollationID = 233
	Collation_utf8mb4_unicode_520_ci      CollationID = 246
	Collation_utf8mb4_unicode_ci          CollationID = 224
	Collation_utf8mb4_vi_0900_ai_ci       CollationID = 277
	Collation_utf8mb4_vi_0900_as_cs       CollationID = 300
	Collation_utf8mb4_vietnamese_ci       CollationID = 247
	Collation_utf8mb4_zh_0900_as_cs       CollationID = 308

	Collation_utf8_general_ci          = Collation_utf8mb3_general_ci
	Collation_utf8_tolower_ci          = Collation_utf8mb3_tolower_ci
	Collation_utf8_bin                 = Collation_utf8mb3_bin
	Collation_utf8_unicode_ci          = Collation_utf8mb3_unicode_ci
	Collation_utf8_icelandic_ci        = Collation_utf8mb3_icelandic_ci
	Collation_utf8_latvian_ci          = Collation_utf8mb3_latvian_ci
	Collation_utf8_romanian_ci         = Collation_utf8mb3_romanian_ci
	Collation_utf8_slovenian_ci        = Collation_utf8mb3_slovenian_ci
	Collation_utf8_polish_ci           = Collation_utf8mb3_polish_ci
	Collation_utf8_estonian_ci         = Collation_utf8mb3_estonian_ci
	Collation_utf8_spanish_ci          = Collation_utf8mb3_spanish_ci
	Collation_utf8_swedish_ci          = Collation_utf8mb3_swedish_ci
	Collation_utf8_turkish_ci          = Collation_utf8mb3_turkish_ci
	Collation_utf8_czech_ci            = Collation_utf8mb3_czech_ci
	Collation_utf8_danish_ci           = Collation_utf8mb3_danish_ci
	Collation_utf8_lithuanian_ci       = Collation_utf8mb3_lithuanian_ci
	Collation_utf8_slovak_ci           = Collation_utf8mb3_slovak_ci
	Collation_utf8_spanish2_ci         = Collation_utf8mb3_spanish2_ci
	Collation_utf8_roman_ci            = Collation_utf8mb3_roman_ci
	Collation_utf8_persian_ci          = Collation_utf8mb3_persian_ci
	Collation_utf8_esperanto_ci        = Collation_utf8mb3_esperanto_ci
	Collation_utf8_hungarian_ci        = Collation_utf8mb3_hungarian_ci
	Collation_utf8_sinhala_ci          = Collation_utf8mb3_sinhala_ci
	Collation_utf8_german2_ci          = Collation_utf8mb3_german2_ci
	Collation_utf8_croatian_ci         = Collation_utf8mb3_croatian_ci
	Collation_utf8_unicode_520_ci      = Collation_utf8mb3_unicode_520_ci
	Collation_utf8_vietnamese_ci       = Collation_utf8mb3_vietnamese_ci
	Collation_utf8_general_mysql500_ci = Collation_utf8mb3_general_mysql500_ci

	Collation_Default = Collation_utf8mb4_0900_bin
	// Collation_Unspecified is used when a collation has not been specified, either explicitly or implicitly. This is
	// usually used as an intermediate collation to be later replaced by an analyzer pass or a plan, although it is
	// valid to use it directly. When used, behaves identically to the default collation, although it will NOT match
	// the default collation.
	Collation_Unspecified CollationID = 0
)

func ConvertToCollatedString added in v0.14.0

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

ConvertToCollatedString returns the given interface as a string, along with its collation. If the Type possess a collation, then that collation is returned. If the Type does not possess a collation (such as an integer), then the value is converted to a string and the default collation is used. If the value is already a string then no additional conversions are made. If the value is a byte slice then a non-copying conversion is made, which means that the original byte slice MUST NOT be modified after being passed to this function. If modifications need to be made, then you must allocate a new byte slice and pass that new one in.

func ParseCollation

func ParseCollation(characterSetStr *string, collationStr *string, binaryAttribute bool) (CollationID, error)

ParseCollation takes in an optional character set and collation, along with the binary attribute if present, and returns a valid collation or error. A nil character set and collation will return the default collation.

func (CollationID) CharacterSet added in v0.14.0

func (c CollationID) CharacterSet() CharacterSetID

CharacterSet returns the CharacterSetID belonging to this Collation.

func (CollationID) Collation added in v0.14.0

func (c CollationID) Collation() Collation

Collation returns the Collation with this ID.

func (CollationID) Equals added in v0.14.0

func (c CollationID) Equals(other CollationID) bool

Equals returns whether the given collation is the same as the calling collation.

func (CollationID) HashToBytes added in v0.14.0

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

HashToBytes returns a hash of the given decoded string based on the collation. Collations take each rune's weight into account, therefore two strings with technically different contents may hash to the same value, as the collation considers them the same string. This is equivalent to HashToUint, except that it converts the uint64 to a byte slice.

func (CollationID) HashToUint added in v0.14.0

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

HashToUint returns a hash of the given decoded string based on the collation. Collations take each rune's weight into account, therefore two strings with technically different contents may hash to the same value, as the collation considers them the same string.

func (CollationID) IsCompiled added in v0.14.0

func (c CollationID) IsCompiled() string

IsCompiled returns a string indicating whether this collation is compiled.

func (CollationID) IsDefault added in v0.14.0

func (c CollationID) IsDefault() string

IsDefault returns a string indicating whether this collation is the default for the character set.

func (CollationID) Name added in v0.14.0

func (c CollationID) Name() string

Name returns the name of this collation.

func (CollationID) PadAttribute added in v0.14.0

func (c CollationID) PadAttribute() string

PadAttribute returns a string representing the pad attribute of the collation.

func (CollationID) SortLength added in v0.14.0

func (c CollationID) SortLength() int64

SortLength returns the sort length of the collation.

func (CollationID) Sorter added in v0.14.0

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

Sorter returns this collation's sort function. As collations are a work-in-progress, it is recommended to avoid using any collations that return a nil sort function.

func (CollationID) String added in v0.14.0

func (c CollationID) String() string

String returns the string representation of the Collation.

func (CollationID) WorksWithCharacterSet added in v0.14.0

func (c CollationID) WorksWithCharacterSet(cs CharacterSetID) bool

WorksWithCharacterSet returns whether the Collation is valid for the given CharacterSet.

type CollationsIterator added in v0.14.0

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

CollationsIterator iterates over every collation available, ordered by their ID (ascending).

func NewCollationsIterator added in v0.14.0

func NewCollationsIterator() *CollationsIterator

NewCollationsIterator returns a new CollationsIterator.

func (*CollationsIterator) Next added in v0.14.0

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

Next returns the next collation. If all collations have been iterated over, returns false.

type Column

type Column struct {
	// Name is the name of the column.
	Name string
	// Type is the data type of the column.
	Type Type
	// Default contains the default value of the column or nil if it was not explicitly defined. A nil instance is valid, thus calls do not error.
	Default *ColumnDefaultValue
	// AutoIncrement is true if the column auto-increments.
	AutoIncrement bool
	// Nullable is true if the column can contain NULL values, or false
	// otherwise.
	Nullable bool
	// Source is the name of the table this column came from.
	Source string
	// DatabaseSource is the name of the database this column came from.
	DatabaseSource string
	// PrimaryKey is true if the column is part of the primary key for its table.
	PrimaryKey bool
	// Comment contains the string comment for this column.
	Comment string
	// Extra contains any additional information to put in the `extra` column under `information_schema.columns`.
	Extra string
}

Column is the definition of a table column. As SQL:2016 puts it:

A column is a named component of a table. It has a data type, a default,
and a nullability characteristic.

func (*Column) Check

func (c *Column) Check(v interface{}) bool

Check ensures the value is correct for this column.

func (*Column) Copy added in v0.12.0

func (c *Column) Copy() *Column

func (*Column) DebugString added in v0.10.0

func (c *Column) DebugString() string

func (*Column) Equals

func (c *Column) Equals(c2 *Column) bool

Equals checks whether two columns are equal.

type ColumnDefaultValue

type ColumnDefaultValue struct {
	// Expression is the expression representing this default value
	Expression
	// contains filtered or unexported fields
}

ColumnDefaultValue is an expression representing the default value of a column. May represent both a default literal and a default expression. A nil pointer of this type represents an implicit default value and is thus valid, so all method calls will return without error.

func NewColumnDefaultValue

func NewColumnDefaultValue(expr Expression, outType Type, representsLiteral bool, parenthesized bool, mayReturnNil bool) (*ColumnDefaultValue, error)

NewColumnDefaultValue returns a new ColumnDefaultValue expression.

func NewUnresolvedColumnDefaultValue added in v0.12.0

func NewUnresolvedColumnDefaultValue(expr string) *ColumnDefaultValue

NewUnresolvedColumnDefaultValue returns a column default

func (*ColumnDefaultValue) CheckType added in v0.12.0

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

CheckType validates that the ColumnDefaultValue has the correct type.

func (*ColumnDefaultValue) Children

func (e *ColumnDefaultValue) Children() []Expression

Children implements sql.Expression

func (*ColumnDefaultValue) DebugString added in v0.12.0

func (e *ColumnDefaultValue) DebugString() string

func (*ColumnDefaultValue) Eval

func (e *ColumnDefaultValue) Eval(ctx *Context, r Row) (interface{}, error)

Eval implements sql.Expression

func (*ColumnDefaultValue) IsLiteral

func (e *ColumnDefaultValue) IsLiteral() bool

IsLiteral returns whether this expression represents a literal default value (otherwise it's an expression default value).

func (*ColumnDefaultValue) IsNullable

func (e *ColumnDefaultValue) IsNullable() bool

IsNullable implements sql.Expression

func (*ColumnDefaultValue) IsParenthesized added in v0.14.0

func (e *ColumnDefaultValue) IsParenthesized() bool

IsParenthesized returns whether this column default was specified in parentheses, using the expression default value form. It is almost always the opposite of IsLiteral, but there is one edge case where matching MySQL's behavior require that we can distinguish between a non-literal value in parens and a non-literal value not in parens. The edge case is using now/current_timestamp as a column default; now/current_timestamp can be specified without parens for datetime/timestamp fields, but it must be enclosed in parens to be used as the default for other types.

func (*ColumnDefaultValue) Resolved

func (e *ColumnDefaultValue) Resolved() bool

Resolved implements sql.Expression

func (*ColumnDefaultValue) String

func (e *ColumnDefaultValue) String() string

String implements sql.Expression

func (*ColumnDefaultValue) Type

func (e *ColumnDefaultValue) Type() Type

Type implements sql.Expression

func (*ColumnDefaultValue) WithChildren

func (e *ColumnDefaultValue) WithChildren(children ...Expression) (Expression, error)

WithChildren implements sql.Expression

type ColumnExpressionType added in v0.12.0

type ColumnExpressionType struct {
	Expression string
	Type       Type
}

ColumnExpressionType returns a column expression along with its Type.

type ColumnOrder

type ColumnOrder struct {
	First       bool   // True if this column should come first
	AfterColumn string // Set to the name of the column after which this column should appear
}

ColumnOrder is used in ALTER TABLE statements to change the order of inserted / modified columns.

type CommentedNode added in v0.9.0

type CommentedNode interface {
	Node
	WithComment(string) Node
	Comment() string
}

CommentedNode allows comments to be set and retrieved on it

type Context

type Context struct {
	context.Context
	Session
	Memory      *MemoryManager
	ProcessList ProcessList
	// contains filtered or unexported fields
}

Context of the query execution.

func NewContext

func NewContext(
	ctx context.Context,
	opts ...ContextOption,
) *Context

NewContext creates a new query context. Options can be passed to configure the context. If some aspect of the context is not configure, the default value will be used. By default, the context will have an empty base session, a noop tracer and a memory manager using the process reporter.

func NewEmptyContext

func NewEmptyContext() *Context

NewEmptyContext returns a default context with default values.

func (*Context) ApplyOpts

func (c *Context) ApplyOpts(opts ...ContextOption)

Applys the options given to the context. Mostly for tests, not safe for use after construction of the context.

func (*Context) Error

func (c *Context) Error(code int, msg string, args ...interface{})

Error adds an error as warning to the session.

func (*Context) KillConnection added in v0.12.0

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

Terminate the connection associated with |connID|.

func (*Context) LoadInfile added in v0.12.0

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

Load the remote file |filename| from the client. Returns a |ReadCloser| for the file's contents. Returns an error if this functionality is not supported.

func (*Context) NewCtxWithClient added in v0.12.0

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

NewCtxWithClient returns a new Context with the given [client]

func (*Context) NewErrgroup added in v0.11.0

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

func (*Context) NewSubContext

func (c *Context) NewSubContext() (*Context, context.CancelFunc)

NewSubContext creates a new sub-context with the current context as parent. Returns the resulting context.CancelFunc as well as the new *sql.Context, which be used to cancel the new context before the parent is finished.

func (*Context) Pid

func (c *Context) Pid() uint64

Pid returns the process id associated with this context.

func (*Context) Query

func (c *Context) Query() string

Query returns the query string associated with this context.

func (*Context) QueryTime

func (c *Context) QueryTime() time.Time

QueryTime returns the time.Time when the context associated with this query was created

func (*Context) RootSpan

func (c *Context) RootSpan() trace.Span

RootSpan returns the root span, if any.

func (*Context) Span

func (c *Context) Span(
	opName string,
	opts ...trace.SpanStartOption,
) (trace.Span, *Context)

Span creates a new tracing span with the given context. It will return the span and a new context that should be passed to all children of this span.

func (*Context) Warn

func (c *Context) Warn(code int, msg string, args ...interface{})

Warn adds a warning to the session.

func (*Context) WithContext

func (c *Context) WithContext(ctx context.Context) *Context

WithContext returns a new context with the given underlying context.

func (*Context) WithCurrentDB

func (c *Context) WithCurrentDB(db string) *Context

func (Context) WithQuery added in v0.12.0

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

type ContextOption

type ContextOption func(*Context)

ContextOption is a function to configure the context.

func WithMemoryManager

func WithMemoryManager(m *MemoryManager) ContextOption

WithMemoryManager adds the given memory manager to the context.

func WithPid

func WithPid(pid uint64) ContextOption

WithPid adds the given pid to the context.

func WithProcessList added in v0.11.0

func WithProcessList(p ProcessList) ContextOption

func WithQuery

func WithQuery(q string) ContextOption

WithQuery adds the given query to the context.

func WithRootSpan

func WithRootSpan(s trace.Span) ContextOption

WithRootSpan sets the root span of the context.

func WithServices added in v0.12.0

func WithServices(services Services) ContextOption

WithServices sets the services for the Context

func WithSession

func WithSession(s Session) ContextOption

WithSession adds the given session to the context.

func WithTracer

func WithTracer(t trace.Tracer) ContextOption

WithTracer adds the given tracer to the context.

type CreateFunc0Args

type CreateFunc0Args func() Expression

type CreateFunc1Args

type CreateFunc1Args func(e1 Expression) Expression

type CreateFunc2Args

type CreateFunc2Args func(e1, e2 Expression) Expression

type CreateFunc3Args

type CreateFunc3Args func(e1, e2, e3 Expression) Expression

type CreateFunc4Args

type CreateFunc4Args func(e1, e2, e3, e4 Expression) Expression

type CreateFunc5Args

type CreateFunc5Args func(e1, e2, e3, e4, e5 Expression) Expression

type CreateFunc6Args

type CreateFunc6Args func(e1, e2, e3, e4, e5, e6 Expression) Expression

type CreateFunc7Args

type CreateFunc7Args func(e1, e2, e3, e4, e5, e6, e7 Expression) Expression

type CreateFuncNArgs

type CreateFuncNArgs func(args ...Expression) (Expression, error)

type Database

type Database interface {
	Nameable

	// GetTableInsensitive retrieves a table by its case insensitive name.  Implementations should look for exact
	// (case-sensitive matches) first.  If no exact matches are found then any table matching the name case insensitively
	// should be returned.  If there is more than one table that matches a case insensitive comparison the resolution
	// strategy is not defined.
	GetTableInsensitive(ctx *Context, tblName string) (Table, bool, error)

	// GetTableNames returns the table names of every table in the database. It does not return the names of temporary
	// tables
	GetTableNames(ctx *Context) ([]string, error)
}

Database represents the database.

type DatabaseProvider added in v0.11.0

type DatabaseProvider interface {
	// Database gets a Database from the provider.
	Database(ctx *Context, name string) (Database, error)

	// HasDatabase checks if the Database exists in the provider.
	HasDatabase(ctx *Context, name string) bool

	// AllDatabases returns a slice of all Databases in the provider.
	AllDatabases(ctx *Context) []Database
}

DatabaseProvider is a collection of Database.

func NewDatabaseProvider added in v0.11.0

func NewDatabaseProvider(dbs ...Database) DatabaseProvider

type Databaseable added in v0.12.0

type Databaseable interface {
	Database() string
}

Databaseable is a node with a string reference to a database

type Databaser

type Databaser interface {
	// Database the current database.
	Database() Database
	// WithDatabase returns a new node instance with the database replaced with
	// the one given as parameter.
	WithDatabase(Database) (Node, error)
}

Databaser is a node that contains a reference to a database.

type DatetimeType

type DatetimeType interface {
	Type
	ConvertWithoutRangeCheck(v interface{}) (time.Time, error)
	MaximumTime() time.Time
	MinimumTime() time.Time
}

DatetimeType represents DATE, DATETIME, and TIMESTAMP. https://dev.mysql.com/doc/refman/8.0/en/datetime.html The type of the returned value is time.Time.

func CreateDatetimeType

func CreateDatetimeType(baseType query.Type) (DatetimeType, error)

CreateDatetimeType creates a Type dealing with all temporal types that are not TIME nor YEAR.

func MustCreateDatetimeType

func MustCreateDatetimeType(baseType query.Type) DatetimeType

MustCreateDatetimeType is the same as CreateDatetimeType except it panics on errors.

type DebugStringer

type DebugStringer interface {
	// DebugString prints a debug string of the node in question.
	DebugString() string
}

DebugStringer is shared by implementors of Node and Expression, and is used for debugging the analyzer. It allows a node or expression to be printed in greater detail than its default String() representation.

type DecimalType

type DecimalType interface {
	Type
	// ConvertToNullDecimal converts the given value to a decimal.NullDecimal if it has a compatible type. It is worth
	// noting that Convert() returns a nil value for nil inputs, and also returns decimal.Decimal rather than
	// decimal.NullDecimal.
	ConvertToNullDecimal(v interface{}) (decimal.NullDecimal, error)
	//ConvertNoBoundsCheck normalizes an interface{} to a decimal type without performing expensive bound checks
	ConvertNoBoundsCheck(v interface{}) (decimal.Decimal, error)
	// BoundsCheck rounds and validates a decimal
	BoundsCheck(v decimal.Decimal) (decimal.Decimal, error)
	// ExclusiveUpperBound returns the exclusive upper bound for this Decimal.
	// For example, DECIMAL(5,2) would return 1000, as 999.99 is the max represented.
	ExclusiveUpperBound() decimal.Decimal
	// MaximumScale returns the maximum scale allowed for the current precision.
	MaximumScale() uint8
	// Precision returns the base-10 precision of the type, which is the total number of digits. For example, a
	// precision of 3 means that 999, 99.9, 9.99, and .999 are all valid maximums (depending on the scale).
	Precision() uint8
	// Scale returns the scale, or number of digits after the decimal, that may be held.
	// This will always be less than or equal to the precision.
	Scale() uint8
}

DecimalType represents the DECIMAL type. https://dev.mysql.com/doc/refman/8.0/en/fixed-point-types.html The type of the returned value is decimal.Decimal.

var InternalDecimalType DecimalType = decimalType{
	// contains filtered or unexported fields
}

InternalDecimalType is a special DecimalType that is used internally for Decimal comparisons. Not intended for usage from integrators.

func CreateDecimalType

func CreateDecimalType(precision uint8, scale uint8) (DecimalType, error)

CreateDecimalType creates a DecimalType.

func MustCreateDecimalType

func MustCreateDecimalType(precision uint8, scale uint8) DecimalType

MustCreateDecimalType is the same as CreateDecimalType except it panics on errors.

type DeferredType added in v0.12.0

type DeferredType interface {
	Type
	IsDeferred() bool
	Name() string
}

DeferredType is a placeholder for prepared statements that is replaced by the BindVar type on re-analysis.

type DeletableTable

type DeletableTable interface {
	Table
	// Deleter returns a RowDeleter for this table. The RowDeleter will get one call to Delete for each row to be deleted,
	// and will end with a call to Close() to finalize the delete operation.
	Deleter(*Context) RowDeleter
}

DeleteableTable is a table that can process the deletion of rows

type Disposable

type Disposable interface {
	// Dispose the contents.
	Dispose()
}

Disposable objects can erase all their content when they're no longer in use. Expressions and Nodes that implement Disposable will have Dispose called on them as a final stage of query execution. This can be used to clean up cached memory that wouldn't get caught via the normal garbage collection process.

type DisposeFunc

type DisposeFunc func()

DisposeFunc is a function to completely erase a cache and remove it from the manager.

type DriverIndex

type DriverIndex interface {
	Index
	// Driver ID of the index.
	Driver() string
}

An indexed managed by a driver, as opposed to natively by a DB table.

type DriverIndexLookup

type DriverIndexLookup interface {
	Lookup() IndexLookup

	// Values returns the values in the subset of the index. These are used to populate the index via the driver.
	Values(Partition) (IndexValueIter, error)

	// Indexes returns the IDs of all indexes involved in this lookup.
	Indexes() []string
}

DriverIndexLookup is a subset of an index. More specific interfaces can be implemented to grant more capabilities to the index lookup.

type DriverIndexableTable

type DriverIndexableTable interface {
	IndexAddressableTable
	WithDriverIndexLookup(DriverIndexLookup) Table
	// IndexKeyValues returns an iterator over partitions and ultimately the rows of the table to compute the value of an
	// index for every row in this table. Used when creating an index for access through an IndexDriver.
	IndexKeyValues(*Context, []string) (PartitionIndexKeyValueIter, error)
}

DriverIndexableTable represents a table that supports being indexed and receiving indexes to be able to speed up its execution.

type EmptyProcessList added in v0.11.0

type EmptyProcessList struct{}

EmptyProcessList is a no-op implementation of ProcessList suitable for use in tests or other installations that don't require a process list

func (EmptyProcessList) AddPartitionProgress added in v0.11.0

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

func (EmptyProcessList) AddProcess added in v0.11.0

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

func (EmptyProcessList) AddTableProgress added in v0.11.0

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

func (EmptyProcessList) Done added in v0.11.0

func (e EmptyProcessList) Done(pid uint64)

func (EmptyProcessList) Kill added in v0.11.0

func (e EmptyProcessList) Kill(connID uint32)

func (EmptyProcessList) Processes added in v0.11.0

func (e EmptyProcessList) Processes() []Process

func (EmptyProcessList) RemovePartitionProgress added in v0.11.0

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

func (EmptyProcessList) RemoveTableProgress added in v0.11.0

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

func (EmptyProcessList) UpdatePartitionProgress added in v0.11.0

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

func (EmptyProcessList) UpdateTableProgress added in v0.11.0

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

type Engine added in v0.9.0

type Engine struct {
	Name string
	// contains filtered or unexported fields
}

Engine represents a sql engine.

func (Engine) Comment added in v0.9.0

func (e Engine) Comment() string

Comment returns a brief description of the storage engine.

func (Engine) Savepoints added in v0.9.0

func (e Engine) Savepoints() string

Savepoints returns whether the storage engine supports savepoints.

func (Engine) String added in v0.9.0

func (e Engine) String() string

String returns the string representation of the Engine.

func (Engine) Support added in v0.9.0

func (e Engine) Support() string

Support returns the server's level of support for the storage engine,

func (Engine) Transactions added in v0.9.0

func (e Engine) Transactions() string

Transactions returns whether the storage engine supports transactions.

func (Engine) XA added in v0.9.0

func (e Engine) XA() string

XA returns whether the storage engine supports XA transactions.

type EnumType

type EnumType interface {
	Type
	// At returns the string at the given index, as well if the string was found.
	At(index int) (string, bool)
	CharacterSet() CharacterSetID
	Collation() CollationID
	// IndexOf returns the index of the given string. If the string was not found, then this returns -1.
	IndexOf(v string) int
	// NumberOfElements returns the number of enumerations.
	NumberOfElements() uint16
	// Values returns the elements, in order, of every enumeration.
	Values() []string
}

EnumType represents the ENUM type. https://dev.mysql.com/doc/refman/8.0/en/enum.html The type of the returned value is uint16.

func CreateEnumType

func CreateEnumType(values []string, collation CollationID) (EnumType, error)

CreateEnumType creates a EnumType.

func MustCreateEnumType

func MustCreateEnumType(values []string, collation CollationID) EnumType

MustCreateEnumType is the same as CreateEnumType except it panics on errors.

type Expression

type Expression interface {
	Resolvable
	fmt.Stringer
	// Type returns the expression type.
	Type() Type
	// IsNullable returns whether the expression can be null.
	IsNullable() bool
	// Eval evaluates the given row and returns a result.
	Eval(ctx *Context, row Row) (interface{}, error)
	// Children returns the children expressions of this expression.
	Children() []Expression
	// WithChildren returns a copy of the expression with children replaced.
	// It will return an error if the number of children is different than
	// the current number of children. They must be given in the same order
	// as they are returned by Children.
	WithChildren(children ...Expression) (Expression, error)
}

Expression is a combination of one or more SQL expressions.

func NillaryWithChildren added in v0.9.0

func NillaryWithChildren(expr Expression, children ...Expression) (Expression, error)

NillaryWithChildren is a common implementation of expression.WithChildren for expressions with no children.

type Expression2 added in v0.12.0

type Expression2 interface {
	Expression
	// Eval2 evaluates the given row frame and returns a result.
	Eval2(ctx *Context, row Row2) (Value, error)
	// Type2 returns the expression type.
	Type2() Type2
}

type Expressioner

type Expressioner interface {
	// Expressions returns the list of expressions contained by the node.
	Expressions() []Expression
	// WithExpressions returns a copy of the node with expressions replaced.
	// It will return an error if the number of expressions is different than
	// the current number of expressions. They must be given in the same order
	// as they are returned by Expressions.
	WithExpressions(...Expression) (Node, error)
}

Expressioner is a node that contains expressions.

type ExternalStoredProcedureDetails added in v0.12.0

type ExternalStoredProcedureDetails struct {
	// Name is the name of the external stored procedure. If two external stored procedures share a name, then they're
	// considered overloaded. Standard stored procedures do not support overloading.
	Name string
	// Schema describes the row layout of the RowIter returned from Function.
	Schema Schema
	// Function is the implementation of the external stored procedure. All functions should have the following definition:
	// `func(*Context, <PARAMETERS>) (RowIter, error)`. The <PARAMETERS> may be any of the following types: `bool`,
	// `string`, `[]byte`, `int8`-`int64`, `uint8`-`uint64`, `float32`, `float64`, `time.Time`, or `Decimal`
	// (shopspring/decimal). The architecture-dependent types `int` and `uint` (without a number) are also supported.
	// It is valid to return a nil RowIter if there are no rows to be returned.
	//
	// Each parameter, by default, is an IN parameter. If the parameter type is a pointer, e.g. `*int32`, then it
	// becomes an INOUT parameter. There is no way to set a parameter as an OUT parameter.
	//
	// Values are converted to their nearest type before being passed in, following the conversion rules of their
	// related SQL types. The exceptions are `time.Time` (treated as a `DATETIME`), string (treated as a `LONGTEXT` with
	// the default collation) and Decimal (treated with a larger precision and scale). Take extra care when using decimal
	// for an INOUT parameter, to ensure that the returned value fits the original's precision and scale, else an error
	// will occur.
	//
	// As functions support overloading, each variant must have a completely unique function signature to prevent
	// ambiguity. Uniqueness is determined by the number of parameters. If two functions are returned that have the same
	// name and same number of parameters, then an error is thrown. If the last parameter is variadic, then the stored
	// procedure functions as though it has the integer-max number of parameters. When an exact match is not found for
	// overloaded functions, the largest function is used (which in this case will be the variadic function). Also, due
	// to the usage of the integer-max for the parameter count, only one variadic function is allowed per function name.
	// The type of the variadic parameter may not have a pointer type.
	Function interface{}
}

ExternalStoredProcedureDetails are the details of an external stored procedure. Compared to standard stored procedures, external ones are considered "built-in", in that they're not created by the user, and may not be modified or deleted by a user. In addition, they're implemented as a function taking standard parameters, compared to stored procedures being implemented as expressions.

func (ExternalStoredProcedureDetails) FakeCreateProcedureStmt added in v0.12.0

func (espd ExternalStoredProcedureDetails) FakeCreateProcedureStmt() string

FakeCreateProcedureStmt returns a parseable CREATE PROCEDURE statement for this external stored procedure, as some tools (such as Java's JDBC connector) require a valid statement in some situations.

type ExternalStoredProcedureProvider added in v0.14.0

type ExternalStoredProcedureProvider interface {
	// ExternalStoredProcedure returns the external stored procedure details for the procedure with the specified name
	// that is able to accept the specified number of parameters. If no matching external stored procedure is found,
	// nil, nil is returned. If an unexpected error is encountered, it is returned as the error parameter.
	ExternalStoredProcedure(ctx *Context, name string, numOfParams int) (*ExternalStoredProcedureDetails, error)
	// ExternalStoredProcedures returns a slice of all external stored procedure details with the specified name. External
	// stored procedures can overload the same name with different arguments, so this method enables a caller to see all
	// available variants with the specified name. If no matching external stored procedures are found, an
	// empty slice is returned, with a nil error. If an unexpected error is encountered, it is returned as the
	// error parameter.
	ExternalStoredProcedures(ctx *Context, name string) ([]ExternalStoredProcedureDetails, error)
}

ExternalStoredProcedureProvider provides access to built-in stored procedures. These procedures are implemented as functions, instead of as SQL statements. The returned stored procedures cannot be modified or deleted.

type ExternalStoredProcedureRegistry added in v0.14.0

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

ExternalStoredProcedureRegistry manages a collection of ExternalStoredProcedures and encapsulates the logic for looking up external stored procedures based on name and number of arguments.

func NewExternalStoredProcedureRegistry added in v0.14.0

func NewExternalStoredProcedureRegistry() ExternalStoredProcedureRegistry

NewExternalStoredProcedureRegistry creates a new, empty instance of ExternalStoredProcedureRegistry.

func (*ExternalStoredProcedureRegistry) LookupByName added in v0.14.0

LookupByName returns all stored procedure variants registered with the specified name, no matter how many parameters they require. If no external stored procedures are registered with the specified name, nil is returned, with no error. If an unexpected error occurs, it is returned as the error parameter.

func (*ExternalStoredProcedureRegistry) LookupByNameAndParamCount added in v0.14.0

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

LookupByNameAndParamCount returns the external stored procedure registered with the specified name and able to accept the specified number of parameters. If no external stored procedures are registered with the specified name and able to accept the specified number of parameters, nil is returned with no error. If an unexpected error occurs, it is returned as the error param.

func (*ExternalStoredProcedureRegistry) Register added in v0.14.0

func (epd *ExternalStoredProcedureRegistry) Register(procedureDetails ExternalStoredProcedureDetails)

Register adds an external stored procedure to this registry.

type FastIntSet added in v0.14.0

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

FastIntSet keeps track of a set of integers. It does not perform any allocations when the values are small. It is not thread-safe.

func NewFastIntSet added in v0.14.0

func NewFastIntSet(vals ...int) FastIntSet

NewFastIntSet returns a set initialized with the given values.

func (*FastIntSet) Add added in v0.14.0

func (s *FastIntSet) Add(i int)

Add adds a value to the set. No-op if the value is already in the set.

func (*FastIntSet) AddRange added in v0.14.0

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

AddRange adds values 'from' up to 'to' (inclusively) to the set. E.g. AddRange(1,5) adds the values 1, 2, 3, 4, 5 to the set. 'to' must be >= 'from'. AddRange is always more efficient than individual Adds.

func (FastIntSet) Contains added in v0.14.0

func (s FastIntSet) Contains(i int) bool

Contains returns true if the set contains the value.

func (FastIntSet) Copy added in v0.14.0

func (s FastIntSet) Copy() FastIntSet

Copy returns a copy of s which can be modified independently.

func (*FastIntSet) CopyFrom added in v0.14.0

func (s *FastIntSet) CopyFrom(c FastIntSet)

CopyFrom sets the receiver to a copy of c, which can then be modified independently.

func (FastIntSet) Difference added in v0.14.0

func (s FastIntSet) Difference(rhs FastIntSet) FastIntSet

Difference returns the elements of s that are not in rhs as a new set.

func (*FastIntSet) DifferenceWith added in v0.14.0

func (s *FastIntSet) DifferenceWith(rhs FastIntSet)

DifferenceWith removes any elements in rhs from this set.

func (FastIntSet) Empty added in v0.14.0

func (s FastIntSet) Empty() bool

Empty returns true if the set is empty.

func (FastIntSet) Equals added in v0.14.0

func (s FastIntSet) Equals(rhs FastIntSet) bool

Equals returns true if the two sets are identical.

func (FastIntSet) ForEach added in v0.14.0

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

ForEach calls a function for each value in the set (in increasing order).

func (FastIntSet) Intersection added in v0.14.0

func (s FastIntSet) Intersection(rhs FastIntSet) FastIntSet

Intersection returns the intersection of s and rhs as a new set.

func (*FastIntSet) IntersectionWith added in v0.14.0

func (s *FastIntSet) IntersectionWith(rhs FastIntSet)

IntersectionWith removes any elements not in rhs from this set.

func (FastIntSet) Intersects added in v0.14.0

func (s FastIntSet) Intersects(rhs FastIntSet) bool

Intersects returns true if s has any elements in common with rhs.

func (FastIntSet) Len added in v0.14.0

func (s FastIntSet) Len() int

Len returns the number of the elements in the set.

func (FastIntSet) Next added in v0.14.0

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

Next returns the first value in the set which is >= startVal. If there is no value, the second return value is false.

func (FastIntSet) Ordered added in v0.14.0

func (s FastIntSet) Ordered() []int

Ordered returns a slice with all the integers in the set, in increasing order.

func (*FastIntSet) Remove added in v0.14.0

func (s *FastIntSet) Remove(i int)

Remove removes a value from the set. No-op if the value is not in the set.

func (*FastIntSet) Shift added in v0.14.0

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

Shift generates a new set which contains elements i+delta for elements i in the original set.

func (FastIntSet) String added in v0.14.0

func (s FastIntSet) String() string

String returns a list representation of elements. Sequential runs of positive numbers are shown as ranges. For example, for the set {0, 1, 2, 5, 6, 10}, the output is "(0-2,5,6,10)".

func (FastIntSet) SubsetOf added in v0.14.0

func (s FastIntSet) SubsetOf(rhs FastIntSet) bool

SubsetOf returns true if rhs contains all the elements in s.

func (FastIntSet) Union added in v0.14.0

func (s FastIntSet) Union(rhs FastIntSet) FastIntSet

Union returns the union of s and rhs as a new set.

func (*FastIntSet) UnionWith added in v0.14.0

func (s *FastIntSet) UnionWith(rhs FastIntSet)

UnionWith adds all the elements from rhs to this set.

type FilteredIndex added in v0.12.0

type FilteredIndex interface {
	Index
	// HandledFilters returns a subset of |filters| that are satisfied
	// by index lookups to this index.
	HandledFilters(filters []Expression) (handled []Expression)
}

FilteredIndex is an extension of |Index| that allows an index to declare certain filter predicates handled, allowing them to be removed from the overall plan for greater execution efficiency

type FilteredTable

type FilteredTable interface {
	Table
	Filters() []Expression
	HandledFilters(filters []Expression) []Expression
	WithFilters(ctx *Context, filters []Expression) Table
}

FilteredTable is a table that can produce a specific RowIter that's more optimized given the filters.

type ForeignKeyConstraint

type ForeignKeyConstraint struct {
	Name           string
	Database       string
	Table          string
	Columns        []string
	ParentDatabase string
	ParentTable    string
	ParentColumns  []string
	OnUpdate       ForeignKeyReferentialAction
	OnDelete       ForeignKeyReferentialAction
	IsResolved     bool
}

ForeignKeyConstraint declares a constraint between the columns of two tables.

func (*ForeignKeyConstraint) DebugString added in v0.10.0

func (f *ForeignKeyConstraint) DebugString() string

func (ForeignKeyConstraint) IsSelfReferential added in v0.12.0

func (f ForeignKeyConstraint) IsSelfReferential() bool

IsSelfReferential returns whether this foreign key represents a self-referential foreign key.

type ForeignKeyReferentialAction added in v0.12.0

type ForeignKeyReferentialAction string

ForeignKeyReferentialAction is the behavior for this foreign key with the relevant action is performed on the foreign table.

const (
	ForeignKeyReferentialAction_DefaultAction ForeignKeyReferentialAction = "DEFAULT" // No explicit action was specified
	ForeignKeyReferentialAction_Restrict      ForeignKeyReferentialAction = "RESTRICT"
	ForeignKeyReferentialAction_Cascade       ForeignKeyReferentialAction = "CASCADE"
	ForeignKeyReferentialAction_NoAction      ForeignKeyReferentialAction = "NO ACTION"
	ForeignKeyReferentialAction_SetNull       ForeignKeyReferentialAction = "SET NULL"
	ForeignKeyReferentialAction_SetDefault    ForeignKeyReferentialAction = "SET DEFAULT"
)

type ForeignKeyTable

type ForeignKeyTable interface {
	IndexAddressableTable
	// CreateIndexForForeignKey creates an index for this table, using the provided parameters. Indexes created through
	// this function are specifically ones generated for use with a foreign key. Returns an error if the index name
	// already exists, or an index on the same columns already exists.
	CreateIndexForForeignKey(ctx *Context, indexName string, using IndexUsing, constraint IndexConstraint, columns []IndexColumn) error

	// GetDeclaredForeignKeys returns the foreign key constraints that are declared by this table.
	GetDeclaredForeignKeys(ctx *Context) ([]ForeignKeyConstraint, error)
	// GetReferencedForeignKeys returns the foreign key constraints that are referenced by this table.
	GetReferencedForeignKeys(ctx *Context) ([]ForeignKeyConstraint, error)
	// AddForeignKey adds the given foreign key constraint to the table. Returns an error if the foreign key name
	// already exists on any other table within the database.
	AddForeignKey(ctx *Context, fk ForeignKeyConstraint) error
	// DropForeignKey removes a foreign key from the table.
	DropForeignKey(ctx *Context, fkName string) error
	// UpdateForeignKey updates the given foreign key constraint. May range from updated table names to setting the
	// IsResolved boolean.
	UpdateForeignKey(ctx *Context, fkName string, fk ForeignKeyConstraint) error
	// GetForeignKeyUpdater returns a ForeignKeyUpdater for this table.
	GetForeignKeyUpdater(ctx *Context) ForeignKeyUpdater
}

ForeignKeyTable is a table that can declare its foreign key constraints, as well as be referenced.

type ForeignKeyUpdater added in v0.12.0

type ForeignKeyUpdater interface {
	RowInserter
	RowUpdater
	RowDeleter
	IndexAddressable
}

ForeignKeyUpdater is a TableEditor that is addressable via IndexLookup.

type Freeable

type Freeable interface {
	// Free the memory.
	Free()
}

Freeable objects can free their memory.

type Function

type Function interface {
	// NewInstance returns a new instance of the function to evaluate against rows
	NewInstance([]Expression) (Expression, error)
	// FunctionName returns the name of this function
	FunctionName() string
	// contains filtered or unexported methods
}

Function is a function defined by the user that can be applied in a SQL query.

type Function0

type Function0 struct {
	Name string
	Fn   CreateFunc0Args
}

Function0 is a function with 0 arguments.

func NewFunction0

func NewFunction0(name string, fn func() Expression) Function0

func (Function0) FunctionName added in v0.11.0

func (fn Function0) FunctionName() string

func (Function0) NewInstance added in v0.9.0

func (fn Function0) NewInstance(args []Expression) (Expression, error)

type Function1

type Function1 struct {
	Name string
	Fn   CreateFunc1Args
}

Function1 is a function with 1 argument.

func (Function1) FunctionName added in v0.11.0

func (fn Function1) FunctionName() string

func (Function1) NewInstance added in v0.9.0

func (fn Function1) NewInstance(args []Expression) (Expression, error)

type Function2

type Function2 struct {
	Name string
	Fn   CreateFunc2Args
}

Function2 is a function with 2 arguments.

func (Function2) FunctionName added in v0.11.0

func (fn Function2) FunctionName() string

func (Function2) NewInstance added in v0.9.0

func (fn Function2) NewInstance(args []Expression) (Expression, error)

type Function3

type Function3 struct {
	Name string
	Fn   CreateFunc3Args
}

Function3 is a function with 3 arguments.

func (Function3) FunctionName added in v0.11.0

func (fn Function3) FunctionName() string

func (Function3) NewInstance added in v0.9.0

func (fn Function3) NewInstance(args []Expression) (Expression, error)

type Function4

type Function4 struct {
	Name string
	Fn   CreateFunc4Args
}

Function4 is a function with 4 arguments.

func (Function4) FunctionName added in v0.11.0

func (fn Function4) FunctionName() string

func (Function4) NewInstance added in v0.9.0

func (fn Function4) NewInstance(args []Expression) (Expression, error)

type Function5

type Function5 struct {
	Name string
	Fn   CreateFunc5Args
}

Function5 is a function with 5 arguments.

func (Function5) FunctionName added in v0.11.0

func (fn Function5) FunctionName() string

func (Function5) NewInstance added in v0.9.0

func (fn Function5) NewInstance(args []Expression) (Expression, error)

type Function6

type Function6 struct {
	Name string
	Fn   CreateFunc6Args
}

Function6 is a function with 6 arguments.

func (Function6) FunctionName added in v0.11.0

func (fn Function6) FunctionName() string

func (Function6) NewInstance added in v0.9.0

func (fn Function6) NewInstance(args []Expression) (Expression, error)

type Function7

type Function7 struct {
	Name string
	Fn   CreateFunc7Args
}

Function7 is a function with 7 arguments.

func (Function7) FunctionName added in v0.11.0

func (fn Function7) FunctionName() string

func (Function7) NewInstance added in v0.9.0

func (fn Function7) NewInstance(args []Expression) (Expression, error)

type FunctionExpression

type FunctionExpression interface {
	Expression
	FunctionName() string
	Description() string
}

FunctionExpression is an Expression that represents a function.

type FunctionN

type FunctionN struct {
	Name string
	Fn   CreateFuncNArgs
}

FunctionN is a function with variable number of arguments. This function is expected to return ErrInvalidArgumentNumber if the arity does not match, since the check has to be done in the implementation.

func (FunctionN) FunctionName added in v0.11.0

func (fn FunctionN) FunctionName() string

func (FunctionN) NewInstance added in v0.9.0

func (fn FunctionN) NewInstance(args []Expression) (Expression, error)

type FunctionProvider added in v0.11.0

type FunctionProvider interface {
	// Function returns the function with the name provided, case-insensitive
	Function(ctx *Context, name string) (Function, error)
}

FunctionProvider is an extension of DatabaseProvider that allows custom functions to be provided

type Generator

type Generator interface {
	// Next value in the generator.
	Next() (interface{}, error)
	// Close the generator and dispose resources.
	Close() error
}

Generator will generate a set of values for a given row.

func NewArrayGenerator

func NewArrayGenerator(array []interface{}) Generator

NewArrayGenerator creates a generator for a given array.

func ToGenerator

func ToGenerator(v interface{}) (Generator, error)

ToGenerator converts a value to a generator if possible.

type GeomColl added in v0.14.0

type GeomColl struct {
	SRID  uint32
	Geoms []GeometryValue
}

GeomColl is the value type returned from GeomCollType. Implements GeometryValue.

func DeserializeGeomColl added in v0.14.0

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

DeserializeGeomColl parses the data portion of a byte array in WKB format to a GeometryCollection object

func (GeomColl) CalculateSize added in v0.14.0

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

CalculateSize is a helper method to determine how much space to allocate for geometry collections TODO: recursion could be better; possible to expand to fit all types

func (GeomColl) GetSRID added in v0.14.0

func (g GeomColl) GetSRID() uint32

GetSRID implements GeometryValue interface.

func (GeomColl) Serialize added in v0.14.0

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

Serialize implements GeometryValue interface. TODO: actually count all points to allocate

func (GeomColl) SetSRID added in v0.14.0

func (g GeomColl) SetSRID(srid uint32) GeometryValue

SetSRID implements GeometryValue interface.

func (GeomColl) Swap added in v0.14.0

func (g GeomColl) Swap() GeometryValue

Swap implements GeometryValue interface.

func (GeomColl) WriteData added in v0.14.0

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

WriteData implements GeometryValue interface.

type GeomCollType added in v0.14.0

type GeomCollType struct {
	SRID        uint32
	DefinedSRID bool
}

GeomCollType represents the GeometryCollection type. https://dev.mysql.com/doc/refman/8.0/en/gis-class-point.html The type of the returned value is GeomColl.

func (GeomCollType) Compare added in v0.14.0

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

Compare implements Type interface.

func (GeomCollType) Convert added in v0.14.0

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

Convert implements Type interface.

func (GeomCollType) Equals added in v0.14.0

func (t GeomCollType) Equals(otherType Type) bool

Equals implements the Type interface.

func (GeomCollType) GetSpatialTypeSRID added in v0.14.0

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

GetSpatialTypeSRID implements SpatialColumnType interface.

func (GeomCollType) MatchSRID added in v0.14.0

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

MatchSRID implements SpatialColumnType interface

func (GeomCollType) MaxTextResponseByteLength added in v0.14.0

func (t GeomCollType) MaxTextResponseByteLength() uint32

MaxTextResponseByteLength implements the Type interface

func (GeomCollType) Promote added in v0.14.0

func (t GeomCollType) Promote() Type

Promote implements the Type interface.

func (GeomCollType) SQL added in v0.14.0

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

SQL implements Type interface.

func (GeomCollType) SetSRID added in v0.14.0

func (t GeomCollType) SetSRID(v uint32) Type

SetSRID implements SpatialColumnType interface.

func (GeomCollType) String added in v0.14.0

func (t GeomCollType) String() string

String implements Type interface.

func (GeomCollType) Type added in v0.14.0

func (t GeomCollType) Type() query.Type

Type implements Type interface.

func (GeomCollType) ValueType added in v0.14.0

func (t GeomCollType) ValueType() reflect.Type

ValueType implements Type interface.

func (GeomCollType) Zero added in v0.14.0

func (t GeomCollType) Zero() interface{}

Zero implements Type interface.

type GeometryType added in v0.12.0

type GeometryType struct {
	SRID        uint32
	DefinedSRID bool
}

GeometryType represents the GEOMETRY type. https://dev.mysql.com/doc/refman/8.0/en/gis-class-geometry.html The type of the returned value is one of the following (each implements GeometryValue): Point, Polygon, LineString.

func (GeometryType) Compare added in v0.12.0

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

Compare implements Type interface.

func (GeometryType) Convert added in v0.12.0

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

Convert implements Type interface.

func (GeometryType) Equals added in v0.12.0

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

Equals implements the Type interface.

func (GeometryType) GetSpatialTypeSRID added in v0.12.0

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

GetSpatialTypeSRID implements SpatialColumnType interface.

func (GeometryType) MatchSRID added in v0.12.0

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

MatchSRID implements SpatialColumnType interface

func (GeometryType) MaxTextResponseByteLength added in v0.14.0

func (t GeometryType) MaxTextResponseByteLength() uint32

MaxTextResponseByteLength implements the Type interface

func (GeometryType) Promote added in v0.12.0

func (t GeometryType) Promote() Type

Promote implements the Type interface.

func (GeometryType) SQL added in v0.12.0

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

SQL implements Type interface.

func (GeometryType) SetSRID added in v0.12.0

func (t GeometryType) SetSRID(v uint32) Type

SetSRID implements SpatialColumnType interface.

func (GeometryType) String added in v0.12.0

func (t GeometryType) String() string

String implements Type interface.

func (GeometryType) Type added in v0.12.0

func (t GeometryType) Type() query.Type

Type implements Type interface.

func (GeometryType) ValueType added in v0.12.0

func (t GeometryType) ValueType() reflect.Type

ValueType implements Type interface.

func (GeometryType) Zero added in v0.12.0

func (t GeometryType) Zero() interface{}

Zero implements Type interface.

type GeometryValue added in v0.12.0

type GeometryValue interface {
	GetSRID() uint32
	SetSRID(srid uint32) GeometryValue
	Serialize() []byte
	WriteData(buf []byte) int
	Swap() GeometryValue
	// contains filtered or unexported methods
}

GeometryValue is the value type returned from GeometryType, which is an interface over the following types: Point, Polygon, LineString, MultiPoint, MultiLineString, MultiPolygon, GeometryCollection.

type Histogram added in v0.14.0

type Histogram struct {
	Buckets       []*HistogramBucket
	Mean          float64
	Min           float64
	Max           float64
	Count         uint64
	NullCount     uint64
	DistinctCount uint64
}

Histogram is all statistics we care about for each column

type HistogramBucket added in v0.14.0

type HistogramBucket struct {
	LowerBound float64 // inclusive
	UpperBound float64 // inclusive
	Frequency  float64
}

HistogramBucket represents a bucket in a histogram inspiration pulled from MySQL and Cockroach DB

type HistogramMap added in v0.14.0

type HistogramMap map[string]*Histogram

HistogramMap is a map from column name to associated histogram

func NewHistogramMapFromTable added in v0.14.0

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

NewHistogramMapFromTable will construct a HistogramMap given a Table TODO: have option for number of buckets (and logic to convert freqMap into those buckets) TODO: could iterate over Partitions asynchronously (after exchange is rewritten)

type IgnorableError added in v0.14.0

type IgnorableError struct {
	OffendingRow Row
}

IgnorableError is used propagate information about an error that needs to be ignored and does not interfere with any update accumulators

func NewIgnorableError added in v0.14.0

func NewIgnorableError(row Row) IgnorableError

func (IgnorableError) Error added in v0.14.0

func (e IgnorableError) Error() string

type Index

type Index interface {
	// ID returns the identifier of the index.
	ID() string
	// Database returns the database name this index belongs to.
	Database() string
	// Table returns the table name this index belongs to.
	Table() string
	// Expressions returns the indexed expressions. If the result is more than
	// one expression, it means the index has multiple columns indexed. If it's
	// just one, it means it may be an expression or a column.
	Expressions() []string
	// IsUnique returns whether this index is unique
	IsUnique() bool
	// Comment returns the comment for this index
	Comment() string
	// IndexType returns the type of this index, e.g. BTREE
	IndexType() string
	// IsGenerated returns whether this index was generated. Generated indexes
	// are used for index access, but are not displayed (such as with SHOW INDEXES).
	IsGenerated() bool
	// ColumnExpressionTypes returns each expression and its associated Type.
	// Each expression string should exactly match the string returned from
	// Index.Expressions().
	ColumnExpressionTypes() []ColumnExpressionType
	// CanSupport returns whether this index supports lookups on the given
	// range filters.
	CanSupport(...Range) bool
}

Index is the representation of an index, and also creates an IndexLookup when given a collection of ranges.

type IndexAddressable added in v0.12.0

type IndexAddressable interface {
	// IndexedAccess returns a table that can perform scans constrained to
	// an IndexLookup on the index given
	IndexedAccess(Index) IndexedTable
	// GetIndexes returns an array of this table's Indexes
	GetIndexes(ctx *Context) ([]Index, error)
}

IndexAddressable is a table that can be scanned through a primary index

type IndexAddressableTable

type IndexAddressableTable interface {
	Table
	IndexAddressable
}

type IndexAlterableTable

type IndexAlterableTable interface {
	Table
	// CreateIndex creates an index for this table, using the provided parameters.
	// Returns an error if the index name already exists, or an index with the same columns already exists.
	CreateIndex(ctx *Context, indexName string, using IndexUsing, constraint IndexConstraint, columns []IndexColumn, comment string) error
	// DropIndex removes an index from this table, if it exists.
	// Returns an error if the removal failed or the index does not exist.
	DropIndex(ctx *Context, indexName string) error
	// RenameIndex renames an existing index to another name that is not already taken by another index on this table.
	RenameIndex(ctx *Context, fromIndexName string, toIndexName string) error
}

IndexAlterableTable represents a table that supports index modification operations.

type IndexBuilder added in v0.12.0

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

IndexBuilder builds ranges based on the combination of calls made for the given index, and then relies on the Index to return an IndexLookup from the created ranges.

func NewIndexBuilder added in v0.12.0

func NewIndexBuilder(idx Index) *IndexBuilder

NewIndexBuilder returns a new IndexBuilder. Used internally to construct a range that will later be passed to integrators through the Index function NewLookup.

func (*IndexBuilder) Build added in v0.12.0

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

Build constructs a new IndexLookup based on the ranges that have been built internally by this builder.

func (*IndexBuilder) Equals added in v0.12.0

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

Equals represents colExpr = key. For IN expressions, pass all of them in the same Equals call.

func (*IndexBuilder) GreaterOrEqual added in v0.12.0

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

GreaterOrEqual represents colExpr >= key.

func (*IndexBuilder) GreaterThan added in v0.12.0

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

GreaterThan represents colExpr > key.

func (*IndexBuilder) IsNotNull added in v0.12.0

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

IsNotNull represents colExpr != nil

func (*IndexBuilder) IsNull added in v0.12.0

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

IsNull represents colExpr = nil

func (*IndexBuilder) LessOrEqual added in v0.12.0

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

LessOrEqual represents colExpr <= key.

func (*IndexBuilder) LessThan added in v0.12.0

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

LessThan represents colExpr < key.

func (*IndexBuilder) NotEquals added in v0.12.0

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

NotEquals represents colExpr <> key.

func (*IndexBuilder) Ranges added in v0.12.0

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

Ranges returns all ranges for this index builder. If the builder is in an error state then this returns nil.

type IndexColumn

type IndexColumn struct {
	Name string
	// Length represents the index prefix length. If zero, then no length was specified.
	Length int64
}

IndexColumn is the column by which to add to an index.

type IndexConstraint

type IndexConstraint byte

IndexConstraint represents any constraints that should be applied to the index.

const (
	IndexConstraint_None IndexConstraint = iota
	IndexConstraint_Unique
	IndexConstraint_Fulltext
	IndexConstraint_Spatial
	IndexConstraint_Primary
)

type IndexDriver

type IndexDriver interface {
	// ID returns the unique name of the driver.
	ID() string
	// Create a new index. If exprs is more than one expression, it means the
	// index has multiple columns indexed. If it's just one, it means it may
	// be an expression or a column.
	Create(db, table, id string, expressions []Expression, config map[string]string) (DriverIndex, error)
	// LoadAll loads all indexes for given db and table.
	LoadAll(ctx *Context, db, table string) ([]DriverIndex, error)
	// Save the given index for all partitions.
	Save(*Context, DriverIndex, PartitionIndexKeyValueIter) error
	// Delete the given index for all partitions in the iterator.
	Delete(DriverIndex, PartitionIter) error
}

IndexDriver manages the coordination between the indexes and their representation on disk.

type IndexKeyValueIter

type IndexKeyValueIter interface {
	// Next returns the next tuple of index key values. The length of the
	// returned slice will be the same as the number of columns used to
	// create this iterator. The second returned parameter is a repo's location.
	Next(*Context) ([]interface{}, []byte, error)
	Closer
}

IndexKeyValueIter is an iterator of index key values, that is, a tuple of the values that will be index keys.

type IndexLookup

type IndexLookup struct {
	Index  Index
	Ranges RangeCollection
	// IsPointLookup is true if the lookup will return one or zero
	// values; the range is null safe, the index is unique, every index
	// column has a range expression, and every range expression is an
	// exact equality.
	IsPointLookup bool
	IsEmptyRange  bool
}

IndexLookup is the implementation-specific definition of an index lookup. The IndexLookup must contain all necessary information to retrieve exactly the rows in the table as specified by the ranges given to their parent index. Implementors are responsible for all semantics of correctly returning rows that match an index lookup.

func (IndexLookup) DebugString added in v0.14.0

func (il IndexLookup) DebugString() string

func (IndexLookup) IsEmpty added in v0.14.0

func (il IndexLookup) IsEmpty() bool

func (IndexLookup) String added in v0.14.0

func (il IndexLookup) String() string

type IndexOrder added in v0.12.0

type IndexOrder byte
const (
	IndexOrderNone IndexOrder = iota
	IndexOrderAsc
	IndexOrderDesc
)

type IndexRegistry

type IndexRegistry struct {
	// Root path where all the data of the indexes is stored on disk.
	Root string
	// contains filtered or unexported fields
}

IndexRegistry keeps track of all driver-provided indexes in the engine.

func NewIndexRegistry

func NewIndexRegistry() *IndexRegistry

NewIndexRegistry returns a new Index Registry.

func (*IndexRegistry) AddIndex

func (r *IndexRegistry) AddIndex(
	idx DriverIndex,
) (created chan<- struct{}, ready <-chan struct{}, err error)

AddIndex adds the given index to the registry. The added index will be marked as creating, so nobody can register two indexes with the same expression or id while the other is still being created. When something is sent through the returned channel, it means the index has finished its creation and will be marked as ready. Another channel is returned to notify the user when the index is ready.

func (*IndexRegistry) CanRemoveIndex

func (r *IndexRegistry) CanRemoveIndex(idx Index) bool

CanRemoveIndex returns whether the given index is ready to be removed.

func (*IndexRegistry) CanUseIndex

func (r *IndexRegistry) CanUseIndex(idx Index) bool

CanUseIndex returns whether the given index is ready to use or not.

func (*IndexRegistry) DefaultIndexDriver

func (r *IndexRegistry) DefaultIndexDriver() IndexDriver

DefaultIndexDriver returns the default index driver, which is the only driver when there is 1 driver in the registry. If there are more than 1 drivers in the registry, this will return the empty string, as there is no clear default driver.

func (*IndexRegistry) DeleteIndex

func (r *IndexRegistry) DeleteIndex(db, id string, force bool) (<-chan struct{}, error)

DeleteIndex deletes an index from the registry by its id. First, it marks the index for deletion but does not remove it, so queries that are using it may still do so. The returned channel will send a message when the index can be deleted from disk. If force is true, it will delete the index even if it's not ready for usage. Only use that parameter if you know what you're doing.

func (*IndexRegistry) ExpressionsWithIndexes

func (r *IndexRegistry) ExpressionsWithIndexes(
	db string,
	exprs ...Expression,
) [][]Expression

ExpressionsWithIndexes finds all the combinations of expressions with matching indexes. This only matches multi-column indexes.

func (*IndexRegistry) HasIndexes

func (r *IndexRegistry) HasIndexes() bool

HasIndexes returns whether the index registry has any registered indexes. Not thread safe, so the answer is approximate in the face of drivers and indexes being added and removed.

func (*IndexRegistry) Index

func (r *IndexRegistry) Index(db, id string) DriverIndex

Index returns the index with the given id. It may return nil if the index is not found.

func (*IndexRegistry) IndexDriver

func (r *IndexRegistry) IndexDriver(id string) IndexDriver

IndexDriver returns the IndexDriver with the given ID.

func (*IndexRegistry) IndexesByTable

func (r *IndexRegistry) IndexesByTable(db, table string) []DriverIndex

IndexesByTable returns a slice of all the indexes existing on the given table.

func (*IndexRegistry) LoadIndexes

func (r *IndexRegistry) LoadIndexes(ctx *Context, dbs []Database) error

LoadIndexes creates load functions for all indexes for all dbs, tables and drivers. These functions are called as needed by the query

func (*IndexRegistry) MarkOutdated

func (r *IndexRegistry) MarkOutdated(idx Index)

MarkOutdated sets the index status as outdated. This method is not thread safe and should not be used directly except for testing.

func (*IndexRegistry) MatchingIndex added in v0.12.0

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

MatchingIndex returns the index that best fits the given expressions. See analyzer.MatchingIndexes for the rules regarding which index is considered the best. If no index matches then returns nil.

func (*IndexRegistry) RegisterIndexDriver

func (r *IndexRegistry) RegisterIndexDriver(driver IndexDriver)

RegisterIndexDriver registers a new index driver.

func (*IndexRegistry) ReleaseIndex

func (r *IndexRegistry) ReleaseIndex(idx Index)

ReleaseIndex releases an index after it's been used.

type IndexStatus

type IndexStatus byte

IndexStatus represents the current status in which the index is.

const (
	// IndexNotReady means the index is not ready to be used.
	IndexNotReady IndexStatus = iota
	// IndexReady means the index can be used.
	IndexReady
	// IndexOutdated means the index is loaded but will not be used because the
	// contents in it are outdated.
	IndexOutdated
)

func (IndexStatus) IsUsable

func (s IndexStatus) IsUsable() bool

IsUsable returns whether the index can be used or not based on the status.

func (IndexStatus) String

func (s IndexStatus) String() string

type IndexUsing

type IndexUsing byte

IndexUsing is the desired storage type.

const (
	IndexUsing_Default IndexUsing = iota
	IndexUsing_BTree
	IndexUsing_Hash
)

type IndexValueIter

type IndexValueIter interface {
	// Next returns the next value (repo's location) - see IndexKeyValueIter.
	Next(*Context) ([]byte, error)
	Closer
}

IndexValueIter is an iterator of index values.

type IndexedTable

type IndexedTable interface {
	Table
	// LookupPartitions returns partitions scanned by the given IndexLookup
	LookupPartitions(*Context, IndexLookup) (PartitionIter, error)
}

IndexedTable is a table with an index chosen for range scans

type InsertableTable

type InsertableTable interface {
	Table
	// Inserter returns an Inserter for this table. The Inserter will get one call to Insert() for each row to be
	// inserted, and will end with a call to Close() to finalize the insert operation.
	Inserter(*Context) RowInserter
}

InsertableTable is a table that can process insertion of new rows.

type JSONDocument added in v0.9.0

type JSONDocument struct {
	Val interface{}
}

func MustJSON added in v0.9.0

func MustJSON(s string) JSONDocument

func (JSONDocument) Compare added in v0.9.0

func (doc JSONDocument) Compare(ctx *Context, v JSONValue) (int, error)

func (JSONDocument) Contains added in v0.9.0

func (doc JSONDocument) Contains(ctx *Context, candidate JSONValue) (val interface{}, err error)

Contains returns nil in case of a nil value for either the doc.Val or candidate. Otherwise it returns a bool

func (JSONDocument) Extract added in v0.9.0

func (doc JSONDocument) Extract(ctx *Context, path string) (JSONValue, error)

func (JSONDocument) Keys added in v0.9.0

func (doc JSONDocument) Keys(ctx *Context, path string) (val JSONValue, err error)

func (JSONDocument) Overlaps added in v0.9.0

func (doc JSONDocument) Overlaps(ctx *Context, val SearchableJSONValue) (ok bool, err error)

func (JSONDocument) Search added in v0.9.0

func (doc JSONDocument) Search(ctx *Context) (path string, err error)

func (JSONDocument) ToString added in v0.9.0

func (doc JSONDocument) ToString(_ *Context) (string, error)

func (JSONDocument) Unmarshall added in v0.9.0

func (doc JSONDocument) Unmarshall(_ *Context) (JSONDocument, error)

type JSONValue added in v0.9.0

type JSONValue interface {
	// Unmarshall converts a JSONValue to a JSONDocument
	Unmarshall(ctx *Context) (val JSONDocument, err error)
	// Compare compares two JSONValues. It maintains the same return value
	// semantics as Type.Compare()
	Compare(ctx *Context, v JSONValue) (cmp int, err error)
	// ToString marshalls a JSONValue to a valid JSON-encoded string.
	ToString(ctx *Context) (string, error)
}

JSONValue is an integrator specific implementation of a JSON field value.

func ConcatenateJSONValues added in v0.9.0

func ConcatenateJSONValues(ctx *Context, vals ...JSONValue) (JSONValue, error)

type JsonType

type JsonType interface {
	Type
}

JsonType represents the JSON type. https://dev.mysql.com/doc/refman/8.0/en/json.html The type of the returned value is JSONValue.

var JSON JsonType = jsonType{}

type KeyValueCache

type KeyValueCache interface {
	// Put a new value in the cache.
	Put(uint64, interface{}) error
	// Get the value with the given key. An error is returned if the specified key does not exist.
	Get(uint64) (interface{}, error)
	// Size returns the number of elements in the cache.
	Size() int
}

KeyValueCache is a cache of key value pairs.

type LineString added in v0.12.0

type LineString struct {
	SRID   uint32
	Points []Point
}

LineString is the value type returned from LineStringType. Implements GeometryValue.

func DeserializeLine added in v0.14.0

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

DeserializeLine parses the data portion of a byte array in WKB format to a LineString object

func (LineString) GetSRID added in v0.14.0

func (l LineString) GetSRID() uint32

GetSRID implements GeometryValue interface.

func (LineString) Serialize added in v0.14.0

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

Serialize implements GeometryValue interface.

func (LineString) SetSRID added in v0.14.0

func (l LineString) SetSRID(srid uint32) GeometryValue

SetSRID implements GeometryValue interface.

func (LineString) Swap added in v0.14.0

func (l LineString) Swap() GeometryValue

Swap implements GeometryValue interface. TODO: possible in place?

func (LineString) WriteData added in v0.14.0

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

WriteData implements GeometryValue interface.

type LineStringType added in v0.12.0

type LineStringType struct {
	SRID        uint32
	DefinedSRID bool
}

LineStringType represents the LINESTRING type. https://dev.mysql.com/doc/refman/8.0/en/gis-class-linestring.html The type of the returned value is LineString.

func (LineStringType) Compare added in v0.12.0

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

Compare implements Type interface.

func (LineStringType) Convert added in v0.12.0

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

Convert implements Type interface.

func (LineStringType) Equals added in v0.12.0

func (t LineStringType) Equals(otherType Type) bool

Equals implements the Type interface.

func (LineStringType) GetSpatialTypeSRID added in v0.12.0

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

GetSpatialTypeSRID implements SpatialColumnType interface.

func (LineStringType) MatchSRID added in v0.12.0

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

MatchSRID implements SpatialColumnType interface

func (LineStringType) MaxTextResponseByteLength added in v0.14.0

func (t LineStringType) MaxTextResponseByteLength() uint32

MaxTextResponseByteLength implements the Type interface

func (LineStringType) Promote added in v0.12.0

func (t LineStringType) Promote() Type

Promote implements the Type interface.

func (LineStringType) SQL added in v0.12.0

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

SQL implements Type interface.

func (LineStringType) SetSRID added in v0.12.0

func (t LineStringType) SetSRID(v uint32) Type

SetSRID implements SpatialColumnType interface.

func (LineStringType) String added in v0.12.0

func (t LineStringType) String() string

String implements Type interface.

func (LineStringType) Type added in v0.12.0

func (t LineStringType) Type() query.Type

Type implements Type interface.

func (LineStringType) ValueType added in v0.12.0

func (t LineStringType) ValueType() reflect.Type

ValueType implements Type interface.

func (LineStringType) Zero added in v0.12.0

func (t LineStringType) Zero() interface{}

Zero implements Type interface.

type LockState

type LockState int

LockState represents the different states a lock can be in

const (
	// LockDoesNotExist is the state where a lock has never been created
	LockDoesNotExist LockState = iota
	// LockInUse is the state where a lock has been acquired by a user
	LockInUse
	// LockFree is the state where a lock has been created, but is not currently owned by any user
	LockFree
)

type LockSubsystem

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

LockSubsystem manages reentrant named locks

func NewLockSubsystem

func NewLockSubsystem() *LockSubsystem

NewLockSubsystem creates a LockSubsystem object

func (*LockSubsystem) GetLockState

func (ls *LockSubsystem) GetLockState(name string) (state LockState, owner uint32)

GetLockState returns the LockState and owner ID for a lock with a given name.

func (*LockSubsystem) Lock

func (ls *LockSubsystem) Lock(ctx *Context, name string, timeout time.Duration) error

Lock attempts to acquire a lock with a given name for the Id associated with the given ctx.Session within the given timeout

func (*LockSubsystem) ReleaseAll

func (ls *LockSubsystem) ReleaseAll(ctx *Context) (int, error)

ReleaseAll releases all locks the ID associated with the given ctx.Session, and returns the number of locks that were succeessfully released.

func (*LockSubsystem) Unlock

func (ls *LockSubsystem) Unlock(ctx *Context, name string) error

Unlock releases a lock with a given name for the ID associated with the given ctx.Session

type Lockable

type Lockable interface {
	Nameable
	// Lock locks the table either for reads or writes. Any session clients can
	// read while the table is locked for read, but not write.
	// When the table is locked for write, nobody can write except for the
	// session client that requested the lock.
	Lock(ctx *Context, write bool) error
	// Unlock releases the lock for the current session client. It blocks until
	// all reads or writes started during the lock are finished.
	// Context may be nil if the unlock it's because the connection was closed.
	// The id will always be provided, since in some cases context is not
	// available.
	Unlock(ctx *Context, id uint32) error
}

Lockable should be implemented by tables that can be locked and unlocked.

type MemoryManager

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

MemoryManager is in charge of keeping track and managing all the components that operate in memory. There should only be one instance of a memory manager running at the same time in each process.

func NewMemoryManager

func NewMemoryManager(r Reporter) *MemoryManager

NewMemoryManager creates a new manager with the given memory reporter. If nil is given, then the Process reporter will be used by default.

func (*MemoryManager) Free

func (m *MemoryManager) Free()

Free the memory of all freeable caches.

func (*MemoryManager) HasAvailable

func (m *MemoryManager) HasAvailable() bool

HasAvailable reports whether the memory manager has any available memory.

func (*MemoryManager) NewHistoryCache

func (m *MemoryManager) NewHistoryCache() (KeyValueCache, DisposeFunc)

NewHistoryCache returns an empty history cache and a function to dispose it when it's no longer needed.

func (*MemoryManager) NewLRUCache

func (m *MemoryManager) NewLRUCache(size uint) (KeyValueCache, DisposeFunc)

NewLRUCache returns an empty LRU cache and a function to dispose it when it's no longer needed.

func (*MemoryManager) NewRows2Cache added in v0.12.0

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

NewRowsCache returns an empty rows cache and a function to dispose it when it's no longer needed.

func (*MemoryManager) NewRowsCache

func (m *MemoryManager) NewRowsCache() (RowsCache, DisposeFunc)

NewRowsCache returns an empty rows cache and a function to dispose it when it's no longer needed.

func (*MemoryManager) NumCaches added in v0.11.0

func (m *MemoryManager) NumCaches() int

type MultiDatabaser added in v0.12.0

type MultiDatabaser interface {
	// DatabaseProvider returns the current DatabaseProvider.
	DatabaseProvider() DatabaseProvider
	// WithDatabaseProvider returns a new node instance with the database provider replaced with the one given as parameter.
	WithDatabaseProvider(DatabaseProvider) (Node, error)
}

MultiDatabaser is a node that contains a reference to a database provider. This interface is intended for very specific nodes that must resolve databases during execution time rather than during analysis, such as block statements where the execution of a nested statement in the block may affect future statements within that same block.

type MultiLineString added in v0.14.0

type MultiLineString struct {
	SRID  uint32
	Lines []LineString
}

MultiLineString is the value type returned from MultiLineStringType. Implements GeometryValue.

func DeserializeMLine added in v0.14.0

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

DeserializeMLine parses the data portion of a byte array in WKB format to a MultiLineString object

func (MultiLineString) GetSRID added in v0.14.0

func (p MultiLineString) GetSRID() uint32

GetSRID implements GeometryValue interface.

func (MultiLineString) Serialize added in v0.14.0

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

Serialize implements GeometryValue interface.

func (MultiLineString) SetSRID added in v0.14.0

func (p MultiLineString) SetSRID(srid uint32) GeometryValue

SetSRID implements GeometryValue interface.

func (MultiLineString) Swap added in v0.14.0

func (p MultiLineString) Swap() GeometryValue

Swap implements GeometryValue interface.

func (MultiLineString) WriteData added in v0.14.0

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

WriteData implements GeometryValue interface.

type MultiLineStringType added in v0.14.0

type MultiLineStringType struct {
	SRID        uint32
	DefinedSRID bool
}

MultiLineStringType represents the MUTILINESTRING type. https://dev.mysql.com/doc/refman/8.0/en/gis-class-multilinestring.html The type of the returned value is MultiLineString.

func (MultiLineStringType) Compare added in v0.14.0

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

Compare implements Type interface.

func (MultiLineStringType) Convert added in v0.14.0

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

Convert implements Type interface.

func (MultiLineStringType) Equals added in v0.14.0

func (t MultiLineStringType) Equals(otherType Type) bool

Equals implements the Type interface.

func (MultiLineStringType) GetSpatialTypeSRID added in v0.14.0

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

GetSpatialTypeSRID implements SpatialColumnType interface.

func (MultiLineStringType) MatchSRID added in v0.14.0

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

MatchSRID implements SpatialColumnType interface

func (MultiLineStringType) MaxTextResponseByteLength added in v0.14.0

func (t MultiLineStringType) MaxTextResponseByteLength() uint32

MaxTextResponseByteLength implements the Type interface

func (MultiLineStringType) Promote added in v0.14.0

func (t MultiLineStringType) Promote() Type

Promote implements the Type interface.

func (MultiLineStringType) SQL added in v0.14.0

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

SQL implements Type interface.

func (MultiLineStringType) SetSRID added in v0.14.0

func (t MultiLineStringType) SetSRID(v uin