add some test to parameter and delete unused code

context.go

@@ -417,26 +417,20 @@ func callWhere(where getter, i []Getter) (ok bool, err error) {
 }
 
 func paramToStatic(f *field, p interface{}) {
-
+	// See https://golang.org/pkg/database/sql/driver/#Value
 	switch t := p.(type) {
 	case bool:
 		f.typ = fieldTypeStaticBool
 		f.staticBool = t
 	case string:
 		f.typ = fieldTypeStaticString
 		f.staticStr = t
-	case fmt.Stringer:
+	case []byte:
 		f.typ = fieldTypeStaticString
-		f.staticStr = t.String()
-	case int:
-		f.typ = fieldTypeStaticNumber
-		f.staticNum = float64(t)
+		f.staticStr = string(t)
 	case int64:
 		f.typ = fieldTypeStaticNumber
 		f.staticNum = float64(t)
-	case float32:
-		f.typ = fieldTypeStaticNumber
-		f.staticNum = float64(t)
 	case float64:
 		f.typ = fieldTypeStaticNumber
 		f.staticNum = t

driver_test.go

@@ -3,6 +3,7 @@ package goql
 import (
 	"database/sql"
 	"testing"
+	"time"
 
 	"github.com/fzerorubigd/goql/astdata"
 	"github.com/stretchr/testify/assert"
@@ -64,3 +65,69 @@ func TestDriver(t *testing.T) {
 		assert.NotEmpty(t, def.String())
 	}
 }
+
+func TestQueryParams(t *testing.T) {
+	c, err := sql.Open("goql", "github.com/fzerorubigd/fixture")
+	require.NoError(t, err)
+	defer func() {
+		assert.NoError(t, c.Close())
+	}()
+
+	ss, err := c.Prepare("select name, def from funcs where def=?")
+	require.NoError(t, err)
+	defer func() {
+		assert.NoError(t, ss.Close())
+	}()
+	s, err := ss.Query("func(error)")
+	require.NoError(t, err)
+
+	defer func() {
+		assert.NoError(t, s.Close())
+	}()
+
+	for s.Next() {
+		var name string
+		var def astdata.Definition
+
+		assert.NoError(t, s.Scan(&name, &def))
+		assert.NotEmpty(t, name)
+		assert.IsType(t, &astdata.FuncType{}, def)
+		assert.Equal(t, "func (error)", def.String())
+	}
+
+	// I don't know if having this kind of bind is normal
+	ss, err = c.Prepare("select ?, ?, ?, ?, ?, ?, ?, ? from funcs")
+	require.NoError(t, err)
+	defer func() {
+		assert.NoError(t, ss.Close())
+	}()
+	s, err = ss.Query(true, "hi", []byte("bye"), int(10), int64(100), float32(1000), float64(10000), time.Now())
+	require.NoError(t, err)
+
+	defer func() {
+		assert.NoError(t, s.Close())
+	}()
+
+	for s.Next() {
+		var (
+			b     bool
+			hi    string
+			bye   []byte
+			in10  int
+			in100 int64
+			in32  float32
+			in64  float64
+			def   string
+		)
+		assert.NoError(t, s.Scan(&b, &hi, &bye, &in10, &in100, &in32, &in64, &def))
+		assert.True(t, b)
+		assert.Equal(t, "hi", hi)
+		assert.Equal(t, []byte("bye"), bye)
+		assert.Equal(t, int(10), in10)
+		assert.Equal(t, int64(100), in100)
+		assert.Equal(t, float32(1000), in32)
+		assert.Equal(t, float64(10000), in64)
+		assert.Equal(t, "time.Time", def)
+	}
+
+}

filter.go

@@ -24,13 +24,12 @@ type (
 
 var (
 	operGetterMap = map[parse.ItemType]operGetter{
-		itemColumn:             fieldGetterGenerator,
-		parse.ItemLiteral1:     literal1GetterGenerator,
-		parse.ItemNumber:       numberGetterGenerator,
-		parse.ItemNull:         nullGetterGenerator,
-		parse.ItemTrue:         boolGetterGenerator,
-		parse.ItemFalse:        boolGetterGenerator,
-		parse.ItemQuestionMark: parameterGetterGenerator,
+		itemColumn:         fieldGetterGenerator,
+		parse.ItemLiteral1: literal1GetterGenerator,
+		parse.ItemNumber:   numberGetterGenerator,
+		parse.ItemNull:     nullGetterGenerator,
+		parse.ItemTrue:     boolGetterGenerator,
+		parse.ItemFalse:    boolGetterGenerator,
 	}
 
 	opGetterMap = map[parse.ItemType]opGetter{
@@ -76,16 +75,6 @@ func assertType(t parse.Item, tp ...parse.ItemType) {
 	panic("runtime error")
 }
 
-func parameterGetterGenerator(t parse.Item) getter {
-	assertType(t, parse.ItemQuestionMark)
-	return func(in []Getter) interface{} {
-		for i := range in {
-			fmt.Println(in[i].Get())
-		}
-		return nullValue
-	}
-}
-
 func nullGetterGenerator(t parse.Item) getter {
 	assertType(t, parse.ItemNull)
 	return func(in []Getter) interface{} {