init - add project files

vendor/github.com/go-jet/jet/v2/sqlite/cast.go

@@ -0,0 +1,47 @@
+package sqlite
+
+import (
+	"github.com/go-jet/jet/v2/internal/jet"
+)
+
+type cast struct {
+	jet.Cast
+}
+
+// CAST function converts a expr (of any type) into latter specified datatype.
+func CAST(expr Expression) *cast {
+	ret := &cast{}
+	ret.Cast = jet.NewCastImpl(expr)
+
+	return ret
+}
+
+// AS casts expressions to castType
+func (c *cast) AS(castType string) Expression {
+	return c.Cast.AS(castType)
+}
+
+// AS_TEXT cast expression to TEXT type
+func (c *cast) AS_TEXT() StringExpression {
+	return StringExp(c.AS("TEXT"))
+}
+
+// AS_NUMERIC cast expression to NUMERIC type
+func (c *cast) AS_NUMERIC() FloatExpression {
+	return FloatExp(c.AS("NUMERIC"))
+}
+
+// AS_INTEGER cast expression to INTEGER type
+func (c *cast) AS_INTEGER() IntegerExpression {
+	return IntExp(c.AS("INTEGER"))
+}
+
+// AS_REAL cast expression to REAL type
+func (c *cast) AS_REAL() FloatExpression {
+	return FloatExp(c.AS("REAL"))
+}
+
+// AS_BLOB cast expression to BLOB type
+func (c *cast) AS_BLOB() StringExpression {
+	return StringExp(c.AS("BLOB"))
+}

vendor/github.com/go-jet/jet/v2/sqlite/columns.go

@@ -0,0 +1,58 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// Column is common column interface for all types of columns.
+type Column = jet.ColumnExpression
+
+// ColumnList function returns list of columns that be used as projection or column list for UPDATE and INSERT statement.
+type ColumnList = jet.ColumnList
+
+// ColumnBool is interface for SQL boolean columns.
+type ColumnBool = jet.ColumnBool
+
+// BoolColumn creates named bool column.
+var BoolColumn = jet.BoolColumn
+
+// ColumnString is interface for SQL text, character, character varying
+// bytea, uuid columns and enums types.
+type ColumnString = jet.ColumnString
+
+// StringColumn creates named string column.
+var StringColumn = jet.StringColumn
+
+// ColumnInteger is interface for SQL smallint, integer, bigint columns.
+type ColumnInteger = jet.ColumnInteger
+
+// IntegerColumn creates named integer column.
+var IntegerColumn = jet.IntegerColumn
+
+// ColumnFloat is interface for SQL real, numeric, decimal or double precision column.
+type ColumnFloat = jet.ColumnFloat
+
+// FloatColumn creates named float column.
+var FloatColumn = jet.FloatColumn
+
+// ColumnTime is interface for SQL time column.
+type ColumnTime = jet.ColumnTime
+
+// TimeColumn creates named time column
+var TimeColumn = jet.TimeColumn
+
+// ColumnDate is interface of SQL date columns.
+type ColumnDate = jet.ColumnDate
+
+// DateColumn creates named date column.
+var DateColumn = jet.DateColumn
+
+// ColumnDateTime is interface of SQL timestamp columns.
+type ColumnDateTime = jet.ColumnTimestamp
+
+// DateTimeColumn creates named timestamp column
+var DateTimeColumn = jet.TimestampColumn
+
+// ColumnTimestamp is interface of SQL timestamp columns.
+type ColumnTimestamp = jet.ColumnTimestamp
+
+// TimestampColumn creates named timestamp column
+var TimestampColumn = jet.TimestampColumn

vendor/github.com/go-jet/jet/v2/sqlite/delete_statement.go

@@ -0,0 +1,60 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// DeleteStatement is interface for MySQL DELETE statement
+type DeleteStatement interface {
+	Statement
+
+	WHERE(expression BoolExpression) DeleteStatement
+	ORDER_BY(orderByClauses ...OrderByClause) DeleteStatement
+	LIMIT(limit int64) DeleteStatement
+	RETURNING(projections ...Projection) DeleteStatement
+}
+
+type deleteStatementImpl struct {
+	jet.SerializerStatement
+
+	Delete    jet.ClauseDelete
+	Where     jet.ClauseWhere
+	OrderBy   jet.ClauseOrderBy
+	Limit     jet.ClauseLimit
+	Returning jet.ClauseReturning
+}
+
+func newDeleteStatement(table Table) DeleteStatement {
+	newDelete := &deleteStatementImpl{}
+	newDelete.SerializerStatement = jet.NewStatementImpl(Dialect, jet.DeleteStatementType, newDelete,
+		&newDelete.Delete,
+		&newDelete.Where,
+		&newDelete.OrderBy,
+		&newDelete.Limit,
+		&newDelete.Returning,
+	)
+
+	newDelete.Delete.Table = table
+	newDelete.Where.Mandatory = true
+	newDelete.Limit.Count = -1
+
+	return newDelete
+}
+
+func (d *deleteStatementImpl) WHERE(expression BoolExpression) DeleteStatement {
+	d.Where.Condition = expression
+	return d
+}
+
+func (d *deleteStatementImpl) ORDER_BY(orderByClauses ...OrderByClause) DeleteStatement {
+	d.OrderBy.List = orderByClauses
+	return d
+}
+
+func (d *deleteStatementImpl) LIMIT(limit int64) DeleteStatement {
+	d.Limit.Count = limit
+	return d
+}
+
+func (d *deleteStatementImpl) RETURNING(projections ...jet.Projection) DeleteStatement {
+	d.Returning.ProjectionList = projections
+	return d
+}

vendor/github.com/go-jet/jet/v2/sqlite/dialect.go

