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

Time, Timez, Timestamp, Timestampz, Date column types added.

Browse source
This commit is contained in:
zer0sub 2019-05-30 14:49:36 +02:00
parent 7b89caa7e0
commit 7f5ba98819
20 changed files with 620 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

10
sqlbuilder/bool_expresion.go
View file

@ -5,6 +5,8 @@ type boolExpression interface {
EQ(expression boolExpression) boolExpression
NOT_EQ(expression boolExpression) boolExpression
IS_DISTINCT_FROM(rhs boolExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs boolExpression) boolExpression
IS_TRUE() boolExpression
IS_NOT_TRUE() boolExpression
@ -29,6 +31,14 @@ func (b *boolInterfaceImpl) NOT_EQ(expression boolExpression) boolExpression {
return NOT_EQ(b.parent, expression)
}
func (b *boolInterfaceImpl) IS_DISTINCT_FROM(rhs boolExpression) boolExpression {
return IS_DISTINCT_FROM(b.parent, rhs)
}
func (b *boolInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs boolExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(b.parent, rhs)
}
func (b *boolInterfaceImpl) AND(expression boolExpression) boolExpression {
return And(b.parent, expression)
}

4
sqlbuilder/clause.go
View file

@ -192,10 +192,8 @@ func ArgToString(value interface{}) string {
case string:
return `'` + bindVal + `'`
case []byte:
return string(bindVal)
return `'` + string(bindVal) + `'`
//TODO: implement
//case time.Time:
// return bindVal.String())
default:
return "[Unknown type]"
}

84
sqlbuilder/column_types.go
View file

@ -85,13 +85,89 @@ type TimeColumn struct {
// Representation of any integer column
// This function will panic if name is not valid
func NewTimeColumn(name string, nullable NullableColumn) *TimeColumn {
stringColumn := &TimeColumn{}
timeColumn := &TimeColumn{}
stringColumn.timeInterfaceImpl.parent = stringColumn
timeColumn.timeInterfaceImpl.parent = timeColumn
stringColumn.baseColumn = newBaseColumn(name, nullable, "", stringColumn)
timeColumn.baseColumn = newBaseColumn(name, nullable, "", timeColumn)
return stringColumn
return timeColumn
}
//------------------------------------------------------//
type TimezColumn struct {
timezInterfaceImpl
baseColumn
}
// Representation of any integer column
// This function will panic if name is not valid
func NewTimezColumn(name string, nullable NullableColumn) *TimezColumn {
timezColumn := &TimezColumn{}
timezColumn.timezInterfaceImpl.parent = timezColumn
timezColumn.baseColumn = newBaseColumn(name, nullable, "", timezColumn)
return timezColumn
}
//------------------------------------------------------//
type TimestampColumn struct {
timestampInterfaceImpl
baseColumn
}
// Representation of any integer column
// This function will panic if name is not valid
func NewTimestampColumn(name string, nullable NullableColumn) *TimestampColumn {
timestampColumn := &TimestampColumn{}
timestampColumn.timestampInterfaceImpl.parent = timestampColumn
timestampColumn.baseColumn = newBaseColumn(name, nullable, "", timestampColumn)
return timestampColumn
}
//------------------------------------------------------//
type TimestampzColumn struct {
timestampzInterfaceImpl
baseColumn
}
// Representation of any integer column
// This function will panic if name is not valid
func NewTimestampzColumn(name string, nullable NullableColumn) *TimestampzColumn {
timestampzColumn := &TimestampzColumn{}
timestampzColumn.timestampzInterfaceImpl.parent = timestampzColumn
timestampzColumn.baseColumn = newBaseColumn(name, nullable, "", timestampzColumn)
return timestampzColumn
}
//------------------------------------------------------//
type DateColumn struct {
dateInterfaceImpl
baseColumn
}
// Representation of any integer column
// This function will panic if name is not valid
func NewDateColumn(name string, nullable NullableColumn) *DateColumn {
dateColumn := &DateColumn{}
dateColumn.dateInterfaceImpl.parent = dateColumn
dateColumn.baseColumn = newBaseColumn(name, nullable, "", dateColumn)
return dateColumn
}
// ------------------------------------------------------//

51
sqlbuilder/date_expression.go Normal file
View file

@ -0,0 +1,51 @@
package sqlbuilder
type DateExpression interface {
expression
EQ(rhs DateExpression) boolExpression
NOT_EQ(rhs DateExpression) boolExpression
IS_DISTINCT_FROM(rhs DateExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs DateExpression) boolExpression
LT(rhs DateExpression) boolExpression
LT_EQ(rhs DateExpression) boolExpression
GT(rhs DateExpression) boolExpression
GT_EQ(rhs DateExpression) boolExpression
}
type dateInterfaceImpl struct {
parent DateExpression
}
func (t *dateInterfaceImpl) EQ(rhs DateExpression) boolExpression {
return EQ(t.parent, rhs)
}
func (t *dateInterfaceImpl) NOT_EQ(rhs DateExpression) boolExpression {
return NOT_EQ(t.parent, rhs)
}
func (t *dateInterfaceImpl) IS_DISTINCT_FROM(rhs DateExpression) boolExpression {
return IS_DISTINCT_FROM(t.parent, rhs)
}
func (t *dateInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs DateExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(t.parent, rhs)
}
func (t *dateInterfaceImpl) LT(rhs DateExpression) boolExpression {
return LT(t.parent, rhs)
}
func (t *dateInterfaceImpl) LT_EQ(rhs DateExpression) boolExpression {
return LT_EQ(t.parent, rhs)
}
func (t *dateInterfaceImpl) GT(rhs DateExpression) boolExpression {
return GT(t.parent, rhs)
}
func (t *dateInterfaceImpl) GT_EQ(rhs DateExpression) boolExpression {
return GT_EQ(t.parent, rhs)
}

10
sqlbuilder/expression.go
View file

@ -13,8 +13,6 @@ type expression interface {
IS_NULL() boolExpression
IS_NOT_NULL() boolExpression
IS_DISTINCT_FROM(expression expression) boolExpression
IS_NOT_DISTINCT_FROM(expression expression) boolExpression
IN(subQuery selectStatement) boolExpression
NOT_IN(subQuery selectStatement) boolExpression
@ -37,14 +35,6 @@ func (e *expressionInterfaceImpl) IS_NOT_NULL() boolExpression {
return newPostifxBoolExpression(e.parent, "IS NOT NULL")
}
func (e *expressionInterfaceImpl) IS_DISTINCT_FROM(expression expression) boolExpression {
return newBinaryBoolExpression(e.parent, expression, "IS DISTINCT FROM")
}
func (e *expressionInterfaceImpl) IS_NOT_DISTINCT_FROM(expression expression) boolExpression {
return newBinaryBoolExpression(e.parent, expression, "IS NOT DISTINCT FROM")
}
func (e *expressionInterfaceImpl) IN(subQuery selectStatement) boolExpression {
return newBinaryBoolExpression(e.parent, subQuery, "IN")
}

4
sqlbuilder/expression_test.go
View file

@ -16,11 +16,11 @@ func TestExpressionIS_NOT_NULL(t *testing.T) {
}
func TestExpressionIS_DISTINCT_FROM(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table2Col3.IS_DISTINCT_FROM(table2StrCol)), "table2.col3 IS DISTINCT FROM table2.col4")
assert.Equal(t, getTestSerialize(t, table2Col3.IS_DISTINCT_FROM(table2Col4)), "table2.col3 IS DISTINCT FROM table2.col4")
assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_DISTINCT_FROM(Int(23))), "(table2.col3 + table2.col3 IS DISTINCT FROM $1)")
}
func TestExpressionIS_NOT_DISTINCT_FROM(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table2Col3.IS_NOT_DISTINCT_FROM(table2StrCol)), "table2.col3 IS NOT DISTINCT FROM table2.col4")
assert.Equal(t, getTestSerialize(t, table2Col3.IS_NOT_DISTINCT_FROM(table2Col4)), "table2.col3 IS NOT DISTINCT FROM table2.col4")
assert.Equal(t, getTestSerialize(t, table2Col3.ADD(table2Col3).IS_NOT_DISTINCT_FROM(Int(23))), "(table2.col3 + table2.col3 IS NOT DISTINCT FROM $1)")
}

