mysql

var (
	Raw = jet.Raw

	RawBool      = jet.RawBool
	RawInt       = jet.RawInt
	RawFloat     = jet.RawFloat
	RawString    = jet.RawString
	RawTime      = jet.RawTime
	RawTimestamp = jet.RawTimestamp
	RawDate      = jet.RawDate
)

Raw can be used for any unsupported functions, operators or expressions. For example: Raw("current_database()") Raw helper methods for each of the mysql types

var (
	// AND function adds AND operator between expressions.
	AND = jet.AND
	// OR function adds OR operator between expressions.
	OR = jet.OR
)

This functions can be used, instead of its method counterparts, to have a better indentation of a complex condition in the Go code and in the generated SQL.

var (
	STAR    = jet.STAR
	NULL    = jet.NULL
	DEFAULT = jet.DEFAULT
)

Keywords

var (
	UPDATE = jet.NewRowLock("UPDATE")
	SHARE  = jet.NewRowLock("SHARE")
)

Row lock types

var (
	PARTITION_BY = jet.PARTITION_BY
	ORDER_BY     = jet.ORDER_BY
	UNBOUNDED    = jet.UNBOUNDED
	CURRENT_ROW  = jet.CURRENT_ROW
)

Window function clauses

var ABSf = jet.ABSf

ABSf calculates absolute value from float expression

var ABSi = jet.ABSi

ABSi calculates absolute value from int expression

var AVG = jet.AVG

AVG is aggregate function used to calculate avg value from numeric expression

var BIT_AND = jet.BIT_AND

BIT_AND is aggregate function used to calculates the bitwise AND of all non-null input values, or null if none.

var BIT_LENGTH = jet.BIT_LENGTH

BIT_LENGTH returns number of bits in string expression

var BIT_NOT = jet.BIT_NOT

BIT_NOT inverts every bit in integer expression result

var BIT_OR = jet.BIT_OR

BIT_OR is aggregate function used to calculates the bitwise OR of all non-null input values, or null if none.

var Bool = jet.Bool

Bool creates new bool literal expression

var BoolColumn = jet.BoolColumn

BoolColumn creates named bool column.

var BoolExp = jet.BoolExp

BoolExp is bool expression wrapper around arbitrary expression. Allows go compiler to see any expression as bool expression. Does not add sql cast to generated sql builder output.

var CASE = jet.CASE

CASE create CASE operator with optional list of expressions

var CEIL = jet.CEIL

CEIL calculates ceil of float expression

var CHAR_LENGTH = jet.CHAR_LENGTH

CHAR_LENGTH returns number of characters in string expression

var COALESCE = jet.COALESCE

COALESCE function returns the first of its arguments that is not null.

var CONCAT = jet.CONCAT

CONCAT adds two or more expressions together

var CONCAT_WS = jet.CONCAT_WS

CONCAT_WS adds two or more expressions together with a separator.

var COUNT = jet.COUNT

COUNT is aggregate function. Returns number of input rows for which the value of expression is not null.

var CUME_DIST = jet.CUME_DIST

CUME_DIST calculates cumulative distribution: (number of partition rows preceding or peer with current row) / total partition rows

var CURRENT_DATE = jet.CURRENT_DATE

CURRENT_DATE returns current date

var DENSE_RANK = jet.DENSE_RANK

DENSE_RANK returns rank of the current row without gaps; this function counts peer groups

var DISTINCT = jet.DISTINCT

DISTINCT operator can be used to return distinct values of expr

var DateColumn = jet.DateColumn

DateColumn creates named date column.

var DateExp = jet.DateExp

DateExp is date expression wrapper around arbitrary expression. Allows go compiler to see any expression as date expression. Does not add sql cast to generated sql builder output.

var DateTimeColumn = jet.TimestampColumn

DateTimeColumn creates named timestamp column

var DateTimeExp = jet.TimestampExp

DateTimeExp is timestamp expression wrapper around arbitrary expression. Allows go compiler to see any expression as timestamp expression. Does not add sql cast to generated sql builder output.

var Decimal = jet.Decimal

Decimal creates new float literal expression from string value

var Dialect = newDialect()

Dialect is implementation of MySQL dialect for SQL Builder serialisation.

var EXISTS = jet.EXISTS

EXISTS checks for existence of the rows in subQuery

var FIRST_VALUE = jet.FIRST_VALUE