@@ -0,0 +1,229 @@
+package sqlite
+
+import (
+	"fmt"
+	"github.com/go-jet/jet/v2/internal/jet"
+)
+
+// Dialect is implementation of SQL Builder for SQLite databases.
+var Dialect = newDialect()
+
+func newDialect() jet.Dialect {
+	operatorSerializeOverrides := map[string]jet.SerializeOverride{}
+	operatorSerializeOverrides["IS DISTINCT FROM"] = sqlite_IS_DISTINCT_FROM
+	operatorSerializeOverrides["IS NOT DISTINCT FROM"] = sqlite_IS_NOT_DISTINCT_FROM
+	operatorSerializeOverrides["#"] = sqliteBitXOR
+
+	mySQLDialectParams := jet.DialectParams{
+		Name:                       "SQLite",
+		PackageName:                "sqlite",
+		OperatorSerializeOverrides: operatorSerializeOverrides,
+		AliasQuoteChar:             '"',
+		IdentifierQuoteChar:        '`',
+		ArgumentPlaceholder: func(int) string {
+			return "?"
+		},
+		ReservedWords: reservedWords2,
+		ValuesDefaultColumnName: func(index int) string {
+			return fmt.Sprintf("column%d", index+1)
+		},
+	}
+
+	return jet.NewDialect(mySQLDialectParams)
+}
+
+func sqliteBitXOR(expressions ...jet.Serializer) jet.SerializerFunc {
+	return func(statement jet.StatementType, out *jet.SQLBuilder, options ...jet.SerializeOption) {
+		if len(expressions) < 2 {
+			panic("jet: invalid number of expressions for operator XOR")
+		}
+
+		// (~(a&b))&(a|b)
+		a := expressions[0]
+		b := expressions[1]
+
+		out.WriteString("(~(")
+		jet.Serialize(a, statement, out, options...)
+		out.WriteByte('&')
+		jet.Serialize(b, statement, out, options...)
+		out.WriteString("))&(")
+		jet.Serialize(a, statement, out, options...)
+		out.WriteByte('|')
+		jet.Serialize(b, statement, out, options...)
+		out.WriteByte(')')
+	}
+}
+
+func sqlite_IS_NOT_DISTINCT_FROM(expressions ...jet.Serializer) jet.SerializerFunc {
+	return func(statement jet.StatementType, out *jet.SQLBuilder, options ...jet.SerializeOption) {
+		if len(expressions) < 2 {
+			panic("jet: invalid number of expressions for operator")
+		}
+
+		jet.Serialize(expressions[0], statement, out)
+		out.WriteString("IS")
+		jet.Serialize(expressions[1], statement, out)
+	}
+}
+
+func sqlite_IS_DISTINCT_FROM(expressions ...jet.Serializer) jet.SerializerFunc {
+	return func(statement jet.StatementType, out *jet.SQLBuilder, options ...jet.SerializeOption) {
+		if len(expressions) < 2 {
+			panic("jet: invalid number of expressions for operator")
+		}
+
+		jet.Serialize(expressions[0], statement, out)
+		out.WriteString("IS NOT")
+		jet.Serialize(expressions[1], statement, out)
+	}
+}
+
+var reservedWords2 = []string{
+	"ABORT",
+	"ACTION",
+	"ADD",
+	"AFTER",
+	"ALL",
+	"ALTER",
+	"ALWAYS",
+	"ANALYZE",
+	"AND",
+	"AS",
+	"ASC",
+	"ATTACH",
+	"AUTOINCREMENT",
+	"BEFORE",
+	"BEGIN",
+	"BETWEEN",
+	"BY",
+	"CASCADE",
+	"CASE",
+	"CAST",
+	"CHECK",
+	"COLLATE",
+	"COLUMN",
+	"COMMIT",
+	"CONFLICT",
+	"CONSTRAINT",
+	"CREATE",
+	"CROSS",
+	"CURRENT",
+	"CURRENT_DATE",
+	"CURRENT_TIME",
+	"CURRENT_TIMESTAMP",
+	"DATABASE",
+	"DEFAULT",
+	"DEFERRABLE",
+	"DEFERRED",
+	"DELETE",
+	"DESC",
+	"DETACH",
+	"DISTINCT",
+	"DO",
+	"DROP",
+	"EACH",
+	"ELSE",
+	"END",
+	"ESCAPE",
+	"EXCEPT",
+	"EXCLUDE",
+	"EXCLUSIVE",
+	"EXISTS",
+	"EXPLAIN",
+	"FAIL",
+	"FILTER",
+	"FIRST",
+	"FOLLOWING",
+	"FOR",
+	"FOREIGN",
+	"FROM",
+	"FULL",
+	"GENERATED",
+	"GLOB",
+	"GROUP",
+	"GROUPS",
+	"HAVING",
+	"IF",
+	"IGNORE",
+	"IMMEDIATE",
+	"IN",
+	"INDEX",
+	"INDEXED",
+	"INITIALLY",
+	"INNER",
+	"INSERT",
+	"INSTEAD",
+	"INTERSECT",
+	"INTO",
+	"IS",
+	"ISNULL",
+	"JOIN",
+	"KEY",
+	"LAST",
+	"LEFT",
+	"LIKE",
+	"LIMIT",
+	"MATCH",
+	"MATERIALIZED",
+	"NATURAL",
+	"NO",
+	"NOT",
+	"NOTHING",
+	"NOTNULL",
+	"NULL",
+	"NULLS",
+	"OF",
+	"OFFSET",
+	"ON",
+	"OR",
+	"ORDER",
+	"OTHERS",
+	"OUTER",
+	"OVER",
+	"PARTITION",
+	"PLAN",
+	"PRAGMA",
+	"PRECEDING",
+	"PRIMARY",
+	"QUERY",
+	"RAISE",
+	"RANGE",
+	"RECURSIVE",
+	"REFERENCES",
+	"REGEXP",
+	"REINDEX",
+	"RELEASE",
+	"RENAME",
+	"REPLACE",
+	"RESTRICT",
+	"RETURNING",
+	"RIGHT",
+	"ROLLBACK",
+	"ROW",
+	"ROWS",
+	"SAVEPOINT",
+	"SELECT",
+	"SET",
+	"TABLE",
+	"TEMP",
+	"TEMPORARY",
+	"THEN",
+	"TIES",
+	"TO",
+	"TRANSACTION",
+	"TRIGGER",
+	"UNBOUNDED",
+	"UNION",
+	"UNIQUE",
+	"UPDATE",
+	"USING",
+	"VACUUM",
+	"VALUES",
+	"VIEW",
+	"VIRTUAL",
+	"WHEN",
+	"WHERE",
+	"WINDOW",
+	"WITH",
+	"WITHOUT",
+}

vendor/github.com/go-jet/jet/v2/sqlite/expressions.go

@@ -0,0 +1,115 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// Expression is common interface for all expressions.
+// Can be Bool, Int, Float, String, Date, Time or Timestamp expressions.
+type Expression = jet.Expression
+
+// BoolExpression interface
+type BoolExpression = jet.BoolExpression
+
+// StringExpression interface
+type StringExpression = jet.StringExpression
+
+// NumericExpression is shared interface for integer or real expression
+type NumericExpression = jet.NumericExpression
+
+// IntegerExpression interface
+type IntegerExpression = jet.IntegerExpression
+
+// FloatExpression interface
+type FloatExpression = jet.FloatExpression
+
+// TimeExpression interface
+type TimeExpression = jet.TimeExpression
+
+// DateExpression interface
+type DateExpression = jet.DateExpression
+
+// DateTimeExpression interface
+type DateTimeExpression = jet.TimestampExpression
+
+// TimestampExpression interface
+type TimestampExpression = jet.TimestampExpression
+
+// RowExpression interface
+type RowExpression = jet.RowExpression
+
+// 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 BoolExp = jet.BoolExp
+
+// 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 StringExp = jet.StringExp
+
+// 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 IntExp = jet.IntExp
+
+// 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 FloatExp = jet.FloatExp
+
+// 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 TimeExp = jet.TimeExp
+
+// 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 DateExp = jet.DateExp
+
+// 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 DateTimeExp = 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 TimestampExp = jet.TimestampExp
+
+// RowExp serves as a wrapper for an arbitrary expression, treating it as a row expression.
+// This enables the Go compiler to interpret any expression as a row expression
+// Note: This does not modify the generated SQL builder output by adding a SQL CAST operation.
+var RowExp = jet.RowExp
+
+// CustomExpression is used to define custom expressions.
+var CustomExpression = jet.CustomExpression
+
+// Token is used to define custom token in a custom expression.
+type Token = jet.Token
+
+// RawArgs is type used to pass optional arguments to Raw method
+type RawArgs = map[string]interface{}
+
+// Raw can be used for any unsupported functions, operators or expressions.
+// For example: Raw("current_database()")
+// Raw helper methods for each of the sqlite types
+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
+)
+
+// Func can be used to call custom or unsupported database functions.
+var Func = jet.Func
+
+// NewEnumValue creates new named enum value
+var NewEnumValue = jet.NewEnumValue
+
+// BinaryOperator can be used to use custom or unsupported operators that take two operands.
+var BinaryOperator = jet.BinaryOperator

vendor/github.com/go-jet/jet/v2/sqlite/functions.go

