Merge branch 'master' into fargate

Author: els-tmiller

embedded/sql/engine_test.go

@@ -3202,6 +3202,69 @@ func TestQuery(t *testing.T) {
 	})
 }
 
+func TestExtractFromTimestamp(t *testing.T) {
+	st, err := store.Open(t.TempDir(), store.DefaultOptions().WithMultiIndexing(true))
+	require.NoError(t, err)
+	defer closeStore(t, st)
+
+	engine, err := NewEngine(st, DefaultOptions().WithPrefix(sqlPrefix))
+	require.NoError(t, err)
+
+	t.Run("extract from constant expressions", func(t *testing.T) {
+		assertQueryShouldProduceResults(
+			t,
+			engine,
+			`SELECT
+			EXTRACT(YEAR FROM '2020-01-15'),
+			EXTRACT(MONTH FROM '2020-01-15'),
+			EXTRACT(DAY FROM '2020-01-15'::TIMESTAMP),
+			EXTRACT(HOUR FROM '2020-01-15 12:30:24'),
+			EXTRACT(MINUTE FROM '2020-01-15 12:30:24'),
+			EXTRACT(SECOND FROM '2020-01-15 12:30:24'::TIMESTAMP)
+		`,
+			`SELECT * FROM (
+			VALUES (2020, 01, 15, 12, 30, 24)
+		)`,
+		)
+	})
+
+	t.Run("extract from table", func(t *testing.T) {
+		_, _, err := engine.Exec(
+			context.Background(),
+			nil,
+			`CREATE TABLE events(ts TIMESTAMP PRIMARY KEY);
+
+			INSERT INTO events(ts) VALUES
+				('2021-07-04 14:45:30'::TIMESTAMP),
+				('1999-12-31 23:59:59'::TIMESTAMP);
+			`,
+			nil,
+		)
+		require.NoError(t, err)
+
+		assertQueryShouldProduceResults(
+			t,
+			engine,
+			`SELECT
+				EXTRACT(YEAR FROM ts),
+				EXTRACT(MONTH FROM ts),
+				EXTRACT(DAY FROM ts),
+				EXTRACT(HOUR FROM ts),
+				EXTRACT(MINUTE FROM ts),
+				EXTRACT(SECOND FROM ts)
+			FROM events
+			ORDER BY ts
+			`,
+			`SELECT * FROM (
+				VALUES
+					(1999, 12, 31, 23, 59, 59),
+					(2021, 07, 04, 14, 45, 30)
+			)`,
+		)
+	})
+
+}
+
 func TestJSON(t *testing.T) {
 	opts := store.DefaultOptions().WithMultiIndexing(true)
 	opts.WithIndexOptions(opts.IndexOpts.WithMaxActiveSnapshots(1))
@@ -9450,6 +9513,51 @@ func TestFunctions(t *testing.T) {
 	)
 	require.NoError(t, err)
 
+	t.Run("coalesce", func(t *testing.T) {
+		type testCase struct {
+			query          string
+			expectedValues string
+			err            error
+		}
+
+		cases := []testCase{
+			{
+				query:          "SELECT COALESCE (NULL)",
+				expectedValues: "NULL",
+			},
+			{
+				query:          "SELECT COALESCE (NULL, NULL)",
+				expectedValues: "NULL",
+			},
+			{
+				query:          "SELECT COALESCE(NULL, 1, 1.5, 3)",
+				expectedValues: "1",
+			},
+			{
+				query:          "SELECT COALESCE('one', 'two', 'three')",
+				expectedValues: "'one'",
+			},
+			{
+				query: "SELECT COALESCE(1, 'test')",
+				err:   ErrInvalidTypes,
+			},
+		}
+
+		for _, tc := range cases {
+			if tc.err != nil {
+				_, err := engine.queryAll(context.Background(), nil, tc.query, nil)
+				require.ErrorIs(t, err, tc.err)
+				continue
+			}
+
+			assertQueryShouldProduceResults(
+				t,
+				engine,
+				tc.query,
+				fmt.Sprintf("SELECT * FROM (VALUES (%s))", tc.expectedValues))
+		}
+	})
+
 	t.Run("timestamp functions", func(t *testing.T) {
 		_, err := engine.queryAll(context.Background(), nil, "SELECT NOW(1) FROM mytable", nil)
 		require.ErrorIs(t, err, ErrIllegalArguments)

embedded/sql/functions.go

@@ -25,6 +25,7 @@ import (
 )
 
 const (
+	CoalesceFnCall           string = "COALESCE"
 	LengthFnCall             string = "LENGTH"
 	SubstringFnCall          string = "SUBSTRING"
 	ConcatFnCall             string = "CONCAT"
@@ -47,6 +48,7 @@ const (
 )
 
 var builtinFunctions = map[string]Function{
+	CoalesceFnCall:           &CoalesceFn{},
 	LengthFnCall:             &LengthFn{},
 	SubstringFnCall:          &SubstringFn{},
 	ConcatFnCall:             &ConcatFn{},
@@ -67,6 +69,37 @@ type Function interface {
 	Apply(tx *SQLTx, params []TypedValue) (TypedValue, error)
 }
 
+type CoalesceFn struct{}
+
+func (f *CoalesceFn) InferType(cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) (SQLValueType, error) {
+	return AnyType, nil
+}
+
+func (f *CoalesceFn) RequiresType(t SQLValueType, cols map[string]ColDescriptor, params map[string]SQLValueType, implicitTable string) error {
+	return nil
+}
+
+func (f *CoalesceFn) Apply(tx *SQLTx, params []TypedValue) (TypedValue, error) {
+	t := AnyType
+
+	for _, p := range params {
+		if !p.IsNull() {
+			if t == AnyType {
+				t = p.Type()
+			} else if p.Type() != t && !(IsNumericType(t) && IsNumericType(p.Type())) {
+				return nil, fmt.Errorf("coalesce: %w", ErrInvalidTypes)
+			}
+		}
+	}
+
+	for _, p := range params {
+		if !p.IsNull() {
+			return p, nil
+		}
+	}
+	return NewNull(t), nil
+}
+
 // -------------------------------------
 // String Functions
 // -------------------------------------

embedded/sql/parser.go

@@ -28,7 +28,7 @@ import (
 
 //go:generate go run golang.org/x/tools/cmd/goyacc -l -o sql_parser.go sql_grammar.y
 
-var reservedWords = map[string]int{
+var keywords = map[string]int{
 	"CREATE":         CREATE,
 	"DROP":           DROP,
 	"USE":            USE,
@@ -118,6 +118,21 @@ var reservedWords = map[string]int{
 	"THEN":           THEN,
 	"ELSE":           ELSE,
 	"END":            END,
+	"EXTRACT":        EXTRACT,
+	"INTEGER":        INTEGER_TYPE,
+	"BOOLEAN":        BOOLEAN_TYPE,
+	"VARCHAR":        VARCHAR_TYPE,
+	"TIMESTAMP":      TIMESTAMP_TYPE,
+	"FLOAT":          FLOAT_TYPE,
+	"BLOB":           BLOB_TYPE,
+	"UUID":           UUID_TYPE,
+	"JSON":           JSON_TYPE,
+	"YEAR":           YEAR,
+	"MONTH":          MONTH,
+	"DAY":            DAY,
+	"HOUR":           HOUR,
+	"MINUTE":         MINUTE,
+	"SECOND":         SECOND,
 }
 
 var joinTypes = map[string]JoinType{
@@ -126,17 +141,6 @@ var joinTypes = map[string]JoinType{
 	"RIGHT": RightJoin,
 }
 
-var types = map[string]SQLValueType{
-	"INTEGER":   IntegerType,
-	"BOOLEAN":   BooleanType,
-	"VARCHAR":   VarcharType,
-	"UUID":      UUIDType,
-	"BLOB":      BLOBType,
-	"TIMESTAMP": TimestampType,
-	"FLOAT":     Float64Type,
-	"JSON":      JSONType,
-}
-
 var aggregateFns = map[string]AggregateFn{
 	"COUNT": COUNT,
 	"SUM":   SUM,
@@ -321,7 +325,7 @@ func (l *lexer) Lex(lval *yySymType) int {
 		}
 
 		lval.blob = val
-		return BLOB
+		return BLOB_LIT
 	}
 
 	if isLetter(ch) {
@@ -334,16 +338,10 @@ func (l *lexer) Lex(lval *yySymType) int {
 		w := fmt.Sprintf("%c%s", ch, tail)
 		tid := strings.ToUpper(w)
 
-		sqlType, ok := types[tid]
-		if ok {
-			lval.sqlType = sqlType
-			return TYPE
-		}
-
 		val, ok := boolValues[tid]
 		if ok {
 			lval.boolean = val
-			return BOOLEAN
+			return BOOLEAN_LIT
 		}
 
 		afn, ok := aggregateFns[tid]
@@ -358,13 +356,13 @@ func (l *lexer) Lex(lval *yySymType) int {
 			return JOINTYPE
 		}
 
-		tkn, ok := reservedWords[tid]
+		tkn, ok := keywords[tid]
 		if ok {
+			lval.keyword = w
 			return tkn
 		}
 
 		lval.id = strings.ToLower(w)
-
 		return IDENTIFIER
 	}
 
@@ -409,7 +407,7 @@ func (l *lexer) Lex(lval *yySymType) int {
 			}
 
 			lval.float = val
-			return FLOAT
+			return FLOAT_LIT
 		}
 
 		val, err := strconv.ParseUint(fmt.Sprintf("%c%s", ch, tail), 10, 64)
@@ -419,7 +417,7 @@ func (l *lexer) Lex(lval *yySymType) int {
 		}
 
 		lval.integer = val
-		return INTEGER
+		return INTEGER_LIT
 	}
 
 	if isComparison(ch) {
@@ -452,7 +450,7 @@ func (l *lexer) Lex(lval *yySymType) int {
 		}
 
 		lval.str = tail
-		return VARCHAR
+		return VARCHAR_LIT
 	}
 
 	if ch == ':' {
@@ -566,7 +564,7 @@ func (l *lexer) Lex(lval *yySymType) int {
 				return ERROR
 			}
 			lval.float = val
-			return FLOAT
+			return FLOAT_LIT
 		}
 		return DOT
 	}
@@ -681,3 +679,35 @@ func isDoubleQuote(ch byte) bool {
 func isDot(ch byte) bool {
 	return ch == '.'
 }
+
+func newCreateTableStmt(
+	name string,
+	elems []TableElem,
+	ifNotExists bool,
+) *CreateTableStmt {
+	colsSpecs := make([]*ColSpec, 0, 5)
+	var checks []CheckConstraint
+
+	var pk PrimaryKeyConstraint
+	for _, e := range elems {
+		switch c := e.(type) {
+		case *ColSpec:
+			colsSpecs = append(colsSpecs, c)
+		case PrimaryKeyConstraint:
+			pk = c
+		case CheckConstraint:
+			if checks == nil {
+				checks = make([]CheckConstraint, 0, 5)
+			}
+			checks = append(checks, c)
+		}
+	}
+
+	return &CreateTableStmt{
+		ifNotExists: ifNotExists,
+		table:       name,
+		colsSpec:    colsSpecs,
+		pkColNames:  pk,
+		checks:      checks,
+	}
+}