Gleipnir/jet
4
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Dialect refactor improvements and clean up.

Browse source
This commit is contained in:
go-jet 2019-08-06 10:29:04 +02:00
parent 23fd973699
commit 647ef21aaf
52 changed files with 1097 additions and 671 deletions
Download patch file Download diff file Expand all files Collapse all files

89
mysql/bool_expression_test.go
View file

@ -1,89 +0,0 @@
package mysql
import (
"testing"
)
func TestBoolExpressionEQ(t *testing.T) {
assertClauseSerializeErr(t, table1ColBool.EQ(nil), "jet: nil rhs")
assertClauseSerialize(t, table1ColBool.EQ(table2ColBool), "(table1.col_bool = table2.col_bool)")
assertClauseSerialize(t, table1ColBool.EQ(Bool(true)), "(table1.col_bool = ?)", true)
}
func TestBoolExpressionNOT_EQ(t *testing.T) {
assertClauseSerialize(t, table1ColBool.NOT_EQ(table2ColBool), "(table1.col_bool != table2.col_bool)")
assertClauseSerialize(t, table1ColBool.NOT_EQ(Bool(true)), "(table1.col_bool != ?)", true)
}
func TestBoolExpressionIS_DISTINCT_FROM(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(table2ColBool), "(NOT table1.col_bool <=> table2.col_bool)")
assertClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(Bool(false)), "(NOT table1.col_bool <=> ?)", false)
}
func TestBoolExpressionIS_NOT_DISTINCT_FROM(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(table2ColBool), "(table1.col_bool <=> table2.col_bool)")
assertClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(Bool(false)), "(table1.col_bool <=> ?)", false)
}
func TestBoolExpressionIS_TRUE(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_TRUE(), "table1.col_bool IS TRUE")
assertClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE(),
`(? = table1.col_int) IS TRUE`, int64(2))
assertClauseSerialize(t, (Int(2).EQ(table1ColInt)).IS_TRUE().AND(Int(4).EQ(table2ColInt)),
`((? = table1.col_int) IS TRUE AND (? = table2.col_int))`, int64(2), int64(4))
}
func TestBoolExpressionIS_NOT_TRUE(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_NOT_TRUE(), "table1.col_bool IS NOT TRUE")
}
func TestBoolExpressionIS_FALSE(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_FALSE(), "table1.col_bool IS FALSE")
}
func TestBoolExpressionIS_NOT_FALSE(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_NOT_FALSE(), "table1.col_bool IS NOT FALSE")
}
func TestBoolExpressionIS_UNKNOWN(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_UNKNOWN(), "table1.col_bool IS UNKNOWN")
}
func TestBoolExpressionIS_NOT_UNKNOWN(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_NOT_UNKNOWN(), "table1.col_bool IS NOT UNKNOWN")
}
func TestBinaryBoolExpressionAsProjection(t *testing.T) {
boolExpression := Int(2).EQ(Int(3))
assertProjectionSerialize(t, boolExpression, "? = ?", int64(2), int64(3))
assertProjectionSerialize(t, boolExpression.AS("alias_eq_expression"),
`(? = ?) AS "alias_eq_expression"`, int64(2), int64(3))
}
func TestBoolLiteral(t *testing.T) {
assertClauseSerialize(t, Bool(true), "?", true)
assertClauseSerialize(t, Bool(false), "?", false)
}
//
//func TestExists(t *testing.T) {
//
// assertClauseSerialize(t, EXISTS(
// table2.
// SELECT(Int(1)).
// WHERE(table1Col1.EQ(table2Col3)),
// ),
// `(EXISTS (
// SELECT ?
// FROM db.table2
// WHERE table1.col1 = table2.col3
//))`, int64(1))
//}
//
//func TestBoolExp(t *testing.T) {
// assertClauseSerialize(t, BoolExp(String("true")), "?", "true")
// assertClauseSerialize(t, BoolExp(String("true")).IS_TRUE(), "? IS TRUE", "true")
//}

9
mysql/column.go
View file

@ -1,9 +0,0 @@
package mysql
import "github.com/go-jet/jet/internal/jet"
type Column jet.Column
type IColumnList jet.IColumnList
var ColumnList = jet.ColumnList

41
mysql/columns.go Normal file
View file

