Merge pull request #11 from vilterp/bool-ops

Bool ops

Author: vilterp

pkg/client.go

@@ -4,8 +4,11 @@ package treesql
 // this should pretty much be the same API as TreeSQLClient.js
 
 import (
+	"fmt"
 	"log"
 
+	"encoding/json"
+
 	"github.com/gorilla/websocket"
 	"github.com/pkg/errors"
 )
@@ -100,10 +103,11 @@ func (conn *Client) handleIncoming() {
 	defer conn.webSocketConn.Close()
 	for {
 		parsedMessage := &BasicChannelMessage{}
-		err := conn.webSocketConn.ReadJSON(&parsedMessage)
+		_, rawMsg, err := conn.webSocketConn.ReadMessage()
+		json.Unmarshal(rawMsg, parsedMessage)
 
 		if err != nil {
-			log.Println("error in handleIncoming:", err)
+			log.Println("error in handleIncoming: ReadJSON:", err)
 			close(conn.incomingMessages)
 			conn.ServerClosed <- true
 			return
@@ -140,19 +144,22 @@ func (conn *Client) LiveQuery(query string) (*basicInitialResult, *ClientChannel
 	if update.InitialResultMessage != nil {
 		return update.InitialResultMessage, channel, nil
 	}
-	return nil, nil, errors.New("query result neither error nor initial result")
+	return nil, nil, fmt.Errorf("query result neither error nor initial result")
 }
 
 func (conn *Client) Query(query string) (*basicInitialResult, error) {
 	resultChan := conn.RunStatement(query)
 	update := <-resultChan.Updates
+	if update == nil {
+		return nil, fmt.Errorf("update is nil")
+	}
 	if update.ErrorMessage != nil {
 		return nil, errors.New(*update.ErrorMessage)
 	}
 	if update.InitialResultMessage != nil {
 		return update.InitialResultMessage, nil
 	}
-	return nil, errors.New("query result neither error nor initial result")
+	return nil, fmt.Errorf("query result neither error nor initial result")
 }
 
 func (conn *Client) Exec(statement string) (string, error) {
@@ -163,5 +170,5 @@ func (conn *Client) Exec(statement string) (string, error) {
 	} else if update.AckMessage != nil {
 		return *update.AckMessage, nil
 	}
-	return "", errors.New("exec result neither error nor ack")
+	return "", fmt.Errorf("exec result neither error nor ack")
 }

pkg/connection.go

@@ -50,13 +50,13 @@ func (conn *connection) writeMessagesToSocket() {
 		bufWriter := bufio.NewWriter(writer)
 
 		if err := msg.toVal().WriteAsJSON(bufWriter, msg.getCaller()); err != nil {
-			clog.Println(conn, "error writing msg to conn:", err)
+			clog.Println(conn, "error writing msg to conn: writing value: ", err)
 		}
 		if err := bufWriter.Flush(); err != nil {
-			clog.Println(conn, "error writing msg to conn:", err)
+			clog.Println(conn, "error writing msg to conn: flusing buffer: ", err)
 		}
 		if err := writer.Close(); err != nil {
-			clog.Println(conn, "error writing msg to conn:", err)
+			clog.Println(conn, "error writing msg to conn: closing writer: ", err)
 		}
 	}
 }

pkg/lang/builtins.go

@@ -36,6 +36,47 @@ func init() {
 			}, nil
 		},
 	})
