Add UPPER function

cmd/genji/doc/functions.go

@@ -3,6 +3,7 @@ package doc
 type functionDocs map[string]string
 
 var packageDocs = map[string]functionDocs{
+	"strings": stringsDocs,
 	"math": mathDocs,
 	"":     builtinDocs,
 }
@@ -16,7 +17,6 @@ var builtinDocs = functionDocs{
 	"avg":    "The avg function returns the average of all values taken by the arg1 expression in a group.",
 	"typeof": "The typeof function returns the type of arg1.",
 	"len":    "The len function returns length of the arg1 expression if arg1 evals to string, array or document, either returns NULL.",
-	"lower":  "The lower function returns arg1 to lower-case if arg1 evals to string",
 }
 
 var mathDocs = functionDocs{
@@ -29,3 +29,8 @@ var mathDocs = functionDocs{
 	"atan2": "Returns the arctangent of arg1/arg2, using the signs of the two to determine the quadrant of the return value.",
 	"floor": "Returns the greatest integer value less than or equal to arg1.",
 }
+
+var stringsDocs = functionDocs{
+	"lower":  "The lower function returns arg1 to lower-case if arg1 evals to string",
+	"upper":  "The upper function returns arg1 to upper-case if arg1 evals to string",
+}

internal/expr/functions/builtins.go

@@ -2,7 +2,6 @@ package functions
 
 import (
 	"fmt"
-	"strings"
 
 	"github.com/cockroachdb/errors"
 	"github.com/genjidb/genji/document"
@@ -68,13 +67,6 @@ var builtinFunctions = Definitions{
 			return &Len{Expr: args[0]}, nil
 		},
 	},
-	"lower": &definition{
-		name: "lower",
-		arity: 1,
-		constructorFn: func(args ...expr.Expr) (expr.Function, error) {
-			return &Lower{Expr: args[0]}, nil
-		},
-	},
 }
 
 // BuiltinDefinitions returns a map of builtin functions.
@@ -724,44 +716,4 @@ func (s *Len) Params() []expr.Expr { return []expr.Expr{s.Expr} }
 // String returns the literal representation of len.
 func (s *Len) String() string {
 	return fmt.Sprintf("LEN(%v)", s.Expr)
-}
-
-// Lower is the LOWER function
-// It returns the lower-case version of a string
-type Lower struct {
-	Expr expr.Expr
-}
-
-func (s* Lower) Eval(env *environment.Environment) (types.Value, error) {
-	val, err := s.Expr.Eval(env)
-	if err != nil {
-		return nil, err
-	}
-
-	if val.Type() != types.TextValue {
-		return types.NewNullValue(), nil
-	}
-
-	lowerCaseString := strings.ToLower(types.As[string](val))
-
-	return types.NewTextValue(lowerCaseString), nil
-}
-
-func (s *Lower) IsEqual(other expr.Expr) bool {
-	if other == nil {
-		return false
-	}
-
-	o, ok := other.(*Lower)
-	if !ok {
-		return false
-	}
-
-	return expr.Equal(s.Expr, o.Expr)
-}
-
-func (s *Lower) Params() []expr.Expr { return []expr.Expr{s.Expr} }
-
-func (s *Lower) String() string {
-	return fmt.Sprintf("LOWER(%v)", s.Expr)
 }

internal/expr/functions/definition.go

@@ -25,6 +25,7 @@ func DefaultPackages() Packages {
 	return Packages{
 		"":     BuiltinDefinitions(),
 		"math": MathFunctions(),
+		"strings": StringsDefinitions(),
 	}
 }
 

internal/expr/functions/strings.go

