richer support for where expressions

Author: Andrew Harding

README.md

@@ -452,11 +452,32 @@ read <views> (
 	// "project.id"
 	select <field refs>
 	
-	// a read can have any number of where clauses. the clause refers to a
-	// field, an operation like "!=" or "<=", and another field. if the right
-	// side field is a question mark, the read will fill it in with an argument
-	// and be generated with a parameter for that argument.
-	where <model.field> <op> <model.field or "?">
+	// a read can have any number of where clauses. the clause refers to an
+	// expression, an operation like "!=" or "<=", and another expression. if
+	// the right side field has a placeholder (?), the read will fill it in
+	// with an argument and be generated with a parameter for that argument.
+	//
+	// <expr> can be one of the following:
+	// 1) placeholder
+	//    where animal.name = ?
+	// 2) null
+	//    where animal.name = null
+	// 3) string literal
+	//    where animal.name = "Tiger"
+	// 4) number literal
+	//    where animal.age < 30
+	// 5) model field reference: <model>.<field>
+	//    where animal.height = animal.width
+	// 6) SQL function call: <name>(<expr>)
+	//    where lower(animal.name) = "tiger"
+	//
+	// SQL function calls take an expression for each argument. Currently only
+	// "lower" is implemented.
+	//
+	// <limited-expr> is the same as <expr> except that it can only contain
+	// a model field reference, optionally wrapped in one or more function
+	// calls.
+	where <limited-expr> <op> <expr>
 	
 	// a join describes a join for the read. it brings the right hand side
 	// model into scope for the selects, and the joins must be in a consistent

ast/types.go

@@ -16,6 +16,7 @@ package ast
 
 import (
 	"fmt"
+	"strings"
 	"text/scanner"
 
 	"gopkg.in/spacemonkeygo/dbx.v1/consts"
@@ -241,17 +242,73 @@ func (j *JoinType) Get() consts.JoinType {
 
 type Where struct {
 	Pos   scanner.Position
-	Left  *FieldRef
+	Left  *Expr
 	Op    *Operator
-	Right *FieldRef
+	Right *Expr
 }
 
 func (w *Where) String() string {
-	right := "?"
-	if w.Right != nil {
-		right = w.Right.String()
+	return fmt.Sprintf("%s %s %s", w.Left, w.Op, w.Right)
+}
+
+type Expr struct {
+	Pos scanner.Position
+	// The following fields are mutually exclusive
+	Null        *Null
+	StringLit   *String
+	NumberLit   *String
+	Placeholder *Placeholder
+	FieldRef    *FieldRef
+	FuncCall    *FuncCall
+}
+
+func (e *Expr) String() string {
+	switch {
+	case e.Null != nil:
+		return e.Null.String()
+	case e.StringLit != nil:
+		return fmt.Sprintf("%q", e.StringLit.Value)
+	case e.NumberLit != nil:
+		return e.NumberLit.Value
+	case e.Placeholder != nil:
+		return e.Placeholder.String()
+	case e.FieldRef != nil:
+		return e.FieldRef.String()
+	case e.FuncCall != nil:
+		return e.FuncCall.String()
+	default:
+		return ""
+	}
+}
+
+type Null struct {
+	Pos scanner.Position
+}
+
+func (p *Null) String() string {
+	return "null"
+}
+
+type Placeholder struct {
+	Pos scanner.Position
+}
+
+func (p *Placeholder) String() string {
+	return "?"
+}
+
+type FuncCall struct {
+	Pos  scanner.Position
+	Name *String
+	Args []*Expr
+}
+
+func (f *FuncCall) String() string {
+	var args []string
+	for _, arg := range f.Args {
+		args = append(args, arg.String())
 	}
-	return fmt.Sprintf("%s %s %s", w.Left, w.Op, right)
+	return fmt.Sprintf("%s(%s)", f.Name.Value, strings.Join(args, ", "))
 }
 
 type Operator struct {

code/golang/delete.go

@@ -28,7 +28,7 @@ type Delete struct {
 }
 
 func DeleteFromIR(ir_del *ir.Delete, dialect sql.Dialect) *Delete {
-	delete_sql := sql.DeleteSQL(ir_del)
+	delete_sql := sql.DeleteSQL(ir_del, dialect)
 	del := &Delete{
 		PartitionedArgs: PartitionedArgsFromWheres(ir_del.Where),
 		Info:            sqlembedgo.Embed("__", delete_sql),

code/golang/get.go

@@ -32,7 +32,7 @@ type Get struct {
 }
 
 func GetFromIR(ir_read *ir.Read, dialect sql.Dialect) *Get {
-	select_sql := sql.SelectSQL(ir_read)
+	select_sql := sql.SelectSQL(ir_read, dialect)
 	get := &Get{
 		PartitionedArgs: PartitionedArgsFromWheres(ir_read.Where),
 		Info:            sqlembedgo.Embed("__", select_sql),

code/golang/renderer.go

@@ -440,7 +440,7 @@ func (r *Renderer) renderDeleteWorld(w io.Writer, ir_models []*ir.Model,
 	for i := len(ir_models) - 1; i >= 0; i-- {
 		sql := sqlgen.Render(dialect, sql.DeleteSQL(&ir.Delete{
 			Model: ir_models[i],
-		}))
+		}, dialect))
 		del.SQLs = append(del.SQLs, sql)
 	}
 

code/golang/update.go

@@ -55,7 +55,7 @@ func UpdateFromIR(ir_upd *ir.Update, dialect sql.Dialect) *Update {
 			Joins:       ir_upd.Joins,
 			Where:       ir_upd.Where,
 			View:        ir.All,
-		})
+		}, dialect)
 		upd.InfoGet = sqlembedgo.Embed("__", select_sql)
 	}
 

code/golang/var.go

@@ -18,6 +18,7 @@ import (
 	"fmt"
 
 	"bitbucket.org/pkg/inflect"
+	"gopkg.in/spacemonkeygo/dbx.v1/consts"
 	"gopkg.in/spacemonkeygo/dbx.v1/ir"
 )
 
@@ -74,16 +75,25 @@ func ArgFromField(field *ir.Field) *Var {
 }
 
 func ArgFromWhere(where *ir.Where) *Var {
-	name := where.Left.UnderRef()
-	if suffix := where.Op.Suffix(); suffix != "" {
-		name += "_" + suffix
+	// TODO: clean this up when we do full expression type evaluation.
+	// assume for now that the left hand side evaluates eventually to a single
+	// field wrapped in zero or more function calls since that is all that is
+	// possible via the xform package.
+	expr := where.Left
+	for expr.Field == nil {
+		expr = expr.FuncCall.Args[0]
+	}
+
+	name := expr.Field.UnderRef()
+	if where.Op != consts.EQ {
+		name += "_" + where.Op.Suffix()
 	}
 
 	// we don't set ZeroVal or InitVal because these args should only be used
 	// as incoming arguments to function calls.
 	return &Var{
 		Name: name,
-		Type: ModelFieldFromIR(where.Left).StructName(),
+		Type: ModelFieldFromIR(expr.Field).StructName(),
 	}
 }
 

code/golang/where.go

@@ -24,14 +24,14 @@ type PartitionedArgs struct {
 
 func PartitionedArgsFromWheres(wheres []*ir.Where) (out PartitionedArgs) {
 	for _, where := range wheres {
-		if where.Right != nil {
+		if !where.Right.HasPlaceholder() {
 			continue
 		}
 
 		arg := ArgFromWhere(where)
 		out.AllArgs = append(out.AllArgs, arg)
 
-		if where.Nullable() {
+		if where.NeedsCondition() {
 			out.NullableArgs = append(out.NullableArgs, arg)
 		} else {
 			out.StaticArgs = append(out.StaticArgs, arg)

compile_test.go

@@ -11,6 +11,7 @@ import (
 	"io/ioutil"
 	"os"
 	"path/filepath"
+	"runtime/debug"
 	"testing"
 
 	"gopkg.in/spacemonkeygo/dbx.v1/testutil"
@@ -37,7 +38,7 @@ func TestCompilation(t *testing.T) {
 func testFile(t *testutil.T, file string) {
 	defer func() {
 		if val := recover(); val != nil {
-			t.Fatal(val)
+			t.Fatalf("%s\n%s", val, string(debug.Stack()))
 		}
 	}()
 
@@ -57,18 +58,22 @@ func testFile(t *testutil.T, file string) {
 	}
 
 	runBuild := func(rx, userdata bool) {
+		t.Logf("[%s] generating... (rx=%t, userdata=%t)", file, rx, userdata)
 		err = golangCmd("", dialects, "", rx, userdata, file, dir)
 		t.AssertNoError(err)
 
+		t.Logf("[%s] loading...", file)
 		go_file := filepath.Join(dir, filepath.Base(file)+".go")
 		go_source, err := ioutil.ReadFile(go_file)
 		t.AssertNoError(err)
 		t.Context("go", linedSource(go_source))
 
+		t.Logf("[%s] parsing...", file)
 		fset := token.NewFileSet()
 		f, err := parser.ParseFile(fset, go_file, go_source, parser.AllErrors)
 		t.AssertNoError(err)
 
+		t.Logf("[%s] compiling...", file)
 		config := types.Config{
 			Importer: importer.Default(),
 		}

consts/consts.go

@@ -45,7 +45,7 @@ func (o Operator) Suffix() string {
 	case GE:
 		return "greater_or_equal"
 	case EQ:
-		return ""
+		return "equal"
 	case NE:
 		return "not"
 	case Like:

ir/expr.go

@@ -0,0 +1,74 @@
+// Copyright (C) 2017 Space Monkey, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package ir
+
+type Expr struct {
+	Null        bool
+	Placeholder bool
+	StringLit   *string
+	NumberLit   *string
+	Field     *Field
+	FuncCall    *FuncCall
+}
+
+func (e *Expr) Nullable() bool {
+	switch {
+	case e.Null, e.Placeholder:
+		return true
+	case e.Field != nil:
+		return e.Field.Nullable
+	case e.FuncCall != nil:
+		return e.FuncCall.Nullable()
+	default:
+		return false
+	}
+}
+
+func (e *Expr) HasPlaceholder() bool {
+	if e.Placeholder {
+		return true
+	}
+	if e.FuncCall != nil {
+		return e.FuncCall.HasPlaceholder()
+	}
+	return false
+}
+
+func (e *Expr) Unique() bool {
+	return e.Field != nil && e.Field.Unique()
+}
+
+type FuncCall struct {
+	Name string
+	Args []*Expr
+}
+
+func (fc *FuncCall) Nullable() bool {
+	for _, arg := range fc.Args {
+		if arg.Nullable() {
+			return true
+		}
+	}
+	return false
+}
+
+func (fc *FuncCall) HasPlaceholder() bool {
+	for _, arg := range fc.Args {
+		if arg.HasPlaceholder() {
+			return true
+		}
+	}
+	return false
+}

ir/helpers.go

@@ -59,10 +59,19 @@ func fieldSetPrune(all, bad []*Field) (out []*Field) {
 
 func whereUnique(wheres []*Where) (unique map[string]bool) {
 	fields := map[*Model][]*Field{}
-	for _, eq := range FilterWhere(wheres, consts.EQ) {
-		fields[eq.Left.Model] = append(fields[eq.Left.Model], eq.Left)
-		if eq.Right != nil {
-			fields[eq.Right.Model] = append(fields[eq.Right.Model], eq.Right)
+	for _, where := range wheres {
+		if where.Op != consts.EQ {
+			continue
+		}
+
+		left := where.Left.Field
+		right := where.Right.Field
+
+		if left != nil {
+			fields[left.Model] = append(fields[left.Model], left)
+		}
+		if right != nil {
+			fields[right.Model] = append(fields[right.Model], left)
 		}
 	}