@@ -0,0 +1,357 @@
+package sqlite
+
+import (
+	"fmt"
+	"github.com/go-jet/jet/v2/internal/jet"
+	"time"
+)
+
+// 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 (
+	// AND function adds AND operator between expressions.
+	AND = jet.AND
+	// OR function adds OR operator between expressions.
+	OR = jet.OR
+)
+
+// ROW function is used to create a tuple value that consists of a set of expressions or column values.
+func ROW(expressions ...Expression) RowExpression {
+	return jet.WRAP(Dialect, expressions...)
+}
+
+// ------------------ Mathematical functions ---------------//
+
+// ABSf calculates absolute value from float expression
+var ABSf = jet.ABSf
+
+// ABSi calculates absolute value from int expression
+var ABSi = jet.ABSi
+
+// POW calculates power of base with exponent
+var POW = jet.POW
+
+// POWER calculates power of base with exponent
+var POWER = jet.POWER
+
+// SQRT calculates square root of numeric expression
+var SQRT = jet.SQRT
+
+// CBRT calculates cube root of numeric expression
+func CBRT(number jet.NumericExpression) jet.FloatExpression {
+	return POWER(number, Float(1.0).DIV(Float(3.0)))
+}
+
+// CEIL calculates ceil of float expression
+var CEIL = jet.CEIL
+
+// FLOOR calculates floor of float expression
+var FLOOR = jet.FLOOR
+
+// ROUND calculates round of a float expressions with optional precision
+var ROUND = jet.ROUND
+
+// SIGN returns sign of float expression
+var SIGN = jet.SIGN
+
+// TRUNC calculates trunc of float expression with precision
+var TRUNC = TRUNCATE
+
+// TRUNCATE calculates trunc of float expression with precision
+var TRUNCATE = func(floatExpression jet.FloatExpression, precision jet.IntegerExpression) jet.FloatExpression {
+	return jet.NewFloatFunc("TRUNCATE", floatExpression, precision)
+}
+
+// LN calculates natural algorithm of float expression
+var LN = jet.LN
+
+// LOG calculates logarithm of float expression
+var LOG = jet.LOG
+
+// ----------------- Aggregate functions  -------------------//
+
+// AVG is aggregate function used to calculate avg value from numeric expression
+var AVG = jet.AVG
+
+// BIT_AND is aggregate function used to calculates the bitwise AND of all non-null input values, or null if none.
+//var BIT_AND = jet.BIT_AND
+
+// BIT_OR is aggregate function used to calculates the bitwise OR of all non-null input values, or null if none.
+//var BIT_OR = jet.BIT_OR
+
+// COUNT is aggregate function. Returns number of input rows for which the value of expression is not null.
+var COUNT = jet.COUNT
+
+// MAX is aggregate function. Returns maximum value of expression across all input values
+var MAX = jet.MAX
+
+// MAXi is aggregate function. Returns maximum value of int expression across all input values
+var MAXi = jet.MAXi
+
+// MAXf is aggregate function. Returns maximum value of float expression across all input values
+var MAXf = jet.MAXf
+
+// MIN is aggregate function. Returns minimum value of int expression across all input values
+var MIN = jet.MIN
+
+// MINi is aggregate function. Returns minimum value of int expression across all input values
+var MINi = jet.MINi
+
+// MINf is aggregate function. Returns minimum value of float expression across all input values
+var MINf = jet.MINf
+
+// SUM is aggregate function. Returns sum of all expressions
+var SUM = jet.SUM
+
+// SUMi is aggregate function. Returns sum of integer expression.
+var SUMi = jet.SUMi
+
+// SUMf is aggregate function. Returns sum of float expression.
+var SUMf = jet.SUMf
+
+// -------------------- Window functions -----------------------//
+
+// ROW_NUMBER returns number of the current row within its partition, counting from 1
+var ROW_NUMBER = jet.ROW_NUMBER
+
+// RANK of the current row with gaps; same as row_number of its first peer
+var RANK = jet.RANK
+
+// DENSE_RANK returns rank of the current row without gaps; this function counts peer groups
+var DENSE_RANK = jet.DENSE_RANK
+
+// PERCENT_RANK calculates relative rank of the current row: (rank - 1) / (total partition rows - 1)
+var PERCENT_RANK = jet.PERCENT_RANK
+
+// CUME_DIST calculates cumulative distribution: (number of partition rows preceding or peer with current row) / total partition rows
+var CUME_DIST = jet.CUME_DIST
+
+// NTILE returns integer ranging from 1 to the argument value, dividing the partition as equally as possible
+var NTILE = jet.NTILE
+
+// 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 LAG = jet.LAG
+
+// 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 LEAD = jet.LEAD
+
+// FIRST_VALUE returns value evaluated at the row that is the first row of the window frame
+var FIRST_VALUE = jet.FIRST_VALUE
+
+// LAST_VALUE returns value evaluated at the row that is the last row of the window frame
+var LAST_VALUE = jet.LAST_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 NTH_VALUE = jet.NTH_VALUE
+
+//--------------------- String functions ------------------//
+
+// BIT_LENGTH returns number of bits in string expression
+//var BIT_LENGTH = jet.BIT_LENGTH
+//
+//// CHAR_LENGTH returns number of characters in string expression
+//var CHAR_LENGTH = jet.CHAR_LENGTH
+//
+//// OCTET_LENGTH returns number of bytes in string expression
+//var OCTET_LENGTH = jet.OCTET_LENGTH
+
+// LOWER returns string expression in lower case
+var LOWER = jet.LOWER
+
+// UPPER returns string expression in upper case
+var UPPER = jet.UPPER
+
+// LTRIM removes the longest string containing only characters
+// from characters (a space by default) from the start of string
+var LTRIM = jet.LTRIM
+
+// RTRIM removes the longest string containing only characters
+// from characters (a space by default) from the end of string
+var RTRIM = jet.RTRIM
+
+// CONCAT adds two or more expressions together
+//var CONCAT = jet.CONCAT
+
+// CONCAT_WS adds two or more expressions together with a separator.
+//var CONCAT_WS = jet.CONCAT_WS
+
+// 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 FORMAT = jet.FORMAT
+
+// LEFTSTR returns first n characters in the string.
+// When n is negative, return all but last |n| characters.
+//func LEFTSTR(str StringExpression, n IntegerExpression) StringExpression {
+//	return jet.NewStringFunc("LEFTSTR", str, n)
+//}
+//
+//// RIGHT returns last n characters in the string.
+//// When n is negative, return all but first |n| characters.
+//func RIGHTSTR(str StringExpression, n IntegerExpression) StringExpression {
+//	return jet.NewStringFunc("RIGHTSTR", str, n)
+//}
+
+// LENGTH returns number of characters in string with a given encoding
+func LENGTH(str jet.StringExpression) jet.StringExpression {
+	return jet.LENGTH(str)
+}
+
+// LPAD fills up the string to length length by prepending the characters
+// fill (a space by default). If the string is already longer than length
+// then it is truncated (on the right).
+//func LPAD(str jet.StringExpression, length jet.IntegerExpression, text jet.StringExpression) jet.StringExpression {
+//	return jet.LPAD(str, length, text)
+//}
+
+// RPAD fills up the string to length length by appending the characters
+// fill (a space by default). If the string is already longer than length then it is truncated.
+//func RPAD(str jet.StringExpression, length jet.IntegerExpression, text jet.StringExpression) jet.StringExpression {
+//	return jet.RPAD(str, length, text)
+//}
+
+// MD5 calculates the MD5 hash of string, returning the result in hexadecimal
+//var MD5 = jet.MD5
+
+// REPEAT repeats string the specified number of times
+//var REPEAT = jet.REPEAT
+
+// REPLACE replaces all occurrences in string of substring from with substring to
+var REPLACE = jet.REPLACE
+
+// REVERSE returns reversed string.
+var REVERSE = jet.REVERSE
+
+// SUBSTR extracts substring
+var SUBSTR = jet.SUBSTR
+
+// REGEXP_LIKE Returns 1 if the string expr matches the regular expression specified by the pattern pat, 0 otherwise.
+var REGEXP_LIKE = jet.REGEXP_LIKE
+
+//----------------- Date/Time Functions and Operators ------------//
+
+// CURRENT_DATE returns current date
+var CURRENT_DATE = jet.CURRENT_DATE
+
+// CURRENT_TIME returns current time with time zone
+func CURRENT_TIME() TimeExpression {
+	return TimeExp(jet.CURRENT_TIME())
+}
+
+// CURRENT_TIMESTAMP returns current timestamp with time zone
+func CURRENT_TIMESTAMP() TimestampExpression {
+	return TimestampExp(jet.CURRENT_TIMESTAMP())
+}
+
+//// NOW returns current datetime
+//func NOW() DateTimeExpression {
+//	//if len(fsp) > 0 {
+//	//	return jet.NewTimestampFunc("NOW", jet.FixedLiteral(int64(fsp[0])))
+//	//}
+//	//return jet.NewTimestampFunc("NOW")
+//	return DATETIME(jet.FixedLiteral("now"))
+//}
+
+// time-value modifiers
+var (
+	YEARS   = modifier("YEARS")
+	MONTHS  = modifier("MONTHS")
+	DAYS    = modifier("DAYS")
+	HOURS   = modifier("HOURS")
+	MINUTES = modifier("MINUTES")
+	SECONDS = modifier("SECONDS")
+
+	START_OF_YEAR  = String("start of year")
+	START_OF_MONTH = String("start of month")
+	UNIXEPOCH      = String("unixepoch")
+	LOCALTIME      = String("localtime")
+	UTC            = String("UTC")
+
+	WEEKDAY = func(value int) Expression {
+		return String(fmt.Sprintf("WEEKDAY %d", value))
+	}
+)
+
+func modifier(modifierName string) func(value float64) Expression {
+	return func(value float64) Expression {
+		return String(fmt.Sprintf("%g %s", value, modifierName))
+	}
+}
+
+// DATE function creates new date from time-value and zero or more time modifiers
+func DATE(timeValue interface{}, modifiers ...Expression) DateExpression {
+	exprList := getFuncExprList(timeValue, modifiers...)
+
+	return jet.NewDateFunc("DATE", exprList...)
+}
+
+// TIME function creates new time from time-value and zero or more time modifiers
+func TIME(timeValue interface{}, modifiers ...Expression) TimeExpression {
+	exprList := getFuncExprList(timeValue, modifiers...)
+
+	return jet.NewTimeFunc("TIME", exprList...)
+}
+
+// DATETIME function creates new DateTime from time-value and zero or more time modifiers
+func DATETIME(timeValue interface{}, modifiers ...Expression) DateTimeExpression {
+	exprList := getFuncExprList(timeValue, modifiers...)
+
+	return jet.NewTimestampFunc("DATETIME", exprList...)
+}
+
+// JULIANDAY returns the number of days since noon in Greenwich on November 24, 4714 B.C
+func JULIANDAY(timeValue interface{}, modifiers ...Expression) FloatExpression {
+	exprList := getFuncExprList(timeValue, modifiers...)
+	return jet.NewFloatFunc("JULIANDAY", exprList...)
+}
+
+// STRFTIME routine returns the date formatted according to the format string specified as the first argument.
+func STRFTIME(format StringExpression, timeValue interface{}, modifiers ...Expression) StringExpression {
+	exprList := append([]Expression{format}, getFuncExprList(timeValue, modifiers...)...)
+	return jet.NewStringFunc("strftime", exprList...)
+}
+
+func getFuncExprList(timeValue interface{}, modifiers ...Expression) []Expression {
+	return append([]Expression{getTimeValueExpression(timeValue)}, modifiers...)
+}
+
+func getTimeValueExpression(timeValue interface{}) Expression {
+	switch t := timeValue.(type) {
+	case string:
+		return String(t)
+	case Expression:
+		return t
+	case time.Time, int64:
+		return jet.Literal(t)
+	}
+
+	panic(fmt.Sprintf("jet: Invalid time value %T(%q)", timeValue, timeValue))
+}
+
+// TIMESTAMP return a datetime value based on the arguments:
+func TIMESTAMP(str StringExpression) TimestampExpression {
+	return jet.NewTimestampFunc("TIMESTAMP", str)
+}
+
+// UNIX_TIMESTAMP returns unix timestamp
+func UNIX_TIMESTAMP(str StringExpression) TimestampExpression {
+	return jet.NewTimestampFunc("UNIX_TIMESTAMP", str)
+}
+
+// --------------- Conditional Expressions Functions -------------//
+
+// COALESCE function returns the first of its arguments that is not null.
+var COALESCE = jet.COALESCE
+
+// NULLIF function returns a null value if value1 equals value2; otherwise it returns value1.
+var NULLIF = jet.NULLIF
+
+// EXISTS checks for existence of the rows in subQuery
+var EXISTS = jet.EXISTS
+
+// CASE create CASE operator with optional list of expressions
+var CASE = jet.CASE