@ -0,0 +1,41 @@
package mysql
import "github.com/go-jet/jet/internal/jet"
type Column jet.Column
type IColumnList jet.IColumnList
var ColumnList = jet.ColumnList
type ColumnBool jet.ColumnBool
var BoolColumn = jet.BoolColumn
type ColumnString jet.ColumnString
var StringColumn = jet.StringColumn
type ColumnInteger jet.ColumnInteger
var IntegerColumn = jet.IntegerColumn
type ColumnFloat jet.ColumnFloat
var FloatColumn = jet.FloatColumn
type ColumnTime jet.ColumnTime
var TimeColumn = jet.TimeColumn
type ColumnDate jet.ColumnDate
var DateColumn = jet.DateColumn
type ColumnDateTime jet.ColumnTimestamp
var DateTimeColumn = jet.TimestampColumn
type ColumnTimestamp jet.ColumnTimestamp
var TimestampColumn = jet.TimestampColumn

53
mysql/dialect.go
View file

@ -14,6 +14,7 @@ func NewDialect() jet.Dialect {
serializeOverrides["IS NOT DISTINCT FROM"] = mysql_IS_NOT_DISTINCT_FROM
serializeOverrides["/"] = mysql_DIVISION
serializeOverrides["#"] = mysql_BIT_XOR
serializeOverrides[jet.StringConcatOperator] = mysql_CONCAT_operator
mySQLDialectParams := jet.DialectParams{
Name: "MySQL",
@ -24,36 +25,12 @@ func NewDialect() jet.Dialect {
ArgumentPlaceholder: func(int) string {
return "?"
},
UpdateAssigment: mysqlUpdateAssigment,
SupportsReturning: false,
}
return jet.NewDialect(mySQLDialectParams)
}
func mysqlUpdateAssigment(columns []jet.IColumn, values []jet.Clause, out *jet.SqlBuilder) (err error) {
if len(columns) != len(values) {
return errors.New("jet: mismatch in numers of columns and values")
}
for i, column := range columns {
if i > 0 {
out.WriteString(", ")
}
out.WriteString(column.Name())
out.WriteString(" = ")
if err = jet.Serialize(values[i], jet.UpdateStatementType, out); err != nil {
return err
}
}
return nil
}
func mysql_BIT_XOR(expressions ...jet.Expression) jet.SerializeFunc {
return func(statement jet.StatementType, out *jet.SqlBuilder, options ...jet.SerializeOption) error {
if len(expressions) != 2 {
@ -76,6 +53,30 @@ func mysql_BIT_XOR(expressions ...jet.Expression) jet.SerializeFunc {
}
}
func mysql_CONCAT_operator(expressions ...jet.Expression) jet.SerializeFunc {
return func(statement jet.StatementType, out *jet.SqlBuilder, options ...jet.SerializeOption) error {
if len(expressions) != 2 {
return errors.New("jet: invalid number of expressions for operator")
}
out.WriteString("CONCAT(")
if err := jet.Serialize(expressions[0], statement, out, options...); err != nil {
return err
}
out.WriteString(", ")
if err := jet.Serialize(expressions[1], statement, out, options...); err != nil {
return err
}
out.WriteString(")")
return nil
}
}
func mysql_DIVISION(expressions ...jet.Expression) jet.SerializeFunc {
return func(statement jet.StatementType, out *jet.SqlBuilder, options ...jet.SerializeOption) error {
if len(expressions) != 2 {
@ -126,7 +127,7 @@ func mysql_IS_NOT_DISTINCT_FROM(expressions ...jet.Expression) jet.SerializeFunc
func mysql_IS_DISTINCT_FROM(expressions ...jet.Expression) jet.SerializeFunc {
return func(statement jet.StatementType, out *jet.SqlBuilder, options ...jet.SerializeOption) error {
out.WriteString("NOT")
out.WriteString("NOT(")
err := mysql_IS_NOT_DISTINCT_FROM(expressions...)(statement, out, options...)
@ -134,6 +135,8 @@ func mysql_IS_DISTINCT_FROM(expressions ...jet.Expression) jet.SerializeFunc {
return err
}
out.WriteString(")")
return nil
}
}

35
mysql/dialect_test.go Normal file
View file

@ -0,0 +1,35 @@
package mysql
import (
"testing"
)
func TestBoolExpressionIS_DISTINCT_FROM(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(table2ColBool), "(NOT(table1.col_bool <=> table2.col_bool))")
assertClauseSerialize(t, table1ColBool.IS_DISTINCT_FROM(Bool(false)), "(NOT(table1.col_bool <=> ?))", false)
}
func TestBoolExpressionIS_NOT_DISTINCT_FROM(t *testing.T) {
assertClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(table2ColBool), "(table1.col_bool <=> table2.col_bool)")
assertClauseSerialize(t, table1ColBool.IS_NOT_DISTINCT_FROM(Bool(false)), "(table1.col_bool <=> ?)", false)
}
func TestBoolLiteral(t *testing.T) {
assertClauseSerialize(t, Bool(true), "?", true)
assertClauseSerialize(t, Bool(false), "?", false)
}
func TestIntegerExpressionDIV(t *testing.T) {
assertClauseSerialize(t, table1ColInt.DIV(table2ColInt), "(table1.col_int DIV table2.col_int)")
assertClauseSerialize(t, table1ColInt.DIV(Int(11)), "(table1.col_int DIV ?)", int64(11))
}
func TestIntExpressionPOW(t *testing.T) {
assertClauseSerialize(t, table1ColInt.POW(table2ColInt), "POW(table1.col_int, table2.col_int)")
assertClauseSerialize(t, table1ColInt.POW(Int(11)), "POW(table1.col_int, ?)", int64(11))
}
func TestIntExpressionBIT_XOR(t *testing.T) {
assertClauseSerialize(t, table1ColInt.BIT_XOR(table2ColInt), "(table1.col_int ^ table2.col_int)")
assertClauseSerialize(t, table1ColInt.BIT_XOR(Int(11)), "(table1.col_int ^ ?)", int64(11))
}

13
mysql/expressions.go
View file

@ -12,10 +12,21 @@ type IntegerExpression jet.IntegerExpression
type FloatExpression jet.FloatExpression
type TimeExpression jet.TimeExpression
type DateExpression jet.DateExpression
type DateTimeExpression jet.TimestampExpression
type TimestampExpression jet.TimestampExpression
type TimeExpression jet.TimeExpression
var BoolExp = jet.BoolExp
var StringExp = jet.StringExp
var IntExp = jet.IntExp
var FloatExp = jet.FloatExp
var TimeExp = jet.TimeExp
var DateExp = jet.DateExp
var DateTimeExp = jet.TimestampExp
var TimestampExp = jet.TimestampExp
var RAW = jet.RAW

122
mysql/functions.go Normal file
View file

@ -0,0 +1,122 @@
package mysql
import "github.com/go-jet/jet/internal/jet"
// ------------------ Mathematical functions ---------------//
var POW = jet.POW
var LN = jet.LN
var LOG = jet.LOG
var ABSf = jet.ABSf
var ABSi = jet.ABSi
var POWER = jet.POWER
var SQRT = jet.SQRT
func CBRT(number jet.NumericExpression) jet.FloatExpression {
return POWER(number, Float(1.0).DIV(Float(3.0)))
}
var CEIL = jet.CEIL
var FLOOR = jet.FLOOR
var ROUND = jet.ROUND
var SIGN = jet.SIGN
var TRUNC = TRUNCATE
var TRUNCATE = func(floatExpression jet.FloatExpression, precision jet.IntegerExpression) jet.FloatExpression {
return jet.NewFloatFunc("TRUNCATE", floatExpression, precision)
}
var MINUSi = jet.MINUSi
var MINUSf = jet.MINUSf
var BIT_NOT = jet.BIT_NOT
// ----------------- Aggregate functions -------------------//
var BIT_AND = jet.BIT_AND
var BIT_OR = jet.BIT_OR
var BOOL_AND = jet.BOOL_AND
var BOOL_OR = jet.BOOL_OR
var EVERY = jet.EVERY
var MAXi = jet.MAXi
var MINi = jet.MINi
var SUMi = jet.SUMi
var SUMf = jet.SUMf
var AVG = jet.AVG
var MAXf = jet.MAXf
var MINf = jet.MINf
var COUNT = jet.COUNT
//--------------------- String functions ------------------//
var REGEXP_LIKE = jet.REGEXP_LIKE
var BIT_LENGTH = jet.BIT_LENGTH
var CHAR_LENGTH = jet.CHAR_LENGTH
var OCTET_LENGTH = jet.OCTET_LENGTH
var LOWER = jet.LOWER
var UPPER = jet.UPPER
var BTRIM = jet.BTRIM
var LTRIM = jet.LTRIM
var RTRIM = jet.RTRIM
var CHR = jet.CHR
var CONCAT = jet.CONCAT
var CONCAT_WS = jet.CONCAT_WS
var CONVERT = jet.CONVERT
var CONVERT_FROM = jet.CONVERT_FROM
var CONVERT_TO = jet.CONVERT_TO
var ENCODE = jet.ENCODE
var DECODE = jet.DECODE
var FORMAT = jet.FORMAT
var INITCAP = jet.INITCAP
var LEFT = jet.LEFT
var RIGHT = jet.RIGHT
func LENGTH(str jet.StringExpression) jet.StringExpression {
return jet.LENGTH(str)
}
func LPAD(str jet.StringExpression, length jet.IntegerExpression, text jet.StringExpression) jet.StringExpression {
return jet.LPAD(str, length, text)
}
func RPAD(str jet.StringExpression, length jet.IntegerExpression, text jet.StringExpression) jet.StringExpression {
return jet.RPAD(str, length, text)
}
var MD5 = jet.MD5
var REPEAT = jet.REPEAT
var REPLACE = jet.REPLACE
var REVERSE = jet.REVERSE
var STRPOS = jet.STRPOS
var SUBSTR = jet.SUBSTR
var TO_ASCII = jet.TO_ASCII
var TO_HEX = jet.TO_HEX
//----------Data Type Formatting Functions ----------------------//
var TO_CHAR = jet.TO_CHAR
var TO_DATE = jet.TO_DATE
var TO_NUMBER = jet.TO_NUMBER
var TO_TIMESTAMP = jet.TO_TIMESTAMP
//----------------- Date/Time Functions and Operators ------------//
var CURRENT_DATE = jet.CURRENT_DATE
var CURRENT_TIME = jet.CURRENT_TIME
var CURRENT_TIMESTAMP = jet.CURRENT_TIMESTAMP
var LOCALTIME = jet.LOCALTIME
var LOCALTIMESTAMP = jet.LOCALTIMESTAMP
func NOW(fsp ...int) DateTimeExpression {
if len(fsp) > 0 {
return jet.NewTimestampFunc("NOW", Int(int64(fsp[0]), true))
}
return jet.NewTimestampFunc("NOW")
}
// --------------- Conditional Expressions Functions -------------//
var COALESCE = jet.COALESCE
var NULLIF = jet.NULLIF
var GREATEST = jet.GREATEST
var LEAST = jet.LEAST
var EXISTS = jet.EXISTS
var CASE = jet.CASE

107
mysql/integer_expression_test.go
View file

@ -1,107 +0,0 @@
package mysql
import (
"testing"
)
func TestIntegerExpressionEQ(t *testing.T) {
assertClauseSerialize(t, table1ColInt.EQ(table2ColInt), "(table1.col_int = table2.col_int)")
assertClauseSerialize(t, table1ColInt.EQ(Int(11)), "(table1.col_int = ?)", int64(11))
}
func TestIntegerExpressionNOT_EQ(t *testing.T) {
assertClauseSerialize(t, table1ColInt.NOT_EQ(table2ColInt), "(table1.col_int != table2.col_int)")
assertClauseSerialize(t, table1ColInt.NOT_EQ(Int(11)), "(table1.col_int != ?)", int64(11))
}
func TestIntegerExpressionGT(t *testing.T) {
assertClauseSerialize(t, table1ColInt.GT(table2ColInt), "(table1.col_int > table2.col_int)")
assertClauseSerialize(t, table1ColInt.GT(Int(11)), "(table1.col_int > ?)", int64(11))
}
func TestIntegerExpressionGT_EQ(t *testing.T) {
assertClauseSerialize(t, table1ColInt.GT_EQ(table2ColInt), "(table1.col_int >= table2.col_int)")
assertClauseSerialize(t, table1ColInt.GT_EQ(Int(11)), "(table1.col_int >= ?)", int64(11))
}
func TestIntegerExpressionLT(t *testing.T) {
assertClauseSerialize(t, table1ColInt.LT(table2ColInt), "(table1.col_int < table2.col_int)")
assertClauseSerialize(t, table1ColInt.LT(Int(11)), "(table1.col_int < ?)", int64(11))
}
func TestIntegerExpressionLT_EQ(t *testing.T) {
assertClauseSerialize(t, table1ColInt.LT_EQ(table2ColInt), "(table1.col_int <= table2.col_int)")
assertClauseSerialize(t, table1ColInt.LT_EQ(Int(11)), "(table1.col_int <= ?)", int64(11))
}
func TestIntegerExpressionADD(t *testing.T) {
assertClauseSerialize(t, table1ColInt.ADD(table2ColInt), "(table1.col_int + table2.col_int)")
assertClauseSerialize(t, table1ColInt.ADD(Int(11)), "(table1.col_int + ?)", int64(11))
}
func TestIntegerExpressionSUB(t *testing.T) {
assertClauseSerialize(t, table1ColInt.SUB(table2ColInt), "(table1.col_int - table2.col_int)")
assertClauseSerialize(t, table1ColInt.SUB(Int(11)), "(table1.col_int - ?)", int64(11))
}
func TestIntegerExpressionMUL(t *testing.T) {
assertClauseSerialize(t, table1ColInt.MUL(table2ColInt), "(table1.col_int * table2.col_int)")
assertClauseSerialize(t, table1ColInt.MUL(Int(11)), "(table1.col_int * ?)", int64(11))
}
func TestIntegerExpressionDIV(t *testing.T) {
assertClauseSerialize(t, table1ColInt.DIV(table2ColInt), "(table1.col_int DIV table2.col_int)")
assertClauseSerialize(t, table1ColInt.DIV(Int(11)), "(table1.col_int DIV ?)", int64(11))
}
func TestIntExpressionMOD(t *testing.T) {
assertClauseSerialize(t, table1ColInt.MOD(table2ColInt), "(table1.col_int % table2.col_int)")
assertClauseSerialize(t, table1ColInt.MOD(Int(11)), "(table1.col_int % ?)", int64(11))
}
func TestIntExpressionPOW(t *testing.T) {
assertClauseSerialize(t, table1ColInt.POW(table2ColInt), "POW(table1.col_int, table2.col_int)")
assertClauseSerialize(t, table1ColInt.POW(Int(11)), "POW(table1.col_int, ?)", int64(11))
}
func TestIntExpressionBIT_NOT(t *testing.T) {
assertClauseSerialize(t, BIT_NOT(table2ColInt), "(~ table2.col_int)")
assertClauseSerialize(t, BIT_NOT(Int(11)), "(~ ?)", int64(11))
}
func TestIntExpressionBIT_AND(t *testing.T) {
assertClauseSerialize(t, table1ColInt.BIT_AND(table2ColInt), "(table1.col_int & table2.col_int)")
assertClauseSerialize(t, table1ColInt.BIT_AND(Int(11)), "(table1.col_int & ?)", int64(11))
}
func TestIntExpressionBIT_OR(t *testing.T) {
assertClauseSerialize(t, table1ColInt.BIT_OR(table2ColInt), "(table1.col_int | table2.col_int)")
assertClauseSerialize(t, table1ColInt.BIT_OR(Int(11)), "(table1.col_int | ?)", int64(11))
}
func TestIntExpressionBIT_XOR(t *testing.T) {
assertClauseSerialize(t, table1ColInt.BIT_XOR(table2ColInt), "(table1.col_int ^ table2.col_int)")
assertClauseSerialize(t, table1ColInt.BIT_XOR(Int(11)), "(table1.col_int ^ ?)", int64(11))
}
func TestIntExpressionBIT_SHIFT_LEFT(t *testing.T) {
assertClauseSerialize(t, table1ColInt.BIT_SHIFT_LEFT(table2ColInt), "(table1.col_int << table2.col_int)")
assertClauseSerialize(t, table1ColInt.BIT_SHIFT_LEFT(Int(11)), "(table1.col_int << ?)", int64(11))
}
func TestIntExpressionBIT_SHIFT_RIGHT(t *testing.T) {
assertClauseSerialize(t, table1ColInt.BIT_SHIFT_RIGHT(table2ColInt), "(table1.col_int >> table2.col_int)")
assertClauseSerialize(t, table1ColInt.BIT_SHIFT_RIGHT(Int(11)), "(table1.col_int >> ?)", int64(11))
}
//
//func TestIntExpressionIntExp(t *testing.T) {
// assertClauseSerialize(t, IntExp(table1ColFloat), "table1.col_float")
// assertClauseSerialize(t, IntExp(table1ColFloat.ADD(table2ColFloat)).ADD(Int(11)),
// "((table1.col_float + table2.col_float) + ?)", int64(11))
//}
func TestIntExpression_MINUSi(t *testing.T) {
assertClauseSerialize(t, MINUSi(table2ColInt), "(- table2.col_int)")
assertClauseSerialize(t, MINUSi(Int(3)), "(- ?)", int64(3))
}

13
mysql/literal.go Normal file
View file

@ -0,0 +1,13 @@
package mysql
import "github.com/go-jet/jet/internal/jet"
var Bool = jet.Bool
var Int = jet.Int
var Float = jet.Float
var String = jet.String
var Time = jet.Time
var Date = jet.Date
var DateTime = jet.Timestamp
var Timestamp = jet.Timestamp

27
mysql/statements.go Normal file
View file

@ -0,0 +1,27 @@
package mysql
import "github.com/go-jet/jet/internal/jet"
// ----------------- FUNCTIONS ----------------------//
var SELECT = jet.SELECT
type SelectLock jet.SelectLock
var (
UPDATE = jet.NewSelectLock("UPDATE")
SHARE = jet.NewSelectLock("SHARE")
)
var UNION = jet.UNION
var UNION_ALL = jet.UNION_ALL
var INTERSECT = jet.INTERSECT
var INTERSECT_ALL = jet.INTERSECT_ALL
var EXCEPT = jet.EXCEPT
var EXCEPT_ALL = jet.EXCEPT_ALL
//-----------------literals----------------------//
var STAR = jet.STAR
var NULL = jet.NULL
var DEFAULT = jet.DEFAULT

86
mysql/types.go
View file

@ -1,86 +0,0 @@
package mysql
import "github.com/go-jet/jet/internal/jet"
type ColumnBool jet.ColumnBool
var BoolColumn = jet.BoolColumn
var Bool = jet.Bool
type ColumnString jet.ColumnString
var StringColumn = jet.StringColumn
var String = jet.String
type ColumnInteger jet.ColumnInteger
var IntegerColumn = jet.IntegerColumn
var Int = jet.Int
type ColumnFloat jet.ColumnFloat
var FloatColumn = jet.FloatColumn
var Float = jet.Float
type ColumnDate jet.ColumnDate
var DateColumn = jet.DateColumn
var Date = jet.Date
type ColumnDateTime jet.ColumnTimestamp
var DateTimeColumn = jet.TimestampColumn
var DateTime = jet.Timestamp
type ColumnTimestamp jet.ColumnTimestamp
var TimestampColumn = jet.TimestampColumn
var Timestamp = jet.Timestamp
// ----------------- FUNCTIONS ----------------------//
var ABSf = jet.ABSf
var ABSi = jet.ABSi
var POWER = jet.POWER
var SQRT = jet.SQRT
func CBRT(number jet.NumericExpression) jet.FloatExpression {
return POWER(number, Float(1.0).DIV(Float(3.0)))
}
var CEIL = jet.CEIL
var FLOOR = jet.FLOOR
var ROUND = jet.ROUND
var SIGN = jet.SIGN
var TRUNC = TRUNCATE
var TRUNCATE = func(floatExpression jet.FloatExpression, precision jet.IntegerExpression) jet.FloatExpression {
return jet.NewFloatFunc("TRUNCATE", floatExpression, precision)
}
var MINUSi = jet.MINUSi
var MINUSf = jet.MINUSf
var BIT_NOT = jet.BIT_NOT
var SUMf = jet.SUMf
var AVG = jet.AVG
var MAXf = jet.MAXf
var MINf = jet.MINf
var COUNT = jet.COUNT
var SELECT = jet.SELECT
type SelectLock jet.SelectLock
var (
UPDATE = jet.NewSelectLock("UPDATE")
SHARE = jet.NewSelectLock("SHARE")
)
var UNION = jet.UNION
//-----------------literals----------------------//
var STAR = jet.STAR
var NULL = jet.NULL
var DEFAULT = jet.DEFAULT

0
mysql/testutils.go → mysql/utils_test.go
View file