73
sqlbuilder/literal_expression.go
View file

@ -1,6 +1,6 @@
package sqlbuilder
import "time"
import "fmt"
// Representation of an escaped literal
type literalExpression struct {
@ -88,11 +88,78 @@ type timeLiteral struct {
literalExpression
}
func Time(value time.Time) timeExpression {
func Time(hour, minute, second, milliseconds int) timeExpression {
timeLiteral := timeLiteral{}
timeLiteral.literalExpression = *Literal(value)
timeStr := fmt.Sprintf("%02d:%02d:%02d.%03d", hour, minute, second, milliseconds)
timeLiteral.literalExpression = *Literal(timeStr)
timeLiteral.timeInterfaceImpl.parent = &timeLiteral
return &timeLiteral
}
//---------------------------------------------------//
type timezLiteral struct {
timezInterfaceImpl
literalExpression
}
func Timez(hour, minute, second, milliseconds, timezone int) timezExpression {
timezLiteral := timezLiteral{}
timeStr := fmt.Sprintf("%02d:%02d:%02d.%03d %+03d", hour, minute, second, milliseconds, timezone)
timezLiteral.literalExpression = *Literal(timeStr)
timezLiteral.timezInterfaceImpl.parent = &timezLiteral
return &timezLiteral
}
//---------------------------------------------------//
type timestampLiteral struct {
timestampInterfaceImpl
literalExpression
}
func Timestamp(year, month, day, hour, minute, second, milliseconds int) TimestampExpression {
timestampLiteral := timestampLiteral{}
timeStr := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d.%03d", year, month, day, hour, minute, second, milliseconds)
timestampLiteral.literalExpression = *Literal(timeStr)
timestampLiteral.timestampInterfaceImpl.parent = &timestampLiteral
return &timestampLiteral
}
//---------------------------------------------------//
type timestampzLiteral struct {
timestampzInterfaceImpl
literalExpression
}
func Timestampz(year, month, day, hour, minute, second, milliseconds, timezone int) TimestampzExpression {
timestampzLiteral := timestampzLiteral{}
timeStr := fmt.Sprintf("%04d-%02d-%02d %02d:%02d:%02d.%03d %+04d",
year, month, day, hour, minute, second, milliseconds, timezone)
timestampzLiteral.literalExpression = *Literal(timeStr)
timestampzLiteral.timestampzInterfaceImpl.parent = &timestampzLiteral
return &timestampzLiteral
}
//---------------------------------------------------//
type dateLiteral struct {
dateInterfaceImpl
literalExpression
}
func Date(year, month, day int) DateExpression {
dateLiteral := dateLiteral{}
timeStr := fmt.Sprintf("%04d-%02d-%02d", year, month, day)
dateLiteral.literalExpression = *Literal(timeStr)
dateLiteral.dateInterfaceImpl.parent = &dateLiteral
return &dateLiteral
}

39
sqlbuilder/numeric_expression.go
View file

@ -5,37 +5,48 @@ import "errors"
type numericExpression interface {
expression
EQ(expression numericExpression) boolExpression
NOT_EQ(expression numericExpression) boolExpression
EQ(rhs numericExpression) boolExpression
NOT_EQ(rhs numericExpression) boolExpression
IS_DISTINCT_FROM(rhs numericExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs numericExpression) boolExpression
LT(rhs numericExpression) boolExpression
LT_EQ(rhs numericExpression) boolExpression
GT(rhs numericExpression) boolExpression
GT_EQ(rhs numericExpression) boolExpression
ADD(expression numericExpression) numericExpression
SUB(expression numericExpression) numericExpression
MUL(expression numericExpression) numericExpression
DIV(expression numericExpression) numericExpression
ADD(rhs numericExpression) numericExpression
SUB(rhs numericExpression) numericExpression
MUL(rhs numericExpression) numericExpression
DIV(rhs numericExpression) numericExpression
}
type numericInterfaceImpl struct {
parent numericExpression
}
func (n *numericInterfaceImpl) EQ(expression numericExpression) boolExpression {
return EQ(n.parent, expression)
func (n *numericInterfaceImpl) EQ(rhs numericExpression) boolExpression {
return EQ(n.parent, rhs)
}
func (n *numericInterfaceImpl) NOT_EQ(expression numericExpression) boolExpression {
return NOT_EQ(n.parent, expression)
func (n *numericInterfaceImpl) NOT_EQ(rhs numericExpression) boolExpression {
return NOT_EQ(n.parent, rhs)
}
func (n *numericInterfaceImpl) GT(expression numericExpression) boolExpression {
return GT(n.parent, expression)
func (n *numericInterfaceImpl) IS_DISTINCT_FROM(rhs numericExpression) boolExpression {
return IS_DISTINCT_FROM(n.parent, rhs)
}
func (n *numericInterfaceImpl) GT_EQ(expression numericExpression) boolExpression {
return GT_EQ(n.parent, expression)
func (n *numericInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs numericExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(n.parent, rhs)
}
func (n *numericInterfaceImpl) GT(rhs numericExpression) boolExpression {
return GT(n.parent, rhs)
}
func (n *numericInterfaceImpl) GT_EQ(rhs numericExpression) boolExpression {
return GT_EQ(n.parent, rhs)
}
func (n *numericInterfaceImpl) LT(expression numericExpression) boolExpression {

8
sqlbuilder/operators.go
View file

@ -19,6 +19,14 @@ func NOT_EQ(lhs, rhs expression) boolExpression {
return newBinaryBoolExpression(lhs, rhs, "!=")
}
func IS_DISTINCT_FROM(lhs, rhs expression) boolExpression {
return newBinaryBoolExpression(lhs, rhs, "IS DISTINCT FROM")
}
func IS_NOT_DISTINCT_FROM(lhs, rhs expression) boolExpression {
return newBinaryBoolExpression(lhs, rhs, "IS NOT DISTINCT FROM")
}
// Returns a representation of "a<b"
func LT(lhs expression, rhs expression) boolExpression {
return newBinaryBoolExpression(lhs, rhs, "<")

11
sqlbuilder/string_expression.go
View file

@ -5,6 +5,9 @@ type stringExpression interface {
EQ(rhs stringExpression) boolExpression
NOT_EQ(rhs stringExpression) boolExpression
IS_DISTINCT_FROM(rhs stringExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs stringExpression) boolExpression
LT(rhs stringExpression) boolExpression
LT_EQ(rhs stringExpression) boolExpression
GT(rhs stringExpression) boolExpression
@ -23,6 +26,14 @@ func (s *stringInterfaceImpl) NOT_EQ(rhs stringExpression) boolExpression {
return NOT_EQ(s.parent, rhs)
}
func (s *stringInterfaceImpl) IS_DISTINCT_FROM(rhs stringExpression) boolExpression {
return IS_DISTINCT_FROM(s.parent, rhs)
}
func (s *stringInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs stringExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(s.parent, rhs)
}
func (s *stringInterfaceImpl) GT(rhs stringExpression) boolExpression {
return GT(s.parent, rhs)
}

12
sqlbuilder/string_expression_test.go
View file

@ -12,7 +12,7 @@ func TestStringEQColumn(t *testing.T) {
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "table3.col2 = table2.col4")
assert.Equal(t, out.buff.String(), "table3.col2 = table2.colStr")
}
func TestStringEQString(t *testing.T) {
@ -32,7 +32,7 @@ func TestStringNOT_EQ(t *testing.T) {
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "table3.col2 != table2.col4")
assert.Equal(t, out.buff.String(), "table3.col2 != table2.colStr")
}
func TestStringGT(t *testing.T) {
@ -42,7 +42,7 @@ func TestStringGT(t *testing.T) {
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "table3.col2 > table2.col4")
assert.Equal(t, out.buff.String(), "table3.col2 > table2.colStr")
}
func TestStringGT_EQ(t *testing.T) {
@ -52,7 +52,7 @@ func TestStringGT_EQ(t *testing.T) {
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "table3.col2 >= table2.col4")
assert.Equal(t, out.buff.String(), "table3.col2 >= table2.colStr")
}
func TestStringLT(t *testing.T) {
@ -62,7 +62,7 @@ func TestStringLT(t *testing.T) {
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "table3.col2 < table2.col4")
assert.Equal(t, out.buff.String(), "table3.col2 < table2.colStr")
}
func TestStringLT_EQ(t *testing.T) {
@ -72,5 +72,5 @@ func TestStringLT_EQ(t *testing.T) {
err := exp.serialize(select_statement, &out)
assert.NilError(t, err)
assert.Equal(t, out.buff.String(), "table3.col2 <= table2.col4")
assert.Equal(t, out.buff.String(), "table3.col2 <= table2.colStr")
}

2
sqlbuilder/test_utils.go
View file

@ -22,7 +22,7 @@ var table1 = NewTable(
var table2Col3 = NewIntegerColumn("col3", Nullable)
var table2Col4 = NewIntegerColumn("col4", Nullable)
var table2StrCol = NewStringColumn("col4", Nullable)
var table2StrCol = NewStringColumn("colStr", Nullable)
var table2ColBool = NewBoolColumn("colBool", Nullable)
var table2ColTime = NewTimeColumn("colTime", Nullable)

15
sqlbuilder/time_expression.go
View file

@ -5,6 +5,9 @@ type timeExpression interface {
EQ(rhs timeExpression) boolExpression
NOT_EQ(rhs timeExpression) boolExpression
IS_DISTINCT_FROM(rhs timeExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs timeExpression) boolExpression
LT(rhs timeExpression) boolExpression
LT_EQ(rhs timeExpression) boolExpression
GT(rhs timeExpression) boolExpression
@ -23,6 +26,14 @@ func (t *timeInterfaceImpl) NOT_EQ(rhs timeExpression) boolExpression {
return NOT_EQ(t.parent, rhs)
}
func (t *timeInterfaceImpl) IS_DISTINCT_FROM(rhs timeExpression) boolExpression {
return IS_DISTINCT_FROM(t.parent, rhs)
}
func (t *timeInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs timeExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(t.parent, rhs)
}
func (t *timeInterfaceImpl) LT(rhs timeExpression) boolExpression {
return LT(t.parent, rhs)
}
@ -47,7 +58,7 @@ type prefixTimeExpression struct {
prefixOpExpression
}
func newPrefixTimeExpression(expression expression, operator string) timeExpression {
func newPrefixTimeExpression(operator string, expression expression) timeExpression {
timeExpr := prefixTimeExpression{}
timeExpr.prefixOpExpression = newPrefixExpression(expression, operator)
@ -58,5 +69,5 @@ func newPrefixTimeExpression(expression expression, operator string) timeExpress
}
func INTERVAL(interval string) expression {
return newPrefixTimeExpression(Literal(interval), "INTERVAL")
return newPrefixTimeExpression("INTERVAL", Literal(interval))
}

13
sqlbuilder/time_expression_test.go
View file

@ -3,35 +3,34 @@ package sqlbuilder
import (
"gotest.tools/assert"
"testing"
"time"
)
func TestTimeExpressionEQ(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(table2ColTime)), "table1.colTime = table2.colTime")
assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(Time(time.Now()))), "table1.colTime = $1")
assert.Equal(t, getTestSerialize(t, table1ColTime.EQ(Time(10, 20, 0, 0))), "table1.colTime = $1")
}
func TestTimeExpressionNOT_EQ(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(table2ColTime)), "table1.colTime != table2.colTime")
assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(Time(time.Now()))), "table1.colTime != $1")
assert.Equal(t, getTestSerialize(t, table1ColTime.NOT_EQ(Time(10, 20, 0, 0))), "table1.colTime != $1")
}
func TestTimeExpressionLT(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table1ColTime.LT(table2ColTime)), "table1.colTime < table2.colTime")
assert.Equal(t, getTestSerialize(t, table1ColTime.LT(Time(time.Now()))), "table1.colTime < $1")
assert.Equal(t, getTestSerialize(t, table1ColTime.LT(Time(10, 20, 0, 0))), "table1.colTime < $1")
}
func TestTimeExpressionLT_EQ(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(table2ColTime)), "table1.colTime <= table2.colTime")
assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(Time(time.Now()))), "table1.colTime <= $1")
assert.Equal(t, getTestSerialize(t, table1ColTime.LT_EQ(Time(10, 20, 0, 0))), "table1.colTime <= $1")
}
func TestTimeExpressionGT(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table1ColTime.GT(table2ColTime)), "table1.colTime > table2.colTime")
assert.Equal(t, getTestSerialize(t, table1ColTime.GT(Time(time.Now()))), "table1.colTime > $1")
assert.Equal(t, getTestSerialize(t, table1ColTime.GT(Time(10, 20, 0, 0))), "table1.colTime > $1")
}
func TestTimeExpressionGT_EQ(t *testing.T) {
assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(table2ColTime)), "table1.colTime >= table2.colTime")
assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(Time(time.Now()))), "table1.colTime >= $1")
assert.Equal(t, getTestSerialize(t, table1ColTime.GT_EQ(Time(10, 20, 0, 0))), "table1.colTime >= $1")
}