@@ -0,0 +1,111 @@
+package functions
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/genjidb/genji/internal/environment"
+	"github.com/genjidb/genji/internal/expr"
+	"github.com/genjidb/genji/types"
+)
+
+var stringsFunctions = Definitions{
+	"lower": &definition{
+		name:  "lower",
+		arity: 1,
+		constructorFn: func(args ...expr.Expr) (expr.Function, error) {
+			return &Lower{Expr: args[0]}, nil
+		},
+	},
+	"upper": &definition{
+		name:  "upper",
+		arity: 1,
+		constructorFn: func(args ...expr.Expr) (expr.Function, error) {
+			return &Upper{Expr: args[0]}, nil
+		},
+	},
+}
+
+func StringsDefinitions() Definitions {
+	return stringsFunctions
+}
+
+// Lower is the LOWER function
+// It returns the lower-case version of a string
+type Lower struct {
+	Expr expr.Expr
+}
+
+func (s *Lower) Eval(env *environment.Environment) (types.Value, error) {
+	val, err := s.Expr.Eval(env)
+	if err != nil {
+		return nil, err
+	}
+
+	if val.Type() != types.TextValue {
+		return types.NewNullValue(), nil
+	}
+
+	lowerCaseString := strings.ToLower(types.As[string](val))
+
+	return types.NewTextValue(lowerCaseString), nil
+}
+
+func (s *Lower) IsEqual(other expr.Expr) bool {
+	if other == nil {
+		return false
+	}
+
+	o, ok := other.(*Lower)
+	if !ok {
+		return false
+	}
+
+	return expr.Equal(s.Expr, o.Expr)
+}
+
+func (s *Lower) Params() []expr.Expr { return []expr.Expr{s.Expr} }
+
+func (s *Lower) String() string {
+	return fmt.Sprintf("LOWER(%v)", s.Expr)
+}
+
+// Upper is the UPPER function
+// It returns the upper-case version of a string
+type Upper struct {
+	Expr expr.Expr
+}
+
+func (s *Upper) Eval(env *environment.Environment) (types.Value, error) {
+	val, err := s.Expr.Eval(env)
+	if err != nil {
+		return nil, err
+	}
+
+	if val.Type() != types.TextValue {
+		return types.NewNullValue(), nil
+	}
+
+	upperCaseString := strings.ToUpper(types.As[string](val))
+
+	return types.NewTextValue(upperCaseString), nil
+}
+
+func (s *Upper) IsEqual(other expr.Expr) bool {
+	if other == nil {
+		return false
+	}
+
+	o, ok := other.(*Upper)
+	if !ok {
+		return false
+	}
+
+	return expr.Equal(s.Expr, o.Expr)
+}
+
+func (s *Upper) Params() []expr.Expr { return []expr.Expr{s.Expr} }
+
+func (s *Upper) String() string {
+	return fmt.Sprintf("UPPER(%v)", s.Expr)
+}

sqltests/SELECT/lower.sql → sqltests/SELECT/STRINGS/lower.sql

@@ -23,7 +23,7 @@ INSERT INTO test (a, b, c, d, e, f) VALUES (
 );
 
 -- test: TEXT value
-SELECT LOWER(a) FROM test;
+SELECT strings.LOWER(a) FROM test;
 /* result:
 {
     "LOWER(a)": "foo" 
@@ -32,7 +32,7 @@ SELECT LOWER(a) FROM test;
 
 
 -- test: INT value
-SELECT LOWER(b) FROM test;
+SELECT strings.LOWER(b) FROM test;
 /* result:
 {
     "LOWER(b)": NULL 
@@ -41,71 +41,71 @@ SELECT LOWER(b) FROM test;
 
 
 -- test: BOOL value
-SELECT LOWER(c) FROM test;
+SELECT strings.LOWER(c) FROM test;
 /* result:
 {
     "LOWER(c)": NULL 
 }
 */
 
 -- test: DOUBLE value
-SELECT LOWER(d) FROM test;
+SELECT strings.LOWER(d) FROM test;
 /* result:
 {
     "LOWER(d)": NULL 
 }
 */
 
 -- test: ARRAY value
-SELECT LOWER(e) FROM test;
+SELECT strings.LOWER(e) FROM test;
 /* result:
 {
     "LOWER(e)": NULL 
 }
 */
 
 -- test: DOCUMENT value
-SELECT LOWER(f) FROM test;
+SELECT strings.LOWER(f) FROM test;
 /* result:
 {
     "LOWER(f)": NULL 
 }
 */
 
 -- test: cast INT
-SELECT LOWER(CAST(b as TEXT)) FROM test;
+SELECT strings.LOWER(CAST(b as TEXT)) FROM test;
 /* result:
 {
     "LOWER(CAST(b AS text))": "42" 
 }
 */
 
 -- test: cast BOOL
-SELECT LOWER(CAST(c as TEXT)) FROM test;
+SELECT strings.LOWER(CAST(c as TEXT)) FROM test;
 /* result:
 {
     "LOWER(CAST(c AS text))": "true" 
 }
 */
 
 -- test: cast DOUBLE
-SELECT LOWER(CAST(d as TEXT)) FROM test;
+SELECT strings.LOWER(CAST(d as TEXT)) FROM test;
 /* result:
 {
     "LOWER(CAST(d AS text))": "42.42" 
 }
 */
 
 -- test: cast ARRAY
-SELECT LOWER(CAST(e as TEXT)) FROM test;
+SELECT strings.LOWER(CAST(e as TEXT)) FROM test;
 /* result:
 {
     "LOWER(CAST(e AS text))": "[\"a\", \"b\", \"c\", \"d\", \"e\"]" 
 }
 */
 
 -- test: cast DOCUMENT
-SELECT LOWER(CAST(f as TEXT)) FROM test;
+SELECT strings.LOWER(CAST(f as TEXT)) FROM test;
 /* result:
 {
     "LOWER(CAST(f AS text))": "{\"a\": \"hello\", \"b\": \"world\"}"