Support nil as paramterized values

db/db.go

@@ -889,6 +889,8 @@ func parametersToValues(parameters []*command.Parameter) ([]interface{}, error)
 			values[i] = sql.Named(parameters[i].GetName(), w.Y)
 		case *command.Parameter_S:
 			values[i] = sql.Named(parameters[i].GetName(), w.S)
+		case nil:
+			values[i] = nil
 		default:
 			return nil, fmt.Errorf("unsupported type: %T", w)
 		}

http/request_parser.go

@@ -131,6 +131,8 @@ func makeParameter(name string, i interface{}) (*command.Parameter, error) {
 			},
 			Name: name,
 		}, nil
+	case nil:
+		return nil, nil
 	}
 	return nil, ErrUnsupportedType
 }

http/request_parser_test.go

@@ -113,6 +113,34 @@ func Test_SingleParameterizedRequest(t *testing.T) {
 	}
 }
 
+func Test_SingleParameterizedRequestNull(t *testing.T) {
+	s := "INSERT INTO test(name, value) VALUES(?, ?)"
+	p0 := "fiona"
+	b := []byte(fmt.Sprintf(`[["%s", "%s", null]]`, s, p0))
+
+	stmts, err := ParseRequest(b)
+	if err != nil {
+		t.Fatalf("failed to parse request: %s", err.Error())
+	}
+
+	if len(stmts) != 1 {
+		t.Fatalf("incorrect number of statements returned: %d", len(stmts))
+	}
+	if stmts[0].Sql != s {
+		t.Fatalf("incorrect statement parsed, exp %s, got %s", s, stmts[0].Sql)
+	}
+
+	if len(stmts[0].Parameters) != 2 {
+		t.Fatalf("incorrect number of parameters returned: %d", len(stmts[0].Parameters))
+	}
+	if stmts[0].Parameters[0].GetS() != p0 {
+		t.Fatalf("incorrect parameter, exp %s, got %s", p0, stmts[0].Parameters[0])
+	}
+	if stmts[0].Parameters[1].GetValue() != nil {
+		t.Fatalf("incorrect nil parameter")
+	}
+}
+
 func Test_SingleNamedParameterizedRequest(t *testing.T) {
 	s := "SELECT * FROM foo WHERE bar=:bar AND qux=:qux"
 	b := []byte(fmt.Sprintf(`[["%s", %s]]`, s, mustJSONMarshal(map[string]interface{}{"bar": 1, "qux": "some string"})))

system_test/single_node_test.go

@@ -291,6 +291,49 @@ func Test_SingleNodeParameterized(t *testing.T) {
 	}
 }
 
+func Test_SingleNodeParameterizedNull(t *testing.T) {
+	node := mustNewLeaderNode()
+	defer node.Deprovision()
+
+	tests := []struct {
+		stmt     []interface{}
+		expected string
+		execute  bool
+	}{
+		{
+			stmt:     []interface{}{"CREATE TABLE foo (id integer not null primary key, name text, age integer)"},
+			expected: `{"results":[{}]}`,
+			execute:  true,
+		},
+		{
+			stmt:     []interface{}{"INSERT INTO foo(name, age) VALUES(?, ?)", "declan", nil},
+			expected: `{"results":[{"last_insert_id":1,"rows_affected":1}]}`,
+			execute:  true,
+		},
+		{
+			stmt:     []interface{}{"SELECT * FROM foo WHERE NAME=?", "declan"},
+			expected: `{"results":[{"columns":["id","name","age"],"types":["integer","text","integer"],"values":[[1,"declan",null]]}]}`,
+			execute:  false,
+		},
+	}
+
+	for i, tt := range tests {
+		var r string
+		var err error
+		if tt.execute {
+			r, err = node.ExecuteParameterized(tt.stmt)
+		} else {
+			r, err = node.QueryParameterized(tt.stmt)
+		}
+		if err != nil {
+			t.Fatalf(`test %d failed "%s": %s`, i, tt.stmt, err.Error())
+		}
+		if r != tt.expected {
+			t.Fatalf(`test %d received wrong result "%s" got: %s exp: %s`, i, tt.stmt, r, tt.expected)
+		}
+	}
+}
+
 func Test_SingleNodeParameterizedNamed(t *testing.T) {
 	node := mustNewLeaderNode()
 	defer node.Deprovision()