feat: support bulk delete (#25)

Author: Gustrb

db.go

@@ -164,6 +164,10 @@ func (db *DB) Delete(ctx context.Context, record interface{}) error {
 	return mustDelete(ctx, db.Exec, record)
 }
 
+func (db *DB) BulkDelete(ctx context.Context, records interface{}) error {
+	return mustBulkDelete(ctx, db.Exec, records)
+}
+
 // Start a DB transaction. It returns an interface w/ most of the methods DB provides.
 func (db *DB) Begin(ctx context.Context, readOnly bool) (*Tx, error) {
 	client, err := db.Client.BeginTx(ctx, &stdsql.TxOptions{

delete.go

@@ -5,12 +5,13 @@ import (
 	stdsql "database/sql"
 	"errors"
 	"fmt"
+	"reflect"
 
 	"github.com/azer/crud/v2/meta"
 	"github.com/azer/crud/v2/sql"
 )
 
-func deleteRow(ctx context.Context, exec ExecFn, record interface{}) (stdsql.Result, error) {
+func deleteRow(ctx context.Context, exec ExecFn, record any) (stdsql.Result, error) {
 	table, err := NewTable(record)
 
 	if err != nil {
@@ -25,7 +26,31 @@ func deleteRow(ctx context.Context, exec ExecFn, record interface{}) (stdsql.Res
 	return exec(ctx, sql.DeleteQuery(table.SQLName, pk.SQL.Name), meta.StructFieldValue(record, pk.Name))
 }
 
-func mustDelete(ctx context.Context, exec ExecFn, record interface{}) error {
+func deleteRows(ctx context.Context, exec ExecFn, records []any) (stdsql.Result, error) {
+	if len(records) == 0 {
+		return nil, errors.New("no records to delete")
+	}
+
+	table, err := NewTable(records[0])
+	if err != nil {
+		return nil, err
+	}
+
+	pk := table.PrimaryKeyField()
+	if pk == nil {
+		return nil, fmt.Errorf("Table '%s' (%s) doesn't have a primary-key field", table.Name, table.SQLName)
+	}
+
+	pkValues := make([]any, 0, len(records))
+	for _, record := range records {
+		pkValue := meta.StructFieldValue(record, pk.Name)
+		pkValues = append(pkValues, pkValue)
+	}
+
+	return exec(ctx, sql.BulkDeleteQuery(table.SQLName, pk.SQL.Name, len(records)), pkValues...)
+}
+
+func mustDelete(ctx context.Context, exec ExecFn, record any) error {
 	result, err := deleteRow(ctx, exec, record)
 	if err != nil {
 		return err
@@ -42,3 +67,35 @@ func mustDelete(ctx context.Context, exec ExecFn, record interface{}) error {
 
 	return nil
 }
+
+func mustBulkDelete(ctx context.Context, exec ExecFn, value any) error {
+	v := reflect.ValueOf(value)
+	if v.Kind() != reflect.Slice {
+		return errors.New("records must be a slice")
+	}
+
+	records := make([]any, 0, v.Len())
+	for i := 0; i < v.Len(); i++ {
+		records = append(records, v.Index(i).Interface())
+	}
+
+	if len(records) == 0 {
+		return errors.New("no records to delete")
+	}
+
+	result, err := deleteRows(ctx, exec, records)
+	if err != nil {
+		return err
+	}
+
+	count, err := result.RowsAffected()
+	if err != nil {
+		return err
+	}
+
+	if count == 0 {
+		return stdsql.ErrNoRows
+	}
+
+	return nil
+}

delete_test.go

@@ -55,3 +55,19 @@ func TestMustDeleteNotMatching(t *testing.T) {
 		Name: "Yolo",
 	}))
 }
+
+func TestBulkDelete(t *testing.T) {
+	ctx := context.Background()
+
+	require.NoError(t, CreateUserProfiles(ctx))
+
+	nova := UserProfile{}
+	err := DB.Read(ctx, &nova, "SELECT * FROM user_profiles WHERE name = 'Nova'")
+	assert.Nil(t, err)
+
+	assert.Nil(t, DB.BulkDelete(ctx, []UserProfile{nova}))
+
+	novac := UserProfile{}
+	err = DB.Read(ctx, &novac, "SELECT * FROM user_profile WHERE name = 'Nova'")
+	assert.NotNil(t, err)
+}

sql/table.go

@@ -152,6 +152,14 @@ func DeleteQuery(tableName, index string) string {
 	return fmt.Sprintf("DELETE FROM `%s` WHERE `%s`=?", tableName, index)
 }
 
+func BulkDeleteQuery(tableName, index string, numRecords int) string {
+	pattern := fmt.Sprintf("(%s)", repeatComma(1, "?"))
+	questionMarks := slices.Repeat([]string{pattern}, numRecords)
+
+	return fmt.Sprintf("DELETE FROM `%s` WHERE `%s` IN (%s)",
+		tableName, index, strings.Join(questionMarks, ","))
+}
+
 func quoteColumnNames(columns []string) []string {
 	var cols []string
 	for _, c := range columns {

sql/table_test.go

@@ -101,3 +101,7 @@ func TestUpdateQuery(t *testing.T) {
 func TestDeleteQuery(t *testing.T) {
 	assert.Equal(t, sql.DeleteQuery("yolo", "id"), "DELETE FROM `yolo` WHERE `id`=?")
 }
+
+func TestBulkDeleteQuery(t *testing.T) {
+	assert.Equal(t, sql.BulkDeleteQuery("yolo", "id", 3), "DELETE FROM `yolo` WHERE `id` IN ((?),(?),(?))")
+}

transaction.go

@@ -57,6 +57,10 @@ func (tx *Tx) BulkCreate(ctx context.Context, records any) error {
 	return bulkCreate(ctx, tx.Exec, records)
 }
 
+func (tx *Tx) BulkDelete(ctx context.Context, records any) error {
+	return mustBulkDelete(ctx, tx.Exec, records)
+}
+
 // Replace given record to the database.
 func (tx *Tx) Replace(ctx context.Context, record interface{}) error {
 	return replace(ctx, tx.Exec, record)