vendor/github.com/go-jet/jet/v2/sqlite/insert_statement.go

@@ -0,0 +1,87 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// InsertStatement is interface for SQL INSERT statements
+type InsertStatement interface {
+	Statement
+
+	VALUES(value interface{}, values ...interface{}) InsertStatement
+	MODEL(data interface{}) InsertStatement
+	MODELS(data interface{}) InsertStatement
+	QUERY(selectStatement SelectStatement) InsertStatement
+	DEFAULT_VALUES() InsertStatement
+
+	ON_CONFLICT(indexExpressions ...jet.ColumnExpression) onConflict
+	RETURNING(projections ...Projection) InsertStatement
+}
+
+func newInsertStatement(table Table, columns []jet.Column) InsertStatement {
+	newInsert := &insertStatementImpl{
+		DefaultValues: jet.ClauseOptional{Name: "DEFAULT VALUES", InNewLine: true},
+	}
+
+	newInsert.SerializerStatement = jet.NewStatementImpl(Dialect, jet.InsertStatementType, newInsert,
+		&newInsert.Insert,
+		&newInsert.ValuesQuery,
+		&newInsert.DefaultValues,
+		&newInsert.OnConflict,
+		&newInsert.Returning,
+	)
+
+	newInsert.Insert.Table = table
+	newInsert.Insert.Columns = columns
+	newInsert.ValuesQuery.SkipSelectWrap = true
+
+	return newInsert
+}
+
+type insertStatementImpl struct {
+	jet.SerializerStatement
+
+	Insert        jet.ClauseInsert
+	ValuesQuery   jet.ClauseValuesQuery
+	DefaultValues jet.ClauseOptional
+	OnConflict    onConflictClause
+	Returning     jet.ClauseReturning
+}
+
+func (is *insertStatementImpl) VALUES(value interface{}, values ...interface{}) InsertStatement {
+	is.ValuesQuery.Rows = append(is.ValuesQuery.Rows, jet.UnwindRowFromValues(value, values))
+	return is
+}
+
+// MODEL will insert row of values, where value for each column is extracted from filed of structure data.
+// If data is not struct or there is no field for every column selected, this method will panic.
+func (is *insertStatementImpl) MODEL(data interface{}) InsertStatement {
+	is.ValuesQuery.Rows = append(is.ValuesQuery.Rows, jet.UnwindRowFromModel(is.Insert.GetColumns(), data))
+	return is
+}
+
+func (is *insertStatementImpl) MODELS(data interface{}) InsertStatement {
+	is.ValuesQuery.Rows = append(is.ValuesQuery.Rows, jet.UnwindRowsFromModels(is.Insert.GetColumns(), data)...)
+	return is
+}
+
+func (is *insertStatementImpl) QUERY(selectStatement SelectStatement) InsertStatement {
+	is.ValuesQuery.Query = selectStatement
+	return is
+}
+
+func (is *insertStatementImpl) DEFAULT_VALUES() InsertStatement {
+	is.DefaultValues.Show = true
+	return is
+}
+
+func (is *insertStatementImpl) RETURNING(projections ...jet.Projection) InsertStatement {
+	is.Returning.ProjectionList = projections
+	return is
+}
+
+func (is *insertStatementImpl) ON_CONFLICT(indexExpressions ...jet.ColumnExpression) onConflict {
+	is.OnConflict = onConflictClause{
+		insertStatement:  is,
+		indexExpressions: indexExpressions,
+	}
+	return &is.OnConflict
+}