51
sqlbuilder/timestamp_expression.go Normal file
View file

@ -0,0 +1,51 @@
package sqlbuilder
type TimestampExpression interface {
expression
EQ(rhs TimestampExpression) boolExpression
NOT_EQ(rhs TimestampExpression) boolExpression
IS_DISTINCT_FROM(rhs TimestampExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs TimestampExpression) boolExpression
LT(rhs TimestampExpression) boolExpression
LT_EQ(rhs TimestampExpression) boolExpression
GT(rhs TimestampExpression) boolExpression
GT_EQ(rhs TimestampExpression) boolExpression
}
type timestampInterfaceImpl struct {
parent TimestampExpression
}
func (t *timestampInterfaceImpl) EQ(rhs TimestampExpression) boolExpression {
return EQ(t.parent, rhs)
}
func (t *timestampInterfaceImpl) NOT_EQ(rhs TimestampExpression) boolExpression {
return NOT_EQ(t.parent, rhs)
}
func (t *timestampInterfaceImpl) IS_DISTINCT_FROM(rhs TimestampExpression) boolExpression {
return IS_DISTINCT_FROM(t.parent, rhs)
}
func (t *timestampInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs TimestampExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(t.parent, rhs)
}
func (t *timestampInterfaceImpl) LT(rhs TimestampExpression) boolExpression {
return LT(t.parent, rhs)
}
func (t *timestampInterfaceImpl) LT_EQ(rhs TimestampExpression) boolExpression {
return LT_EQ(t.parent, rhs)
}
func (t *timestampInterfaceImpl) GT(rhs TimestampExpression) boolExpression {
return GT(t.parent, rhs)
}
func (t *timestampInterfaceImpl) GT_EQ(rhs TimestampExpression) boolExpression {
return GT_EQ(t.parent, rhs)
}