+	BuiltinsScope.Add("filter", &VBuiltin{
+		Name: "filter",
+		Params: []Param{
+			{"iter", NewTIterator(NewTVar("A"))},
+			{"func", &tFunction{
+				params:  []Param{{"x", NewTVar("A")}},
+				retType: TBool,
+			}},
+		},
+		RetType: NewTIterator(NewTVar("A")),
+		Impl: func(interp Caller, args []Value) (Value, error) {
+			f := mustBeVFunction(args[1])
+			return &VIteratorRef{
+				iterator: &filterIterator{
+					innerIterator: mustBeVIteratorRef(args[0]).iterator,
+					f:             f,
+				},
+				ofType: f.GetRetType(),
+			}, nil
+		},
+	})
+	BuiltinsScope.Add("strEq", &VBuiltin{
+		Name:    "strEq",
+		Params:  []Param{{"a", TString}, {"b", TString}},
+		RetType: TBool,
+		Impl: func(interp Caller, args []Value) (Value, error) {
+			left := mustBeVString(args[0])
+			right := mustBeVString(args[1])
+			return NewVBool(left == right), nil
+		},
+	})
+	BuiltinsScope.Add("intEq", &VBuiltin{
+		Name:    "intEq",
+		Params:  []Param{{"a", TInt}, {"b", TInt}},
+		RetType: TBool,
+		Impl: func(interp Caller, args []Value) (Value, error) {
+			left := mustBeVInt(args[0])
+			right := mustBeVInt(args[1])
+			return NewVBool(left == right), nil
+		},
+	})
 
 	BuiltinsTypeScope = BuiltinsScope.toTypeScope()
 }

pkg/lang/expr.go

@@ -360,7 +360,9 @@ func (ma *EMemberAccess) Evaluate(interp *interpreter) (Value, error) {
 		}
 		return val, nil
 	default:
-		return nil, fmt.Errorf("member access on a non-record: %s", ma.Format())
+		return nil, fmt.Errorf(
+			"member access on a non-record: %s value: %s", ma.Format(), recVal,
+		)
 	}
 }
 

pkg/lang/interpreter_test.go

@@ -108,6 +108,29 @@ func TestInterpreter(t *testing.T) {
 			typ: TInt,
 			val: "7",
 		},
+		// Equality functions
+		{
+			expr: &EFuncCall{
+				funcName: "strEq",
+				args: []Expr{
+					NewStringLit("foo"),
+					NewStringLit("foo"),
+				},
+			},
+			typ: TBool,
+			val: "true",
+		},
+		{
+			expr: &EFuncCall{
+				funcName: "intEq",
+				args: []Expr{
+					NewIntLit(4),
+					NewIntLit(5),
+				},
+			},
+			typ: TBool,
+			val: "false",
+		},
 	}
 
 	typeScope := userRootScope.toTypeScope()

pkg/lang/iterator.go

@@ -30,6 +30,46 @@ func (mi *mapIterator) Close() error {
 	return mi.innerIterator.Close()
 }
 