vendor/github.com/go-jet/jet/v2/sqlite/literal.go

@@ -0,0 +1,70 @@
+package sqlite
+
+import (
+	"github.com/go-jet/jet/v2/internal/jet"
+	"time"
+)
+
+// Keywords
+var (
+	STAR = jet.STAR
+	NULL = jet.NULL
+)
+
+// Bool creates new bool literal expression
+var Bool = jet.Bool
+
+// Int is constructor for 64 bit signed integer expressions literals.
+var Int = jet.Int
+
+// Int8 is constructor for 8 bit signed integer expressions literals.
+var Int8 = jet.Int8
+
+// Int16 is constructor for 16 bit signed integer expressions literals.
+var Int16 = jet.Int16
+
+// Int32 is constructor for 32 bit signed integer expressions literals.
+var Int32 = jet.Int32
+
+// Int64 is constructor for 64 bit signed integer expressions literals.
+var Int64 = jet.Int
+
+// Uint8 is constructor for 8 bit unsigned integer expressions literals.
+var Uint8 = jet.Uint8
+
+// Uint16 is constructor for 16 bit unsigned integer expressions literals.
+var Uint16 = jet.Uint16
+
+// Uint32 is constructor for 32 bit unsigned integer expressions literals.
+var Uint32 = jet.Uint32
+
+// Uint64 is constructor for 64 bit unsigned integer expressions literals.
+var Uint64 = jet.Uint64
+
+// Float creates new float literal expression from float64 value
+var Float = jet.Float
+
+// Decimal creates new float literal expression from string value
+var Decimal = jet.Decimal
+
+// String creates new string literal expression
+var String = jet.String
+
+// UUID is a helper function to create string literal expression from uuid object
+// value can be any uuid type with a String method
+var UUID = jet.UUID
+
+// Date creates new date literal expression
+func Date(year int, month time.Month, day int) DateExpression {
+	return DATE(jet.Date(year, month, day))
+}
+
+// Time creates new time literal expression
+func Time(hour, minute, second int, nanoseconds ...time.Duration) TimeExpression {
+	return TIME(jet.Time(hour, minute, second, nanoseconds...))
+}
+
+// DateTime creates new datetime(timestamp) literal expression
+func DateTime(year int, month time.Month, day, hour, minute, second int, nanoseconds ...time.Duration) DateTimeExpression {
+	return DATETIME(jet.Timestamp(year, month, day, hour, minute, second, nanoseconds...))
+}

vendor/github.com/go-jet/jet/v2/sqlite/on_conflict_clause.go

@@ -0,0 +1,85 @@
+package sqlite
+
+import (
+	"github.com/go-jet/jet/v2/internal/jet"
+	"github.com/go-jet/jet/v2/internal/utils/is"
+)
+
+type onConflict interface {
+	WHERE(indexPredicate BoolExpression) conflictTarget
+	conflictTarget
+}
+
+type conflictTarget interface {
+	DO_NOTHING() InsertStatement
+	DO_UPDATE(action conflictAction) InsertStatement
+}
+
+type onConflictClause struct {
+	insertStatement  InsertStatement
+	indexExpressions []jet.ColumnExpression
+	whereClause      jet.ClauseWhere
+	do               jet.Serializer
+}
+
+func (o *onConflictClause) WHERE(indexPredicate BoolExpression) conflictTarget {
+	o.whereClause.Condition = indexPredicate
+	return o
+}
+
+func (o *onConflictClause) DO_NOTHING() InsertStatement {
+	o.do = jet.Keyword("DO NOTHING")
+	return o.insertStatement
+}
+
+func (o *onConflictClause) DO_UPDATE(action conflictAction) InsertStatement {
+	o.do = action
+	return o.insertStatement
+}
+
+func (o *onConflictClause) Serialize(statementType jet.StatementType, out *jet.SQLBuilder, options ...jet.SerializeOption) {
+	if is.Nil(o.do) {
+		return
+	}
+
+	out.NewLine()
+	out.WriteString("ON CONFLICT")
+	if len(o.indexExpressions) > 0 {
+		out.WriteString("(")
+		jet.SerializeColumnExpressions(o.indexExpressions, statementType, out, jet.ShortName)
+		out.WriteString(")")
+	}
+
+	o.whereClause.Serialize(statementType, out, jet.SkipNewLine, jet.ShortName)
+
+	out.IncreaseIdent(7)
+	jet.Serialize(o.do, statementType, out)
+	out.DecreaseIdent(7)
+}
+
+type conflictAction interface {
+	jet.Serializer
+	WHERE(condition BoolExpression) conflictAction
+}
+
+// SET creates conflict action for ON_CONFLICT clause
+func SET(assigments ...ColumnAssigment) conflictAction {
+	conflictAction := updateConflictActionImpl{}
+	conflictAction.doUpdate = jet.KeywordClause{Keyword: "DO UPDATE"}
+	conflictAction.Serializer = jet.NewSerializerClauseImpl(&conflictAction.doUpdate, &conflictAction.set, &conflictAction.where)
+	conflictAction.set = assigments
+	return &conflictAction
+}
+
+type updateConflictActionImpl struct {
+	jet.Serializer
+
+	doUpdate jet.KeywordClause
+	set      jet.SetClauseNew
+	where    jet.ClauseWhere
+}
+
+func (u *updateConflictActionImpl) WHERE(condition BoolExpression) conflictAction {
+	u.where.Condition = condition
+	return u
+}

vendor/github.com/go-jet/jet/v2/sqlite/operators.go

@@ -0,0 +1,12 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// NOT returns negation of bool expression result
+var NOT = jet.NOT
+
+// BIT_NOT inverts every bit in integer expression result
+var BIT_NOT = jet.BIT_NOT
+
+// DISTINCT operator can be used to return distinct values of expr
+var DISTINCT = jet.DISTINCT

vendor/github.com/go-jet/jet/v2/sqlite/select_statement.go