FIRST_VALUE returns value evaluated at the row that is the first row of the window frame

var FLOOR = jet.FLOOR

FLOOR calculates floor of float expression

var FORMAT = jet.FORMAT

FORMAT formats a number to a format like "#,###,###.##", rounded to a specified number of decimal places, then it returns the result as a string.

var Float = jet.Float

Float creates new float literal expression from float64 value

var FloatColumn = jet.FloatColumn

FloatColumn creates named float column.

var FloatExp = jet.FloatExp

FloatExp is date expression wrapper around arbitrary expression. Allows go compiler to see any expression as float expression. Does not add sql cast to generated sql builder output.

var Func = jet.Func

Func can be used to call custom or unsupported database functions.

var GREATEST = jet.GREATEST

GREATEST selects the largest value from a list of expressions, or null if any of the expressions is null.

var GROUPING = jet.GROUPING

GROUPING function is used to identify which columns are included in a grouping set or a subtotal row. It takes as input the name of a column and returns 1 if the column is not included in the current grouping set, and 0 otherwise. It can be also used with multiple parameters to check if a set of columns is included in the current grouping set. The result of the GROUPING function would then be an integer bit mask having 1’s for the arguments which have GROUPING(argument) as 1.

var Int = jet.Int

Int is constructor for 64 bit signed integer expressions literals.

var Int16 = jet.Int16

Int16 is constructor for 16 bit signed integer expressions literals.

var Int32 = jet.Int32

Int32 is constructor for 32 bit signed integer expressions literals.

var Int64 = jet.Int

Int64 is constructor for 64 bit signed integer expressions literals.

var Int8 = jet.Int8

Int8 is constructor for 8 bit signed integer expressions literals.

var IntExp = jet.IntExp

IntExp is int expression wrapper around arbitrary expression. Allows go compiler to see any expression as int expression. Does not add sql cast to generated sql builder output.

var IntegerColumn = jet.IntegerColumn

IntegerColumn creates named integer column.

var LAG = jet.LAG

LAG returns value evaluated at the row that is offset rows before the current row within the partition; if there is no such row, instead return default (which must be of the same type as value). Both offset and default are evaluated with respect to the current row. If omitted, offset defaults to 1 and default to null

var LAST_VALUE = jet.LAST_VALUE

LAST_VALUE returns value evaluated at the row that is the last row of the window frame

var LEAD = jet.LEAD

LEAD returns value evaluated at the row that is offset rows after the current row within the partition; if there is no such row, instead return default (which must be of the same type as value). Both offset and default are evaluated with respect to the current row. If omitted, offset defaults to 1 and default to null

var LEAST = jet.LEAST

LEAST selects the smallest value from a list of expressions, or null if any of the expressions is null.

var LEFT = jet.LEFT

LEFT returns first n characters in the string. When n is negative, return all but last |n| characters.

var LN = jet.LN

LN calculates natural algorithm of float expression

var LOG = jet.LOG

LOG calculates logarithm of float expression

var LOWER = jet.LOWER

LOWER returns string expression in lower case

var LTRIM = jet.LTRIM

LTRIM removes the longest string containing only characters from characters (a space by default) from the start of string

var MAX = jet.MAX

MAX is aggregate function. Returns maximum value of expression across all input values

var MAXf = jet.MAXf

MAXf is aggregate function. Returns maximum value of float expression across all input values

var MAXi = jet.MAXi

MAXi is aggregate function. Returns maximum value of int expression across all input values

var MD5 = jet.MD5

MD5 calculates the MD5 hash of string, returning the result in hexadecimal

var MIN = jet.MIN

MIN is aggregate function. Returns minimum value of int expression across all input values

var MINf = jet.MINf

MINf is aggregate function. Returns minimum value of float expression across all input values

var MINi = jet.MINi

MINi is aggregate function. Returns minimum value of int expression across all input values

var NOT = jet.NOT

NOT returns negation of bool expression result

var NTH_VALUE = jet.NTH_VALUE

NTH_VALUE returns value evaluated at the row that is the nth row of the window frame (counting from 1); null if no such row

var NTILE = jet.NTILE

NTILE returns integer ranging from 1 to the argument value, dividing the partition as equally as possible

var NULLIF = jet.NULLIF

NULLIF function returns a null value if value1 equals value2; otherwise it returns value1.

var NewEnumValue = jet.NewEnumValue