51
sqlbuilder/timestampz_expression.go Normal file
View file

@ -0,0 +1,51 @@
package sqlbuilder
type TimestampzExpression interface {
expression
EQ(rhs TimestampzExpression) boolExpression
NOT_EQ(rhs TimestampzExpression) boolExpression
IS_DISTINCT_FROM(rhs TimestampzExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs TimestampzExpression) boolExpression
LT(rhs TimestampzExpression) boolExpression
LT_EQ(rhs TimestampzExpression) boolExpression
GT(rhs TimestampzExpression) boolExpression
GT_EQ(rhs TimestampzExpression) boolExpression
}
type timestampzInterfaceImpl struct {
parent TimestampzExpression
}
func (t *timestampzInterfaceImpl) EQ(rhs TimestampzExpression) boolExpression {
return EQ(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) NOT_EQ(rhs TimestampzExpression) boolExpression {
return NOT_EQ(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) IS_DISTINCT_FROM(rhs TimestampzExpression) boolExpression {
return IS_DISTINCT_FROM(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs TimestampzExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) LT(rhs TimestampzExpression) boolExpression {
return LT(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) LT_EQ(rhs TimestampzExpression) boolExpression {
return LT_EQ(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) GT(rhs TimestampzExpression) boolExpression {
return GT(t.parent, rhs)
}
func (t *timestampzInterfaceImpl) GT_EQ(rhs TimestampzExpression) boolExpression {
return GT_EQ(t.parent, rhs)
}

69
sqlbuilder/timez_expression.go Normal file
View file

@ -0,0 +1,69 @@
package sqlbuilder
type timezExpression interface {
expression
EQ(rhs timezExpression) boolExpression
NOT_EQ(rhs timezExpression) boolExpression
IS_DISTINCT_FROM(rhs timezExpression) boolExpression
IS_NOT_DISTINCT_FROM(rhs timezExpression) boolExpression
LT(rhs timezExpression) boolExpression
LT_EQ(rhs timezExpression) boolExpression
GT(rhs timezExpression) boolExpression
GT_EQ(rhs timezExpression) boolExpression
}
type timezInterfaceImpl struct {
parent timezExpression
}
func (t *timezInterfaceImpl) EQ(rhs timezExpression) boolExpression {
return EQ(t.parent, rhs)
}
func (t *timezInterfaceImpl) NOT_EQ(rhs timezExpression) boolExpression {
return NOT_EQ(t.parent, rhs)
}
func (t *timezInterfaceImpl) IS_DISTINCT_FROM(rhs timezExpression) boolExpression {
return IS_DISTINCT_FROM(t.parent, rhs)
}
func (t *timezInterfaceImpl) IS_NOT_DISTINCT_FROM(rhs timezExpression) boolExpression {
return IS_NOT_DISTINCT_FROM(t.parent, rhs)
}
func (t *timezInterfaceImpl) LT(rhs timezExpression) boolExpression {
return LT(t.parent, rhs)
}
func (t *timezInterfaceImpl) LT_EQ(rhs timezExpression) boolExpression {
return LT_EQ(t.parent, rhs)
}
func (t *timezInterfaceImpl) GT(rhs timezExpression) boolExpression {
return GT(t.parent, rhs)
}
func (t *timezInterfaceImpl) GT_EQ(rhs timezExpression) boolExpression {
return GT_EQ(t.parent, rhs)
}
//---------------------------------------------------//
type prefixTimezExpression struct {
expressionInterfaceImpl
timezInterfaceImpl
prefixOpExpression
}
func newPrefixTimezExpression(operator string, expression expression) timezExpression {
timeExpr := prefixTimezExpression{}
timeExpr.prefixOpExpression = newPrefixExpression(expression, operator)
timeExpr.expressionInterfaceImpl.parent = &timeExpr
timeExpr.timezInterfaceImpl.parent = &timeExpr
return &timeExpr
}