@@ -0,0 +1,190 @@
+package sqlite
+
+import (
+	"github.com/go-jet/jet/v2/internal/jet"
+)
+
+// RowLock is interface for SELECT statement row lock types
+type RowLock = jet.RowLock
+
+// Row lock types
+var (
+	UPDATE = jet.NewRowLock("UPDATE")
+	SHARE  = jet.NewRowLock("SHARE")
+)
+
+// Window function clauses
+var (
+	PARTITION_BY = jet.PARTITION_BY
+	ORDER_BY     = jet.ORDER_BY
+	UNBOUNDED    = jet.UNBOUNDED
+	CURRENT_ROW  = jet.CURRENT_ROW
+)
+
+// PRECEDING window frame clause
+func PRECEDING(offset interface{}) jet.FrameExtent {
+	return jet.PRECEDING(toJetFrameOffset(offset))
+}
+
+// FOLLOWING window frame clause
+func FOLLOWING(offset interface{}) jet.FrameExtent {
+	return jet.FOLLOWING(toJetFrameOffset(offset))
+}
+
+// Window is used to specify window reference from WINDOW clause
+var Window = jet.WindowName
+
+// SelectStatement is interface for MySQL SELECT statement
+type SelectStatement interface {
+	Statement
+	jet.HasProjections
+	Expression
+
+	DISTINCT() SelectStatement
+	FROM(tables ...ReadableTable) SelectStatement
+	WHERE(expression BoolExpression) SelectStatement
+	GROUP_BY(groupByClauses ...GroupByClause) SelectStatement
+	HAVING(boolExpression BoolExpression) SelectStatement
+	WINDOW(name string) windowExpand
+	ORDER_BY(orderByClauses ...OrderByClause) SelectStatement
+	LIMIT(limit int64) SelectStatement
+	OFFSET(offset int64) SelectStatement
+	FOR(lock RowLock) SelectStatement
+	LOCK_IN_SHARE_MODE() SelectStatement
+
+	UNION(rhs SelectStatement) setStatement
+	UNION_ALL(rhs SelectStatement) setStatement
+
+	AsTable(alias string) SelectTable
+}
+
+// SELECT creates new SelectStatement with list of projections
+func SELECT(projection Projection, projections ...Projection) SelectStatement {
+	return newSelectStatement(nil, append([]Projection{projection}, projections...))
+}
+
+func newSelectStatement(table ReadableTable, projections []Projection) SelectStatement {
+	newSelect := &selectStatementImpl{}
+	newSelect.ExpressionStatement = jet.NewExpressionStatementImpl(Dialect, jet.SelectStatementType, newSelect, &newSelect.Select,
+		&newSelect.From, &newSelect.Where, &newSelect.GroupBy, &newSelect.Having, &newSelect.Window, &newSelect.OrderBy,
+		&newSelect.Limit, &newSelect.Offset, &newSelect.For, &newSelect.ShareLock)
+
+	newSelect.Select.ProjectionList = projections
+	if table != nil {
+		newSelect.From.Tables = []jet.Serializer{table}
+	}
+	newSelect.Limit.Count = -1
+	newSelect.ShareLock.Name = "LOCK IN SHARE MODE"
+	newSelect.ShareLock.InNewLine = true
+
+	newSelect.setOperatorsImpl.parent = newSelect
+
+	return newSelect
+}
+
+type selectStatementImpl struct {
+	jet.ExpressionStatement
+	setOperatorsImpl
+
+	Select    jet.ClauseSelect
+	From      jet.ClauseFrom
+	Where     jet.ClauseWhere
+	GroupBy   jet.ClauseGroupBy
+	Having    jet.ClauseHaving
+	Window    jet.ClauseWindow
+	OrderBy   jet.ClauseOrderBy
+	Limit     jet.ClauseLimit
+	Offset    jet.ClauseOffset
+	For       jet.ClauseFor
+	ShareLock jet.ClauseOptional
+}
+
+func (s *selectStatementImpl) DISTINCT() SelectStatement {
+	s.Select.Distinct = true
+	return s
+}
+
+func (s *selectStatementImpl) FROM(tables ...ReadableTable) SelectStatement {
+	s.From.Tables = readableTablesToSerializerList(tables)
+	return s
+}
+
+func (s *selectStatementImpl) WHERE(condition BoolExpression) SelectStatement {
+	s.Where.Condition = condition
+	return s
+}
+
+func (s *selectStatementImpl) GROUP_BY(groupByClauses ...GroupByClause) SelectStatement {
+	s.GroupBy.List = groupByClauses
+	return s
+}
+
+func (s *selectStatementImpl) HAVING(boolExpression BoolExpression) SelectStatement {
+	s.Having.Condition = boolExpression
+	return s
+}
+
+func (s *selectStatementImpl) WINDOW(name string) windowExpand {
+	s.Window.Definitions = append(s.Window.Definitions, jet.WindowDefinition{Name: name})
+	return windowExpand{selectStatement: s}
+}
+
+func (s *selectStatementImpl) ORDER_BY(orderByClauses ...OrderByClause) SelectStatement {
+	s.OrderBy.List = orderByClauses
+	return s
+}
+
+func (s *selectStatementImpl) LIMIT(limit int64) SelectStatement {
+	s.Limit.Count = limit
+	return s
+}
+
+func (s *selectStatementImpl) OFFSET(offset int64) SelectStatement {
+	s.Offset.Count = Int(offset)
+	return s
+}
+
+func (s *selectStatementImpl) FOR(lock RowLock) SelectStatement {
+	s.For.Lock = lock
+	return s
+}
+
+func (s *selectStatementImpl) LOCK_IN_SHARE_MODE() SelectStatement {
+	s.ShareLock.Show = true
+	return s
+}
+
+func (s *selectStatementImpl) AsTable(alias string) SelectTable {
+	return newSelectTable(s, alias, nil)
+}
+
+//-----------------------------------------------------
+
+type windowExpand struct {
+	selectStatement *selectStatementImpl
+}
+
+func (w windowExpand) AS(window ...jet.Window) SelectStatement {
+	if len(window) == 0 {
+		return w.selectStatement
+	}
+	windowsDefinition := w.selectStatement.Window.Definitions
+	windowsDefinition[len(windowsDefinition)-1].Window = window[0]
+	return w.selectStatement
+}
+
+func toJetFrameOffset(offset interface{}) jet.Serializer {
+	if offset == UNBOUNDED {
+		return jet.UNBOUNDED
+	}
+
+	return jet.FixedLiteral(offset)
+}
+
+func readableTablesToSerializerList(tables []ReadableTable) []jet.Serializer {
+	var ret []jet.Serializer
+	for _, table := range tables {
+		ret = append(ret, table)
+	}
+	return ret
+}

vendor/github.com/go-jet/jet/v2/sqlite/select_table.go

@@ -0,0 +1,24 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// SelectTable is interface for MySQL sub-queries
+type SelectTable interface {
+	readableTable
+	jet.SelectTable
+}
+
+type selectTableImpl struct {
+	jet.SelectTable
+	readableTableInterfaceImpl
+}
+
+func newSelectTable(selectStmt jet.SerializerHasProjections, alias string, columnAliases []jet.ColumnExpression) SelectTable {
+	subQuery := &selectTableImpl{
+		SelectTable: jet.NewSelectTable(selectStmt, alias, columnAliases),
+	}
+
+	subQuery.readableTableInterfaceImpl.parent = subQuery
+
+	return subQuery
+}

vendor/github.com/go-jet/jet/v2/sqlite/set_statement.go