+// Filter iterator
+
+type filterIterator struct {
+	innerIterator Iterator
+	f             vFunction
+}
+
+func (fi *filterIterator) Next(c Caller) (Value, error) {
+	for {
+		// Get the next value.
+		next, err := fi.innerIterator.Next(c)
+		var isEOE bool
+		switch err.(type) {
+		case *endOfIteration:
+			isEOE = true
+		default:
+			if err != nil {
+				return nil, err
+			}
+		}
+		// Check for end of iteration.
+		if isEOE {
+			return nil, EndOfIteration
+		}
+		// Call the func.
+		res, err := c.Call(fi.f, []Value{next})
+		if err != nil {
+			return nil, err
+		}
+		// Return the val if true.
+		if *mustBeVBool(res) {
+			return next, nil
+		}
+	}
+}
+
+func (fi *filterIterator) Close() error {
+	return fi.innerIterator.Close()
+}
+
 // Array iterator
 
 type arrayIterator struct {

pkg/lang/type.go

@@ -60,6 +60,23 @@ func (tInt) matches(other Type) (bool, typeVarBindings) {
 
 func (ti *tInt) substitute(typeVarBindings) (Type, bool, error) { return ti, true, nil }
 
+// Bool
+
+type tBool struct{}
+
+var TBool = &tBool{}
+var _ Type = TBool
+
+func (tBool) Format() pp.Doc {
+	return pp.Text("bool")
+}
+
+func (tBool) matches(other Type) (bool, typeVarBindings) {
+	return other == TBool, nil
+}
+
+func (tb *tBool) substitute(typeVarBindings) (Type, bool, error) { return tb, true, nil }
+
 // String
 
 type tString struct{}

pkg/lang/value.go

@@ -51,6 +51,41 @@ func mustBeVInt(v Value) *VInt {
 	return i
 }
 
+// Bool
+
+type VBool bool
+
+var _ Value = NewVBool(false)
+
+func NewVBool(b bool) *VBool {
+	val := VBool(b)
+	return &val
+}
+
+func (v *VBool) Format() pp.Doc {
+	if *v {
+		return pp.Text("true")
+	}
+	return pp.Text("false")
+}
+
+func (v *VBool) GetType() Type {
+	return TBool
+}
+
+func (v *VBool) WriteAsJSON(w *bufio.Writer, _ Caller) error {
+	_, err := w.WriteString(v.Format().String())
+	return err
+}
+
+func mustBeVBool(v Value) *VBool {
+	b, ok := v.(*VBool)
+	if !ok {
+		panic(fmt.Sprintf("not a bool: %s", v.Format()))
+	}
+	return b
+}
+
 // String
 
 type VString string
@@ -143,7 +178,9 @@ func (v *VRecord) WriteAsJSON(w *bufio.Writer, c Caller) error {
 			w.WriteString(",")
 		}
 		w.WriteString(fmt.Sprintf("%#v:", name))
-		val.WriteAsJSON(w, c)
+		if err := val.WriteAsJSON(w, c); err != nil {
+			return err
+		}
 		idx++
 	}
 	w.WriteString("}")

pkg/lang/value_test.go

@@ -57,6 +57,19 @@ func TestWriteAsJSON(t *testing.T) {
 			"[2,3,4]",
 			"",
 		},
+		{
+			&VIteratorRef{
+				ofType:   TInt,
+				iterator: NewArrayIterator([]Value{}),
+			},
+			"[]",
+			"",
+		},
+		{
+			NewVBool(true),
+			"true",
+			"",
+		},
 		{
 			&VBuiltin{},
 			"",

pkg/plan.go

@@ -7,15 +7,44 @@ import (
 )
 
 func (s *schema) planSelect(query *Select) (lang.Expr, error) {
-	if query.Where != nil {
-		return nil, fmt.Errorf("don't know how to plan queries with WHERE yet")
-	}
-
 	tableDesc, ok := s.tables[query.Table]
 	if !ok {
 		return nil, fmt.Errorf("no such table: %s", query.Table)
 	}
 
+	// Scan the table.
+	var innermostExpr lang.Expr
+	innermostExpr = lang.NewMemberAccess(
+		lang.NewMemberAccess(
+			lang.NewMemberAccess(
+				lang.NewVar("tables"),
+				query.Table,
+			),
+			tableDesc.primaryKey,
+		),
+		"scan",
+	)
+
+	if query.Where != nil {
+		innermostExpr = lang.NewFuncCall("filter", []lang.Expr{
+			innermostExpr,
+			lang.NewELambda(
+				[]lang.Param{
+					{
+						Name: "row",
+						Typ:  tableDesc.getType(),
+					},
+				},
+				// TODO: use intEq if it's not a string...
+				lang.NewFuncCall("strEq", []lang.Expr{
+					lang.NewMemberAccess(lang.NewVar("row"), query.Where.ColumnName),
+					lang.NewStringLit(query.Where.Value),
+				}),
+				lang.TBool,
+			),
+		})
+	}
+
 	// Get types and expressions for selectinos.
 	types := map[string]lang.Type{}
 	exprs := map[string]lang.Expr{}
@@ -36,16 +65,7 @@ func (s *schema) planSelect(query *Select) (lang.Expr, error) {
 
 	// Build expression: a scan on the primary key.
 	return lang.NewFuncCall("map", []lang.Expr{
-		lang.NewMemberAccess(
-			lang.NewMemberAccess(
-				lang.NewMemberAccess(
-					lang.NewVar("tables"),
-					query.Table,
-				),
-				tableDesc.primaryKey,
-			),
-			"scan",
-		),
+		innermostExpr,
 		lang.NewELambda(
 			[]lang.Param{
 				{