NewEnumValue creates new named enum value

var OCTET_LENGTH = jet.OCTET_LENGTH

OCTET_LENGTH returns number of bytes in string expression

var PERCENT_RANK = jet.PERCENT_RANK

PERCENT_RANK calculates relative rank of the current row: (rank - 1) / (total partition rows - 1)

var POW = jet.POW

POW calculates power of base with exponent

var POWER = jet.POWER

POWER calculates power of base with exponent

var RANK = jet.RANK

RANK of the current row with gaps; same as row_number of its first peer

var REGEXP_LIKE = jet.REGEXP_LIKE

REGEXP_LIKE Returns 1 if the string expr matches the regular expression specified by the pattern pat, 0 otherwise.

var REPEAT = jet.REPEAT

REPEAT repeats string the specified number of times

var REPLACE = jet.REPLACE

REPLACE replaces all occurrences in string of substring from with substring to

var REVERSE = jet.REVERSE

REVERSE returns reversed string.

var RIGHT = jet.RIGHT

RIGHT returns last n characters in the string. When n is negative, return all but first |n| characters.

var ROUND = jet.ROUND

ROUND calculates round of a float expressions with optional precision

var ROW = jet.ROW

ROW function is used to create a tuple value that consists of a set of expressions or column values.

var ROW_NUMBER = jet.ROW_NUMBER

ROW_NUMBER returns number of the current row within its partition, counting from 1

var RTRIM = jet.RTRIM

RTRIM removes the longest string containing only characters from characters (a space by default) from the end of string

var SIGN = jet.SIGN

SIGN returns sign of float expression

var SQRT = jet.SQRT

SQRT calculates square root of numeric expression

var SUBSTR = jet.SUBSTR

SUBSTR extracts substring

var SUM = jet.SUM

SUM is aggregate function. Returns sum of all expressions

var SUMf = jet.SUMf

SUMf is aggregate function. Returns sum of float expression.

var SUMi = jet.SUMi

SUMi is aggregate function. Returns sum of integer expression.

var SetLogger = jet.SetLoggerFunc

SetLogger sets automatic statement logging Deprecated: use SetQueryLogger instead.

var SetQueryLogger = jet.SetQueryLogger

SetQueryLogger sets automatic query logging function.

var String = jet.String

String creates new string literal expression

var StringColumn = jet.StringColumn

StringColumn creates named string column.

var StringExp = jet.StringExp

StringExp is string expression wrapper around arbitrary expression. Allows go compiler to see any expression as string expression. Does not add sql cast to generated sql builder output.

var TRUNC = TRUNCATE

TRUNC calculates trunc of float expression with precision

var TRUNCATE = func(floatExpression jet.FloatExpression, precision jet.IntegerExpression) jet.FloatExpression {
	return jet.NewFloatFunc("TRUNCATE", floatExpression, precision)
}

TRUNCATE calculates trunc of float expression with precision

var TimeColumn = jet.TimeColumn

TimeColumn creates named time column

var TimeExp = jet.TimeExp

TimeExp is time expression wrapper around arbitrary expression. Allows go compiler to see any expression as time expression. Does not add sql cast to generated sql builder output.

var TimestampColumn = jet.TimestampColumn

TimestampColumn creates named timestamp column

var TimestampExp = jet.TimestampExp

TimestampExp is timestamp expression wrapper around arbitrary expression. Allows go compiler to see any expression as timestamp expression. Does not add sql cast to generated sql builder output.

var UPPER = jet.UPPER

UPPER returns string expression in upper case

var UUID = jet.UUID

UUID is a helper function to create string literal expression from uuid object value can be any uuid type with a String method

var Uint16 = jet.Uint16

Uint16 is constructor for 16 bit unsigned integer expressions literals.

var Uint32 = jet.Uint32

Uint32 is constructor for 32 bit unsigned integer expressions literals.

var Uint64 = jet.Uint64

Uint64 is constructor for 64 bit unsigned integer expressions literals.

var Uint8 = jet.Uint8

Uint8 is constructor for 8 bit unsigned integer expressions literals.

var WITH_ROLLUP = jet.WITH_ROLLUP

WITH_ROLLUP operator is used with the GROUP BY clause to generate all prefixes of a group of columns including the empty list. It creates extra rows in the result set that represent the subtotal values for each combination of columns.

var Window = jet.WindowName

Window is used to specify window reference from WINDOW clause