@@ -0,0 +1,98 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// UNION effectively appends the result of sub-queries(select statements) into single query.
+// It eliminates duplicate rows from its result.
+func UNION(lhs, rhs jet.SerializerStatement, selects ...jet.SerializerStatement) setStatement {
+	return newSetStatementImpl(union, false, toSelectList(lhs, rhs, selects...))
+}
+
+// UNION_ALL effectively appends the result of sub-queries(select statements) into single query.
+// It does not eliminates duplicate rows from its result.
+func UNION_ALL(lhs, rhs jet.SerializerStatement, selects ...jet.SerializerStatement) setStatement {
+	return newSetStatementImpl(union, true, toSelectList(lhs, rhs, selects...))
+}
+
+type setStatement interface {
+	setOperators
+
+	ORDER_BY(orderByClauses ...OrderByClause) setStatement
+
+	LIMIT(limit int64) setStatement
+	OFFSET(offset int64) setStatement
+
+	AsTable(alias string) SelectTable
+}
+
+type setOperators interface {
+	jet.Statement
+	jet.HasProjections
+	jet.Expression
+
+	UNION(rhs SelectStatement) setStatement
+	UNION_ALL(rhs SelectStatement) setStatement
+}
+
+type setOperatorsImpl struct {
+	parent setOperators
+}
+
+func (s *setOperatorsImpl) UNION(rhs SelectStatement) setStatement {
+	return UNION(s.parent, rhs)
+}
+
+func (s *setOperatorsImpl) UNION_ALL(rhs SelectStatement) setStatement {
+	return UNION_ALL(s.parent, rhs)
+}
+
+type setStatementImpl struct {
+	jet.ExpressionStatement
+
+	setOperatorsImpl
+
+	setOperator jet.ClauseSetStmtOperator
+}
+
+func newSetStatementImpl(operator string, all bool, selects []jet.SerializerStatement) setStatement {
+	newSetStatement := &setStatementImpl{}
+	newSetStatement.ExpressionStatement = jet.NewExpressionStatementImpl(Dialect, jet.SetStatementType, newSetStatement,
+		&newSetStatement.setOperator)
+
+	newSetStatement.setOperator.Operator = operator
+	newSetStatement.setOperator.All = all
+	newSetStatement.setOperator.Selects = selects
+	newSetStatement.setOperator.Limit.Count = -1
+	newSetStatement.setOperator.SkipSelectWrap = true
+
+	newSetStatement.setOperatorsImpl.parent = newSetStatement
+
+	return newSetStatement
+}
+
+func (s *setStatementImpl) ORDER_BY(orderByClauses ...OrderByClause) setStatement {
+	s.setOperator.OrderBy.List = orderByClauses
+	return s
+}
+
+func (s *setStatementImpl) LIMIT(limit int64) setStatement {
+	s.setOperator.Limit.Count = limit
+	return s
+}
+
+func (s *setStatementImpl) OFFSET(offset int64) setStatement {
+	s.setOperator.Offset.Count = Int(offset)
+	return s
+}
+
+func (s *setStatementImpl) AsTable(alias string) SelectTable {
+	return newSelectTable(s, alias, nil)
+}
+
+const (
+	union = "UNION"
+)
+
+func toSelectList(lhs, rhs jet.SerializerStatement, selects ...jet.SerializerStatement) []jet.SerializerStatement {
+	return append([]jet.SerializerStatement{lhs, rhs}, selects...)
+}

vendor/github.com/go-jet/jet/v2/sqlite/statement.go

@@ -0,0 +1,10 @@
+package sqlite
+
+import (
+	"github.com/go-jet/jet/v2/internal/jet"
+)
+
+// RawStatement creates new sql statements from raw query and optional map of named arguments
+func RawStatement(rawQuery string, namedArguments ...RawArgs) jet.SerializerStatement {
+	return jet.RawStatement(Dialect, rawQuery, namedArguments...)
+}

vendor/github.com/go-jet/jet/v2/sqlite/table.go

@@ -0,0 +1,122 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// Table is interface for MySQL tables
+type Table interface {
+	jet.SerializerTable
+	readableTable
+
+	INSERT(columns ...jet.Column) InsertStatement
+	UPDATE(columns ...jet.Column) UpdateStatement
+	DELETE() DeleteStatement
+}
+
+type readableTable interface {
+	// Generates a select query on the current tableName.
+	SELECT(projection Projection, projections ...Projection) SelectStatement
+
+	// Creates a inner join tableName Expression using onCondition.
+	INNER_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable
+
+	// Creates a left join tableName Expression using onCondition.
+	LEFT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable
+
+	// Creates a right join tableName Expression using onCondition.
+	RIGHT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable
+
+	// Creates a full join tableName Expression using onCondition.
+	FULL_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable
+
+	// Creates a cross join tableName Expression using onCondition.
+	CROSS_JOIN(table ReadableTable) joinSelectUpdateTable
+}
+
+type joinSelectUpdateTable interface {
+	ReadableTable
+	UPDATE(columns ...jet.Column) UpdateStatement
+}
+
+// ReadableTable interface
+type ReadableTable interface {
+	readableTable
+	jet.Serializer
+}
+
+type readableTableInterfaceImpl struct {
+	parent ReadableTable
+}
+
+// Generates a select query on the current tableName.
+func (r readableTableInterfaceImpl) SELECT(projection1 Projection, projections ...Projection) SelectStatement {
+	return newSelectStatement(r.parent, append([]Projection{projection1}, projections...))
+}
+
+// Creates a inner join tableName Expression using onCondition.
+func (r readableTableInterfaceImpl) INNER_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
+	return newJoinTable(r.parent, table, jet.InnerJoin, onCondition)
+}
+
+// Creates a left join tableName Expression using onCondition.
+func (r readableTableInterfaceImpl) LEFT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
+	return newJoinTable(r.parent, table, jet.LeftJoin, onCondition)
+}
+
+// Creates a right join tableName Expression using onCondition.
+func (r readableTableInterfaceImpl) RIGHT_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
+	return newJoinTable(r.parent, table, jet.RightJoin, onCondition)
+}
+
+func (r readableTableInterfaceImpl) FULL_JOIN(table ReadableTable, onCondition BoolExpression) joinSelectUpdateTable {
+	return newJoinTable(r.parent, table, jet.FullJoin, onCondition)
+}
+
+func (r readableTableInterfaceImpl) CROSS_JOIN(table ReadableTable) joinSelectUpdateTable {
+	return newJoinTable(r.parent, table, jet.CrossJoin, nil)
+}
+
+// NewTable creates new table with schema Name, table Name and list of columns
+func NewTable(schemaName, name, alias string, columns ...jet.ColumnExpression) Table {
+	t := &tableImpl{
+		SerializerTable: jet.NewTable(schemaName, name, alias, columns...),
+	}
+
+	t.readableTableInterfaceImpl.parent = t
+	t.parent = t
+
+	return t
+}
+
+type tableImpl struct {
+	jet.SerializerTable
+	readableTableInterfaceImpl
+	parent Table
+}
+
+func (t *tableImpl) INSERT(columns ...jet.Column) InsertStatement {
+	return newInsertStatement(t.parent, jet.UnwidColumnList(columns))
+}
+
+func (t *tableImpl) UPDATE(columns ...jet.Column) UpdateStatement {
+	return newUpdateStatement(t.parent, jet.UnwidColumnList(columns))
+}
+
+func (t *tableImpl) DELETE() DeleteStatement {
+	return newDeleteStatement(t.parent)
+}
+
+type joinTable struct {
+	tableImpl
+	jet.JoinTable
+}
+
+func newJoinTable(lhs jet.Serializer, rhs jet.Serializer, joinType jet.JoinType, onCondition BoolExpression) Table {
+	newJoinTable := &joinTable{
+		JoinTable: jet.NewJoinTable(lhs, rhs, joinType, onCondition),
+	}
+
+	newJoinTable.readableTableInterfaceImpl.parent = newJoinTable
+	newJoinTable.parent = newJoinTable
+
+	return newJoinTable
+}

vendor/github.com/go-jet/jet/v2/sqlite/types.go

