errors.go

@@ -3,5 +3,3 @@ package mysqlite
 import "errors"
 
 var ErrNoRows = errors.New("mysqlite: no rows returned")
-var ErrMissingBind = errors.New("mysqlite: missing bind value")
-var ErrMissingScan = errors.New("mysqlite: missing scan value")

query.go

@@ -11,10 +11,8 @@ type Query struct {
 	stmt *sqlite.Stmt
 	// Reference to the database. If set, it is assumed that a lock was taken
 	// by the query that should be freed by the query.
-	db *Db
-	// The number of bound arguments
-	binds int
-	err   error
+	db  *Db
+	err error
 }
 
 func (d *Db) Query(query string) *Query {
@@ -46,38 +44,17 @@ func (q *Query) bindInto(into *int, args ...any) *Query {
 	}
 	for i, arg := range args {
 		*into++
-		if arg == nil {
-			q.stmt.BindNull(*into)
-			q.binds++
-			continue
-		}
-		v := reflect.ValueOf(arg)
-		if v.Kind() == reflect.Ptr {
-			if v.IsNil() {
-				q.stmt.BindNull(*into)
-				q.binds++
-				continue
-			}
-			arg = v.Elem().Interface()
-		}
 		if asString, ok := arg.(string); ok {
 			q.stmt.BindText(*into, asString)
-			q.binds++
 		} else if asInt, ok := arg.(int); ok {
 			q.stmt.BindInt64(*into, int64(asInt))
-			q.binds++
-		} else if asInt64, ok := arg.(int64); ok {
-			q.stmt.BindInt64(*into, asInt64)
-			q.binds++
-		} else if asFloat, ok := arg.(float64); ok {
-			q.stmt.BindFloat(*into, asFloat)
-			q.binds++
+		} else if asInt, ok := arg.(int64); ok {
+			q.stmt.BindInt64(*into, asInt)
 		} else if asBool, ok := arg.(bool); ok {
 			q.stmt.BindBool(*into, asBool)
-			q.binds++
 		} else {
 			// Check if the argument is a slice or array of any type
-			v = reflect.ValueOf(arg)
+			v := reflect.ValueOf(arg)
 			if v.Kind() == reflect.Slice || v.Kind() == reflect.Array {
 				*into--
 				for i := 0; i < v.Len(); i++ {
@@ -119,23 +96,6 @@ func (q *Query) MustExec() {
 	}
 }
 
-func (q *Query) ScanColumns(results *[]string) *Query {
-	if q.err != nil {
-		return q
-	}
-
-	// Ensure the number of results matches the number of columns
-	if q.stmt.ColumnCount() != len(*results) {
-		*results = make([]string, q.stmt.ColumnCount())
-	}
-
-	// Fetch the column names
-	for i := 0; i < q.stmt.ColumnCount(); i++ {
-		(*results)[i] = q.stmt.ColumnName(i)
-	}
-	return q
-}
-
 func (q *Query) ScanSingle(results ...any) (rerr error) {
 	defer q.unlock()
 	// Scan rows
@@ -194,10 +154,6 @@ type Rows struct {
 }
 
 func (q *Query) ScanMulti() (*Rows, error) {
-	if q.binds != q.stmt.BindParamCount() {
-		return nil, ErrMissingBind
-	}
-
 	if q.err != nil {
 		return nil, q.err
 	}
@@ -235,9 +191,6 @@ func (r *Rows) MustNext() bool {
 }
 
 func (r *Rows) Scan(results ...any) error {
-	if r.query.stmt.ColumnCount() != len(results) {
-		return ErrMissingScan
-	}
 	for i, arg := range results {
 		err := r.scanArgument(i, arg)
 		if err != nil {
@@ -252,10 +205,6 @@ func (r *Rows) scanArgument(i int, arg any) error {
 		*asString = r.query.stmt.ColumnText(i)
 	} else if asInt, ok := arg.(*int); ok {
 		*asInt = r.query.stmt.ColumnInt(i)
-	} else if asInt, ok := arg.(*int64); ok {
-		*asInt = r.query.stmt.ColumnInt64(i)
-	} else if asFloat, ok := arg.(*float64); ok {
-		*asFloat = r.query.stmt.ColumnFloat(i)
 	} else if asBool, ok := arg.(*bool); ok {
 		*asBool = r.query.stmt.ColumnBool(i)
 	} else if reflect.TypeOf(arg).Kind() == reflect.Ptr && reflect.TypeOf(arg).Elem().Kind() == reflect.Ptr {

query_test.go

@@ -28,36 +28,6 @@ func TestSimpleQueryWithNoResults(t *testing.T) {
 	require.True(t, errors.Is(err, ErrNoRows))
 }
 
-func TestScanWithMissingValues(t *testing.T) {
-	db := openTestDb(t)
-	var count int
-	err := db.Query("select 1, 2").ScanSingle(&count)
-	require.Equal(t, ErrMissingScan, err)
-}
-
-func TestScanColumns(t *testing.T) {
-	db := openTestDb(t)
-	var columns []string
-	var key string
-	err := db.Query("select `key` from mytable").
-		ScanColumns(&columns).
-		ScanSingle(&key)
-	require.NoError(t, err, "expected no error scanning columns")
-	require.Equal(t, 1, len(columns), "expected one column")
-	require.Equal(t, "key", columns[0], "expected column name 'key'")
-	require.Equal(t, "foo", key, "expected key to be 'foo'")
-}
-
-func TestBindInt64(t *testing.T) {
-	db := openTestDb(t)
-	var value int64
-	var result int64
-	value = 5
-	err := db.Query("select ?").Bind(&value).ScanSingle(&result)
-	require.NoError(t, err)
-	require.Equal(t, int64(5), result)
-}
-
 func TestSimpleQueryWithArgs(t *testing.T) {
 	db := openTestDb(t)
 	var value string
@@ -124,70 +94,12 @@ func TestUpdateQuery(t *testing.T) {
 }
 
 func TestUpdateQueryWithWrongArguments(t *testing.T) {
-	type S struct {
-		Field string
-	}
 	db := openTestDb(t)
-	abc := S{
-		Field: "ipsum",
-	}
-	err := db.Query("insert into mytable(key, value) values ('lorem', ?)").Bind(abc).Exec()
+	value := "ipsum"
+	err := db.Query("insert into mytable(key, value) values ('lorem', ?)").Bind(&value).Exec()
 	require.Error(t, err)
 }
 
-func TestUpdateQueryWithPointerValue(t *testing.T) {
-	db := openTestDb(t)
-	func() {
-		tx := db.MustBegin()
-		defer tx.MustRollback()
-		tx.Query("insert into mytable(key, value) values ('lorem', 'bar')").MustExec()
-		value := "ipsum"
-		key := "lorem"
-		tx.Query("update mytable set value = ? where key = ?").Bind(&value, key).MustExec()
-		tx.MustCommit()
-	}()
-
-	var value string
-	db.Query("select value from mytable where key = 'lorem'").MustScanSingle(&value)
-	require.Equal(t, "ipsum", value)
-}
-
-func TestUpdateQueryWithSetPointerValue(t *testing.T) {
-	type S struct {
-		value *string
-	}
-	db := openTestDb(t)
-	func() {
-		tx := db.MustBegin()
-		defer tx.MustRollback()
-		tx.Query("insert into mytable(key, value) values ('lorem', 'bar')").MustExec()
-		s := S{nil}
-		key := "lorem"
-		tx.Query("update mytable set value = ? where key = ?").Bind(s.value, key).MustExec()
-		tx.MustCommit()
-	}()
-
-	var value *string
-	db.Query("select value from mytable where key = 'lorem'").MustScanSingle(&value)
-	require.Equal(t, (*string)(nil), value)
-}
-
-func TestUpdateQueryWithNullValue(t *testing.T) {
-	db := openTestDb(t)
-	func() {
-		tx := db.MustBegin()
-		defer tx.MustRollback()
-		tx.Query("insert into mytable(key, value) values ('lorem', 'bar')").MustExec()
-		key := "lorem"
-		tx.Query("update mytable set value = ? where key = ?").Bind(nil, key).MustExec()
-		tx.MustCommit()
-	}()
-
-	var value *string
-	db.Query("select value from mytable where key = 'lorem'").MustScanSingle(&value)
-	require.Nil(t, value)
-}
-
 func TestQueryWithPointerStringArguments(t *testing.T) {
 	db := openTestDb(t)
 	var result *string
@@ -197,31 +109,6 @@ func TestQueryWithPointerStringArguments(t *testing.T) {
 	require.Equal(t, "bar", *result)
 }
 
-func TestQueryWithInt64Scan(t *testing.T) {
-	db := openTestDb(t)
-	var result int64
-	err := db.Query("select 2").ScanSingle(&result)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	require.Equal(t, int64(2), result)
-}
-
-func TestQueryWithFloat64Scan(t *testing.T) {
-	db := openTestDb(t)
-	var result float64
-	err := db.Query("select 2.5").ScanSingle(&result)
-	require.NoError(t, err)
-	require.NotNil(t, result)
-	require.InDelta(t, 2.5, result, 0.001)
-}
-
-func TestQueryWithMissingBinds(t *testing.T) {
-	db := openTestDb(t)
-	var result float64
-	err := db.Query("select ?").ScanSingle(&result)
-	require.ErrorIs(t, err, ErrMissingBind)
-}
-
 func TestQueryWithPointerStringArgumentsCanSetToNull(t *testing.T) {
 	db := openTestDb(t)
 	db.Query("update mytable set value=null where key = 'foo'").MustExec()