Develop

README.md

@@ -50,7 +50,7 @@ https://medium.com/@go.jet/jet-5f3667efa0cc
 
 To install Jet package, you need to install Go and set your Go workspace first.
 
-[Go](https://golang.org/) **version 1.9+ is required**
+[Go](https://golang.org/) **version 1.18+ is required**
 
 ### Installation
 

generator/template/model_template.go

@@ -5,6 +5,7 @@ import (
 	"github.com/go-jet/jet/v2/generator/metadata"
 	"github.com/go-jet/jet/v2/internal/utils/dbidentifier"
 	"github.com/google/uuid"
+	"github.com/jackc/pgtype"
 	"path"
 	"reflect"
 	"strings"
@@ -320,6 +321,18 @@ func toGoType(column metadata.Column) interface{} {
 		return float64(0.0)
 	case "uuid":
 		return uuid.UUID{}
+	case "daterange":
+		return pgtype.Daterange{}
+	case "tsrange":
+		return pgtype.Tsrange{}
+	case "tstzrange":
+		return pgtype.Tstzrange{}
+	case "int4range":
+		return pgtype.Int4range{}
+	case "int8range":
+		return pgtype.Int8range{}
+	case "numrange":
+		return pgtype.Numrange{}
 	default:
 		fmt.Println("- [Model      ] Unsupported sql column '" + column.Name + " " + column.DataType.Name + "', using string instead.")
 		return ""

generator/template/sql_builder_template.go

@@ -177,6 +177,18 @@ func getSqlBuilderColumnType(columnMetaData metadata.Column) string {
 	case "real", "numeric", "decimal", "double precision", "float", "float4", "float8",
 		"double": // MySQL
 		return "Float"
+	case "daterange":
+		return "DateRange"
+	case "tsrange":
+		return "TimestampRange"
+	case "tstzrange":
+		return "TimestampzRange"
+	case "int4range":
+		return "Int4Range"
+	case "int8range":
+		return "Int8Range"
+	case "numrange":
+		return "NumericRange"
 	default:
 		fmt.Println("- [SQL Builder] Unsupported sql column '" + columnMetaData.Name + " " + columnMetaData.DataType.Name + "', using StringColumn instead.")
 		return "String"

go.mod

@@ -1,6 +1,6 @@
 module github.com/go-jet/jet/v2
 
-go 1.11
+go 1.18
 
 require (
 	github.com/go-sql-driver/mysql v1.7.1
@@ -10,14 +10,34 @@ require (
 	github.com/mattn/go-sqlite3 v1.14.17
 )
 
-// test dependencies
 require (
 	github.com/google/go-cmp v0.5.9
+	github.com/jackc/pgtype v1.14.0
 	github.com/jackc/pgx/v4 v4.18.1
 	github.com/pkg/profile v1.7.0
 	github.com/shopspring/decimal v1.3.1
 	github.com/stretchr/testify v1.8.2
 	github.com/volatiletech/null/v8 v8.1.2
-	golang.org/x/sync v0.3.0
 	gopkg.in/guregu/null.v4 v4.0.0
 )
+
+require (
+	github.com/davecgh/go-spew v1.1.1 // indirect
+	github.com/felixge/fgprof v0.9.3 // indirect
+	github.com/friendsofgo/errors v0.9.2 // indirect
+	github.com/gofrs/uuid v4.0.0+incompatible // indirect
+	github.com/google/pprof v0.0.0-20211214055906-6f57359322fd // indirect
+	github.com/jackc/chunkreader/v2 v2.0.1 // indirect
+	github.com/jackc/pgio v1.0.0 // indirect
+	github.com/jackc/pgpassfile v1.0.0 // indirect
+	github.com/jackc/pgproto3/v2 v2.3.2 // indirect
+	github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
+	github.com/volatiletech/inflect v0.0.1 // indirect
+	github.com/volatiletech/randomize v0.0.1 // indirect
+	github.com/volatiletech/strmangle v0.0.1 // indirect
+	golang.org/x/crypto v0.6.0 // indirect
+	golang.org/x/text v0.7.0 // indirect
+	golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 // indirect
+	gopkg.in/yaml.v3 v3.0.1 // indirect
+)

go.sum

@@ -32,7 +32,6 @@ github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm4
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/ianlancetaylor/demangle v0.0.0-20210905161508-09a460cdf81d/go.mod h1:aYm2/VgdVmcIU8iMfdMvDMsRAQjcfZSKFby6HOFvi/w=
-github.com/jackc/chunkreader v1.0.0 h1:4s39bBR8ByfqH+DKm8rQA3E1LHZWB9XWcrz8fqaZbe0=
 github.com/jackc/chunkreader v1.0.0/go.mod h1:RT6O25fNZIuasFJRyZ4R/Y2BbhasbmZXF9QQ7T3kePo=
 github.com/jackc/chunkreader/v2 v2.0.0/go.mod h1:odVSm741yZoC3dpHEUXIqA9tQRhFrgOHwnPIn9lDKlk=
 github.com/jackc/chunkreader/v2 v2.0.1 h1:i+RDz65UE+mmpjTfyz0MoVTnzeYxroil2G82ki7MGG8=
@@ -54,7 +53,6 @@ github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65 h1:DadwsjnMwFjfWc9y5W
 github.com/jackc/pgmock v0.0.0-20210724152146-4ad1a8207f65/go.mod h1:5R2h2EEX+qri8jOWMbJCtaPWkrrNc7OHwsp2TCqp7ak=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
-github.com/jackc/pgproto3 v1.1.0 h1:FYYE4yRw+AgI8wXIinMlNjBbp/UitDJwfj5LqqewP1A=
 github.com/jackc/pgproto3 v1.1.0/go.mod h1:eR5FA3leWg7p9aeAqi37XOTgTIbkABlvcPB3E5rlc78=
 github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190420180111-c116219b62db/go.mod h1:bhq50y+xrl9n5mRYyCBFKkpRVTLYJVWeCc+mEAI3yXA=
 github.com/jackc/pgproto3/v2 v2.0.0-alpha1.0.20190609003834-432c2951c711/go.mod h1:uH0AWtUmuShn0bcesswc4aBTWGvw0cAxIJp+6OB//Wg=
@@ -183,8 +181,6 @@ golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.3.0 h1:ftCYgMx6zT/asHUrPw8BLLscYtGznsLAnjq5RH9P66E=
-golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
 golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

internal/jet/column_types.go

@@ -358,3 +358,44 @@ func DateColumn(name string) ColumnDate {
 	dateColumn.ColumnExpressionImpl = NewColumnImpl(name, "", dateColumn)
 	return dateColumn
 }
+
+//------------------------------------------------------//
+
+// ColumnRange is interface for range columns which can be int range, string range
+// timestamp range or date range.
+type ColumnRange[T Expression] interface {
+	Range[T]
+	Column
+
+	From(subQuery SelectTable) ColumnRange[T]
+	SET(rangeExp Range[T]) ColumnAssigment
+}
+
+type rangeColumnImpl[T Expression] struct {
+	rangeInterfaceImpl[T]
+	ColumnExpressionImpl
+}
+
+func (i *rangeColumnImpl[T]) From(subQuery SelectTable) ColumnRange[T] {
+	newRangeColumn := RangeColumn[T](i.name)
+	newRangeColumn.setTableName(i.tableName)
+	newRangeColumn.setSubQuery(subQuery)
+
+	return newRangeColumn
+}
+
+func (i *rangeColumnImpl[T]) SET(rangeExp Range[T]) ColumnAssigment {
+	return columnAssigmentImpl{
+		column:     i,
+		expression: rangeExp,
+	}
+}
+
+// RangeColumn creates named range column.
+func RangeColumn[T Expression](name string) ColumnRange[T] {
+	rangeColumn := &rangeColumnImpl[T]{}
+	rangeColumn.rangeInterfaceImpl.parent = rangeColumn
+	rangeColumn.ColumnExpressionImpl = NewColumnImpl(name, "", rangeColumn)
+
+	return rangeColumn
+}

internal/jet/func_expression.go

@@ -468,6 +468,33 @@ func REGEXP_LIKE(stringExp StringExpression, pattern StringExpression, matchType
 	return newBoolFunc("REGEXP_LIKE", stringExp, pattern)
 }
 
+//----------Range Type Functions ----------------------//
+
+// LOWER_BOUND returns range expressions lower bound
+func LOWER_BOUND[T Expression](rangeExpression Range[T]) T {
+	return rangeTypeCaster[T](rangeExpression, NewFunc("LOWER", []Expression{rangeExpression}, nil))
+}
+
+// UPPER_BOUND returns range expressions upper bound
+func UPPER_BOUND[T Expression](rangeExpression Range[T]) T {
+	return rangeTypeCaster[T](rangeExpression, NewFunc("UPPER", []Expression{rangeExpression}, nil))
+}
+
+func rangeTypeCaster[T Expression](rangeExpression Range[T], exp Expression) T {
+	var i Expression
+	switch rangeExpression.(type) {
+	case Range[DateExpression]:
+		i = DateExp(exp)
+	case Range[IntegerExpression]:
+		i = IntExp(exp)
+	case Range[TimestampzExpression]:
+		i = TimestampzExp(exp)
+	case Range[TimestampExpression]:
+		i = TimestampExp(exp)
+	}
+	return i.(T)
+}
+
 //----------Data Type Formatting Functions ----------------------//
 
 // TO_CHAR converts expression to string with format
@@ -843,3 +870,35 @@ func newTimestampzFunc(name string, expressions ...Expression) *timestampzFunc {
 func Func(name string, expressions ...Expression) Expression {
 	return NewFunc(name, expressions, nil)
 }
+
+func NumRange(lowNum, highNum NumericExpression, bounds ...StringExpression) Range[NumericExpression] {
+	return RangeExp[NumericExpression](NewFunc("numrange", rangeFuncParamCombiner[NumericExpression](lowNum, highNum, bounds...), nil))
+}
+
+func Int4Range(lowNum, highNum IntegerExpression, bounds ...StringExpression) Range[IntegerExpression] {
+	return RangeExp[IntegerExpression](NewFunc("int4range", rangeFuncParamCombiner[IntegerExpression](lowNum, highNum, bounds...), nil))
+}
+
+func Int8Range(lowNum, highNum IntegerExpression, bounds ...StringExpression) Range[IntegerExpression] {
+	return RangeExp[IntegerExpression](NewFunc("int8range", rangeFuncParamCombiner[IntegerExpression](lowNum, highNum, bounds...), nil))
+}
+
+func TimestampRange(lowTs, highTs TimestampExpression, bounds ...StringExpression) Range[TimestampExpression] {
+	return RangeExp[TimestampExpression](NewFunc("tsrange", rangeFuncParamCombiner[TimestampExpression](lowTs, highTs, bounds...), nil))
+}
+
+func TimestampzRange(lowTs, highTs TimestampzExpression, bounds ...StringExpression) Range[TimestampzExpression] {
+	return RangeExp[TimestampzExpression](NewFunc("tstzrange", rangeFuncParamCombiner[TimestampzExpression](lowTs, highTs, bounds...), nil))
+}
+
+func DateRange(lowTs, highTs DateExpression, bounds ...StringExpression) Range[DateExpression] {
+	return RangeExp[DateExpression](NewFunc("daterange", rangeFuncParamCombiner[DateExpression](lowTs, highTs, bounds...), nil))
+}
+
+func rangeFuncParamCombiner[T Expression](low, high T, bounds ...StringExpression) []Expression {
+	exp := []Expression{low, high}
+	if len(bounds) != 0 {
+		exp = append(exp, bounds[0])
+	}
+	return exp
+}

internal/jet/func_expression_test.go

@@ -202,3 +202,14 @@ func TestTO_ASCII(t *testing.T) {
 func TestFunc(t *testing.T) {
 	assertClauseSerialize(t, Func("FOO", String("test"), NULL, MAX(Int(1))), "FOO($1, NULL, MAX($2))", "test", int64(1))
 }
+
+func Test_rangePointCaster(t *testing.T) {
+	mainRange := Int8Range(Int8(10), Int8(12))
+	exp := NewFunc("UPPER", []Expression{mainRange}, nil)
+
+	got := rangeTypeCaster(mainRange, exp)
+	_, ok := got.(IntegerExpression)
+	if !ok {
+		t.Errorf("expecting to get IntegerExpression but got %v", got)
+	}
+}

internal/jet/literal_expression.go

@@ -333,6 +333,10 @@ var (
 	NULL = newNullLiteral()
 	// STAR is jet equivalent of SQL *
 	STAR = newStarLiteral()
+	// PLUS_INFINITY is jet equivalent for sql infinity
+	PLUS_INFINITY = String("infinity")
+	// MINUS_INFINITY is jet equivalent for sql -infinity
+	MINUS_INFINITY = String("-infinity")
 )
 
 type nullLiteral struct {
@@ -490,6 +494,11 @@ func RawDate(raw string, namedArgs ...map[string]interface{}) DateExpression {
 	return DateExp(Raw(raw, namedArgs...))
 }
 
+// RawRange helper that for range expressions
+func RawRange[T Expression](raw string, namedArgs ...map[string]interface{}) Range[T] {
+	return RangeExp[T](Raw(raw, namedArgs...))
+}
+
 // UUID is a helper function to create string literal expression from uuid object
 // value can be any uuid type with a String method
 func UUID(value fmt.Stringer) StringExpression {

internal/jet/operators.go

@@ -69,6 +69,16 @@ func GtEq(lhs, rhs Expression) BoolExpression {
 	return newBinaryBoolOperatorExpression(lhs, rhs, ">=")
 }
 
+// Contains returns a representation of "a @> b"
+func Contains(lhs Expression, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "@>")
+}
+
+// Overlap returns a representation of "a && b"
+func Overlap(lhs, rhs Expression) BoolExpression {
+	return newBinaryBoolOperatorExpression(lhs, rhs, "&&")
+}
+
 // Add notEq returns a representation of "a + b"
 func Add(lhs, rhs Serializer) Expression {
 	return NewBinaryOperatorExpression(lhs, rhs, "+")

internal/jet/range_expression.go

@@ -0,0 +1,95 @@
+package jet
+
+// Range Expression is interface for date range types
+type Range[T Expression] interface {
+	Expression
+
+	EQ(rhs Range[T]) BoolExpression
+	NOT_EQ(rhs Range[T]) BoolExpression
+
+	LT(rhs Range[T]) BoolExpression
+	LT_EQ(rhs Range[T]) BoolExpression
+	GT(rhs Range[T]) BoolExpression
+	GT_EQ(rhs Range[T]) BoolExpression
+
+	CONTAINS(rhs T) BoolExpression
+	CONTAINS_RANGE(rhs Range[T]) BoolExpression
+	OVERLAP(rhs Range[T]) BoolExpression
+	UNION(rhs Range[T]) Range[T]
+	INTERSECTION(rhs Range[T]) Range[T]
+	DIFFERENCE(rhs Range[T]) Range[T]
+}
+
+type rangeInterfaceImpl[T Expression] struct {
+	parent Expression
+}
+
+func (r *rangeInterfaceImpl[T]) EQ(rhs Range[T]) BoolExpression {
+	return Eq(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) NOT_EQ(rhs Range[T]) BoolExpression {
+	return NotEq(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) LT(rhs Range[T]) BoolExpression {
+	return Lt(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) LT_EQ(rhs Range[T]) BoolExpression {
+	return LtEq(r.parent, rhs)
+
+}
+
+func (r *rangeInterfaceImpl[T]) GT(rhs Range[T]) BoolExpression {
+	return Gt(r.parent, rhs)
+
+}
+
+func (r *rangeInterfaceImpl[T]) GT_EQ(rhs Range[T]) BoolExpression {
+	return GtEq(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) CONTAINS(rhs T) BoolExpression {
+	return Contains(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) CONTAINS_RANGE(rhs Range[T]) BoolExpression {
+	return Contains(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) OVERLAP(rhs Range[T]) BoolExpression {
+	return Overlap(r.parent, rhs)
+}
+
+func (r *rangeInterfaceImpl[T]) UNION(rhs Range[T]) Range[T] {
+	return RangeExp[T](Add(r.parent, rhs))
+}
+
+func (r *rangeInterfaceImpl[T]) INTERSECTION(rhs Range[T]) Range[T] {
+	return RangeExp[T](Mul(r.parent, rhs))
+}
+
+func (r *rangeInterfaceImpl[T]) DIFFERENCE(rhs Range[T]) Range[T] {
+	return RangeExp[T](Sub(r.parent, rhs))
+}
+
+//---------------------------------------------------//
+
+type rangeExpressionWrapper[T Expression] struct {
+	rangeInterfaceImpl[T]
+	Expression
+}
+
+func newRangeExpressionWrap[T Expression](expression Expression) Range[T] {
+	rangeExpressionWrap := rangeExpressionWrapper[T]{Expression: expression}
+	rangeExpressionWrap.rangeInterfaceImpl.parent = &rangeExpressionWrap
+	return &rangeExpressionWrap
+}
+
+// RangeExp is range expression wrapper around arbitrary expression.
+// Allows go compiler to see any expression as range expression.
+// Does not add sql cast to generated sql builder output.
+func RangeExp[T Expression](expression Expression) Range[T] {
+	return newRangeExpressionWrap[T](expression)
+}