@@ -0,0 +1,37 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// Statement is common interface for all statements(SELECT, INSERT, UPDATE, DELETE, LOCK)
+type Statement = jet.Statement
+
+// Rows wraps sql.Rows type with a support for query result mapping
+type Rows = jet.Rows
+
+// Projection is interface for all projection types. Types that can be part of, for instance SELECT clause.
+type Projection = jet.Projection
+
+// ProjectionList can be used to create conditional constructed projection list.
+type ProjectionList = jet.ProjectionList
+
+// ColumnAssigment is interface wrapper around column assigment
+type ColumnAssigment = jet.ColumnAssigment
+
+// PrintableStatement is a statement which sql query can be logged
+type PrintableStatement = jet.PrintableStatement
+
+// OrderByClause is the combination of an expression and the wanted ordering to use as input for ORDER BY.
+type OrderByClause = jet.OrderByClause
+
+// GroupByClause interface to use as input for GROUP_BY
+type GroupByClause = jet.GroupByClause
+
+// SetLogger sets automatic statement logging.
+// Deprecated: use SetQueryLogger instead.
+var SetLogger = jet.SetLoggerFunc
+
+// SetQueryLogger sets automatic query logging function.
+var SetQueryLogger = jet.SetQueryLogger
+
+// QueryInfo contains information about executed query
+type QueryInfo = jet.QueryInfo

vendor/github.com/go-jet/jet/v2/sqlite/update_statement.go

@@ -0,0 +1,78 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// UpdateStatement is interface of SQL UPDATE statement
+type UpdateStatement interface {
+	jet.Statement
+
+	SET(value interface{}, values ...interface{}) UpdateStatement
+	MODEL(data interface{}) UpdateStatement
+
+	FROM(tables ...ReadableTable) UpdateStatement
+	WHERE(expression BoolExpression) UpdateStatement
+	RETURNING(projections ...Projection) UpdateStatement
+}
+
+type updateStatementImpl struct {
+	jet.SerializerStatement
+
+	Update    jet.ClauseUpdate
+	From      jet.ClauseFrom
+	Set       jet.SetClause
+	SetNew    jet.SetClauseNew
+	Where     jet.ClauseWhere
+	Returning jet.ClauseReturning
+}
+
+func newUpdateStatement(table Table, columns []jet.Column) UpdateStatement {
+	update := &updateStatementImpl{}
+	update.SerializerStatement = jet.NewStatementImpl(Dialect, jet.UpdateStatementType, update,
+		&update.Update,
+		&update.Set,
+		&update.SetNew,
+		&update.From,
+		&update.Where,
+		&update.Returning)
+
+	update.Update.Table = table
+	update.Set.Columns = columns
+	update.Where.Mandatory = true
+
+	return update
+}
+
+func (u *updateStatementImpl) SET(value interface{}, values ...interface{}) UpdateStatement {
+	columnAssigment, isColumnAssigment := value.(ColumnAssigment)
+
+	if isColumnAssigment {
+		u.SetNew = []ColumnAssigment{columnAssigment}
+		for _, value := range values {
+			u.SetNew = append(u.SetNew, value.(ColumnAssigment))
+		}
+	} else {
+		u.Set.Values = jet.UnwindRowFromValues(value, values)
+	}
+
+	return u
+}
+
+func (u *updateStatementImpl) MODEL(data interface{}) UpdateStatement {
+	u.Set.Values = jet.UnwindRowFromModel(u.Set.Columns, data)
+	return u
+}
+
+func (u *updateStatementImpl) FROM(tables ...ReadableTable) UpdateStatement {
+	u.From.Tables = readableTablesToSerializerList(tables)
+	return u
+}
+
+func (u *updateStatementImpl) WHERE(expression BoolExpression) UpdateStatement {
+	u.Where.Condition = expression
+	return u
+}
+
+func (u *updateStatementImpl) RETURNING(projections ...Projection) UpdateStatement {
+	u.Returning.ProjectionList = projections
+	return u
+}

vendor/github.com/go-jet/jet/v2/sqlite/values.go

@@ -0,0 +1,26 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+type values struct {
+	jet.Values
+}
+
+// VALUES is a table value constructor that computes a set of one or more rows as a temporary constant table.
+// Each row is defined by the ROW constructor, which takes one or more expressions.
+//
+// Example usage:
+//
+//	VALUES(
+//		ROW(Int32(204), Float32(1.21)),
+//		ROW(Int32(207), Float32(1.02)),
+//	)
+func VALUES(rows ...RowExpression) values {
+	return values{Values: jet.Values(rows)}
+}
+
+// AS assigns an alias to the temporary VALUES table, allowing it to be referenced
+// within SQL FROM clauses, just like a regular table.
+func (v values) AS(alias string) SelectTable {
+	return newSelectTable(v, alias, nil)
+}

vendor/github.com/go-jet/jet/v2/sqlite/with_statement.go

@@ -0,0 +1,74 @@
+package sqlite
+
+import "github.com/go-jet/jet/v2/internal/jet"
+
+// CommonTableExpression defines set of interface methods for postgres CTEs
+type CommonTableExpression interface {
+	SelectTable
+
+	AS(statement jet.SerializerHasProjections) CommonTableExpression
+	AS_NOT_MATERIALIZED(statement jet.SerializerHasProjections) CommonTableExpression
+	// ALIAS is used to create another alias of the CTE, if a CTE needs to appear multiple times in the main query.
+	ALIAS(alias string) SelectTable
+
+	internalCTE() *jet.CommonTableExpression
+}
+
+type commonTableExpression struct {
+	readableTableInterfaceImpl
+	jet.CommonTableExpression
+}
+
+// WITH function creates new WITH statement from list of common table expressions
+func WITH(cte ...CommonTableExpression) func(statement jet.Statement) Statement {
+	return jet.WITH(Dialect, false, toInternalCTE(cte)...)
+}
+
+// WITH_RECURSIVE function creates new WITH RECURSIVE statement from list of common table expressions
+func WITH_RECURSIVE(cte ...CommonTableExpression) func(statement jet.Statement) Statement {
+	return jet.WITH(Dialect, true, toInternalCTE(cte)...)
+}
+
+// CTE creates new named commonTableExpression
+func CTE(name string, columns ...jet.ColumnExpression) CommonTableExpression {
+	cte := &commonTableExpression{
+		readableTableInterfaceImpl: readableTableInterfaceImpl{},
+		CommonTableExpression:      jet.CTE(name, columns...),
+	}
+
+	cte.parent = cte
+
+	return cte
+}
+
+// AS is used to define a CTE query
+func (c *commonTableExpression) AS(statement jet.SerializerHasProjections) CommonTableExpression {
+	c.CommonTableExpression.Statement = statement
+	return c
+}
+
+// AS_NOT_MATERIALIZED is used to define not materialized CTE query
+func (c *commonTableExpression) AS_NOT_MATERIALIZED(statement jet.SerializerHasProjections) CommonTableExpression {
+	c.CommonTableExpression.NotMaterialized = true
+	c.CommonTableExpression.Statement = statement
+	return c
+}
+
+func (c *commonTableExpression) internalCTE() *jet.CommonTableExpression {
+	return &c.CommonTableExpression
+}
+
+// ALIAS is used to create another alias of the CTE, if a CTE needs to appear multiple times in the main query.
+func (c *commonTableExpression) ALIAS(name string) SelectTable {
+	return newSelectTable(c, name, nil)
+}
+
+func toInternalCTE(ctes []CommonTableExpression) []*jet.CommonTableExpression {
+	var ret []*jet.CommonTableExpression
+
+	for _, cte := range ctes {
+		ret = append(ret, cte.internalCTE())
+	}
+
+	return ret
+}