bump gg to 0.10.0, use gg/assert

10 files changed, 216 insertions, 279 deletions

diff --git a/benchmark/benchmark_test.go b/benchmark/benchmark_test.go
index f779b08..a1e1450 100644
--- a/benchmark/benchmark_test.go
+++ b/benchmark/benchmark_test.go
@@ -14,8 +14,8 @@ import (
 
 	"github.com/go-gorp/gorp/v3"
 	_ "github.com/mattn/go-sqlite3"
+	"go.xyrillian.de/gg/assert"
 	"go.xyrillian.de/oblast"
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
 	"go.xyrillian.de/oblast/internal/testhelpers/must"
 	"gorm.io/driver/sqlite"
 	"gorm.io/gorm"
diff --git a/benchmark/postgres_test.go b/benchmark/postgres_test.go
index 8f1b7e8..778671b 100644
--- a/benchmark/postgres_test.go
+++ b/benchmark/postgres_test.go
@@ -15,9 +15,9 @@ import (
 
 	"github.com/jackc/pgx/v5"
 	_ "github.com/lib/pq"
+	"go.xyrillian.de/gg/assert"
 	"go.xyrillian.de/oblast"
 	"go.xyrillian.de/oblast/benchmark/internal/oblast_pgx"
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
 	"go.xyrillian.de/oblast/internal/testhelpers/must"
 )
 
diff --git a/errors_test.go b/errors_test.go
index 81ee395..bec0650 100644
--- a/errors_test.go
+++ b/errors_test.go
@@ -7,7 +7,7 @@ import (
 	"errors"
 	"testing"
 
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
+	"go.xyrillian.de/gg/assert"
 )
 
 type fooError struct{}
@@ -24,7 +24,7 @@ func TestIOError(t *testing.T) {
 
 	err = newIOError(fooError{}, "File.Close", nil)
 	assert.ErrEqual(t, err, "foo")
-	assert.DeepEqual(t, err, error(fooError{})) // check for no wrapping in type ioError without cleanup error
+	assert.Equal(t, err, error(fooError{})) // check for no wrapping in type ioError without cleanup error
 
 	err = newIOError(nil, "File.Close", barError{})
 	assert.ErrEqual(t, err, "during File.Close(): bar")
diff --git a/go.mod b/go.mod
index fb7ebd9..6354f3b 100644
--- a/go.mod
+++ b/go.mod
@@ -2,4 +2,4 @@ module go.xyrillian.de/oblast
 
 go 1.26
 
-require go.xyrillian.de/gg v1.7.0
+require go.xyrillian.de/gg v1.10.0
diff --git a/go.sum b/go.sum
index 1e5a029..de98770 100644
--- a/go.sum
+++ b/go.sum
@@ -1,2 +1,2 @@
-go.xyrillian.de/gg v1.7.0 h1:IA0BJaX9TtBD7crH+CSoK4lYmBk5zi7nUQd0YRzPNf0=
-go.xyrillian.de/gg v1.7.0/go.mod h1:dj+ZhCwC6JKWyFvImhVNXQAErrRcYMUkXu6vwWYNrzQ=
+go.xyrillian.de/gg v1.10.0 h1:Z//KSrZ9LM8ZWp1/e+4wBTuxMQlAROrSrgboMUXj3Aw=
+go.xyrillian.de/gg v1.10.0/go.mod h1:DoO4fQSWIrBRlNlCjVyrYM0kAEBt/Jg2GkMH+cGRZ0k=
diff --git a/internal/testhelpers/assert/assert.go b/internal/testhelpers/assert/assert.go
deleted file mode 100644
index 6e641ca..0000000
--- a/internal/testhelpers/assert/assert.go
+++ /dev/null
@@ -1,63 +0,0 @@
-// SPDX-FileCopyrightText: 2026 Stefan Majewsky <majewsky@gmx.net>
-// SPDX-License-Identifier: Apache-2.0
-
-package assert
-
-import (
-	"cmp"
-	"errors"
-	"reflect"
-	"testing"
-)
-
-// Equal is a test assertion.
-func Equal[V comparable](t testing.TB, actual, expected V) {
-	t.Helper()
-	if actual != expected {
-		t.Errorf("expected %#v", expected)
-		t.Errorf(" but got %#v", actual)
-	}
-}
-
-// DeepEqual is a test assertion.
-func DeepEqual[V any](t testing.TB, actual, expected V) {
-	t.Helper()
-	if !reflect.DeepEqual(actual, expected) {
-		t.Errorf("expected %#v", expected)
-		t.Errorf(" but got %#v", actual)
-	}
-}
-
-// ErrEqual is a test assertion.
-func ErrEqual(t testing.TB, actual error, expected string) {
-	t.Helper()
-	Equal(t, cmp.Or(actual, errors.New("<success>")).Error(), expected)
-}
-
-// SliceEqual is a test assertion.
-func SliceEqual[V comparable](t testing.TB, actual []V, expected ...V) {
-	t.Helper()
-	if len(actual) != len(expected) {
-		t.Errorf("length mismatch: expected %#v, but got %#v", expected, actual)
-	}
-	for idx := range actual {
-		if actual[idx] != expected[idx] {
-			t.Errorf("element %d: expected %#v", idx, expected[idx])
-			t.Errorf("element %d:  but got %#v", idx, actual[idx])
-		}
-	}
-}
-
-// SliceDeepEqual is a test assertion.
-func SliceDeepEqual[V any](t testing.TB, actual []V, expected ...V) {
-	t.Helper()
-	if len(actual) != len(expected) {
-		t.Errorf("length mismatch: expected %#v, but got %#v", expected, actual)
-	}
-	for idx := range actual {
-		if !reflect.DeepEqual(actual[idx], expected[idx]) {
-			t.Errorf("element %d: expected %#v", idx, expected[idx])
-			t.Errorf("element %d:  but got %#v", idx, actual[idx])
-		}
-	}
-}
diff --git a/plan_test.go b/plan_test.go
index 6c42f7a..ae9e2cc 100644
--- a/plan_test.go
+++ b/plan_test.go
@@ -10,7 +10,7 @@ import (
 	"testing"
 	"time"
 
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
+	"go.xyrillian.de/gg/assert"
 )
 
 func TestPlanFieldTraversal(t *testing.T) {
@@ -46,10 +46,10 @@ func TestPlanFieldTraversal(t *testing.T) {
 		t.Error(err)
 	}
 	assert.Equal(t, plan.TableName, "log_entries")
-	assert.DeepEqual(t, plan.AllColumnNames, []string{"id", "Message", "created_at", "updated_at", "deleted_at"})
-	assert.DeepEqual(t, plan.PrimaryKeyColumnNames, []string{"id"})
-	assert.DeepEqual(t, plan.AutoColumnNames, []string{"id"})
-	assert.DeepEqual(t, plan.IndexByColumnName, map[string][]int{
+	assert.Equal(t, plan.AllColumnNames, []string{"id", "Message", "created_at", "updated_at", "deleted_at"})
+	assert.Equal(t, plan.PrimaryKeyColumnNames, []string{"id"})
+	assert.Equal(t, plan.AutoColumnNames, []string{"id"})
+	assert.Equal(t, plan.IndexByColumnName, map[string][]int{
 		"id":         {0},
 		"Message":    {1},
 		"created_at": {4, 0},
@@ -77,20 +77,20 @@ func TestQueryConstructionBasic(t *testing.T) {
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.LastInsertIdIsUnsigned, false)
 		assert.Equal(t, plan.Select.Query, "SELECT `ID`, `Description`, `CreatedAt` FROM `basic_records` WHERE ")
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, "INSERT INTO `basic_records` (`Description`, `CreatedAt`) VALUES (?, ?)")
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{1}, {2}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{1}, {2}})
+		assert.Equal(t, plan.Insert.ScanIndexes, [][]int{{0}})
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "UPDATE `basic_records` SET `Description` = ?, `CreatedAt` = ? WHERE `ID` = ?")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "DELETE FROM `basic_records` WHERE `ID` = ?")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("PostgresDialect", func(t *testing.T) {
@@ -100,20 +100,20 @@ func TestQueryConstructionBasic(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, true)
 		assert.Equal(t, plan.Select.Query, `SELECT "ID", "Description", "CreatedAt" FROM "basic_records" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "basic_records" ("Description", "CreatedAt") VALUES ($1, $2) RETURNING "ID"`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{1}, {2}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{1}, {2}})
+		assert.Equal(t, plan.Insert.ScanIndexes, [][]int{{0}})
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, `UPDATE "basic_records" SET "Description" = $1, "CreatedAt" = $2 WHERE "ID" = $3`)
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "basic_records" WHERE "ID" = $1`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("SqliteDialect", func(t *testing.T) {
@@ -124,20 +124,20 @@ func TestQueryConstructionBasic(t *testing.T) {
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.LastInsertIdIsUnsigned, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "ID", "Description", "CreatedAt" FROM "basic_records" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "basic_records" ("Description", "CreatedAt") VALUES (?, ?)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{1}, {2}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{1}, {2}})
+		assert.Equal(t, plan.Insert.ScanIndexes, [][]int{{0}})
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, `UPDATE "basic_records" SET "Description" = ?, "CreatedAt" = ? WHERE "ID" = ?`)
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "basic_records" WHERE "ID" = ?`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 }
 
@@ -158,20 +158,20 @@ func TestQueryConstructionWithOnlyPrimaryKey(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, "SELECT `foo_id`, `bar_id` FROM `foo_bar_relations` WHERE ")
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
 		assert.Equal(t, plan.Insert.Query, "INSERT INTO `foo_bar_relations` (`foo_id`, `bar_id`) VALUES (?, ?)")
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, "INSERT INTO `foo_bar_relations` (`foo_id`, `bar_id`) VALUES (?, ?) ON DUPLICATE KEY UPDATE `foo_id` = VALUES(`foo_id`)")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "DELETE FROM `foo_bar_relations` WHERE `foo_id` = ? AND `bar_id` = ?")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("PostgresDialect", func(t *testing.T) {
@@ -181,20 +181,20 @@ func TestQueryConstructionWithOnlyPrimaryKey(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "foo_id", "bar_id" FROM "foo_bar_relations" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "foo_bar_relations" ("foo_id", "bar_id") VALUES ($1, $2)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, `INSERT INTO "foo_bar_relations" ("foo_id", "bar_id") VALUES ($1, $2) ON CONFLICT ("foo_id", "bar_id") DO NOTHING`)
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "foo_bar_relations" WHERE "foo_id" = $1 AND "bar_id" = $2`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("SqliteDialect", func(t *testing.T) {
@@ -204,20 +204,20 @@ func TestQueryConstructionWithOnlyPrimaryKey(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "foo_id", "bar_id" FROM "foo_bar_relations" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "foo_bar_relations" ("foo_id", "bar_id") VALUES (?, ?)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, `INSERT INTO "foo_bar_relations" ("foo_id", "bar_id") VALUES (?, ?) ON CONFLICT ("foo_id", "bar_id") DO NOTHING`)
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "foo_bar_relations" WHERE "foo_id" = ? AND "bar_id" = ?`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 }
 
@@ -237,20 +237,20 @@ func TestQueryConstructionWithoutPrimaryKey(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, "SELECT `foo_id`, `bar_id` FROM `foo_bar_relations` WHERE ")
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
 		assert.Equal(t, plan.Insert.Query, "INSERT INTO `foo_bar_relations` (`foo_id`, `bar_id`) VALUES (?, ?)")
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("PostgresDialect", func(t *testing.T) {
@@ -260,20 +260,20 @@ func TestQueryConstructionWithoutPrimaryKey(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "foo_id", "bar_id" FROM "foo_bar_relations" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "foo_bar_relations" ("foo_id", "bar_id") VALUES ($1, $2)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("SqliteDialect", func(t *testing.T) {
@@ -283,20 +283,20 @@ func TestQueryConstructionWithoutPrimaryKey(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "foo_id", "bar_id" FROM "foo_bar_relations" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "foo_bar_relations" ("foo_id", "bar_id") VALUES (?, ?)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 }
 
@@ -315,20 +315,20 @@ func TestQueryConstructionImpossible(t *testing.T) {
 			}
 
 			assert.Equal(t, plan.Select.Query, "")
-			assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-			assert.DeepEqual(t, plan.Select.ScanIndexes, nil)
+			assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+			assert.Equal(t, plan.Select.ScanIndexes, nil)
 			assert.Equal(t, plan.Insert.Query, "")
-			assert.DeepEqual(t, plan.Insert.ArgumentIndexes, nil)
-			assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+			assert.Equal(t, plan.Insert.ArgumentIndexes, nil)
+			assert.Equal(t, plan.Insert.ScanIndexes, nil)
 			assert.Equal(t, plan.Upsert.Query, "")
-			assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-			assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+			assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+			assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 			assert.Equal(t, plan.Update.Query, "")
-			assert.DeepEqual(t, plan.Update.ArgumentIndexes, nil)
-			assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+			assert.Equal(t, plan.Update.ArgumentIndexes, nil)
+			assert.Equal(t, plan.Update.ScanIndexes, nil)
 			assert.Equal(t, plan.Delete.Query, "")
-			assert.DeepEqual(t, plan.Delete.ArgumentIndexes, nil)
-			assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+			assert.Equal(t, plan.Delete.ArgumentIndexes, nil)
+			assert.Equal(t, plan.Delete.ScanIndexes, nil)
 		}
 	}
 
@@ -355,20 +355,20 @@ func TestQueryConstructionWithMultiplePrimaryKeyColumns(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, "SELECT `group_id`, `name`, `created_at` FROM `complex_records` WHERE ")
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, "INSERT INTO `complex_records` (`group_id`, `name`, `created_at`) VALUES (?, ?, ?)")
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, "INSERT INTO `complex_records` (`group_id`, `name`, `created_at`) VALUES (?, ?, ?) ON DUPLICATE KEY UPDATE `created_at` = VALUES(`created_at`)")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "UPDATE `complex_records` SET `created_at` = ? WHERE `group_id` = ? AND `name` = ?")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{2}, {0}, {1}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{2}, {0}, {1}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "DELETE FROM `complex_records` WHERE `group_id` = ? AND `name` = ?")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("PostgresDialect", func(t *testing.T) {
@@ -378,20 +378,20 @@ func TestQueryConstructionWithMultiplePrimaryKeyColumns(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "group_id", "name", "created_at" FROM "complex_records" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "complex_records" ("group_id", "name", "created_at") VALUES ($1, $2, $3)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, `INSERT INTO "complex_records" ("group_id", "name", "created_at") VALUES ($1, $2, $3) ON CONFLICT ("group_id", "name") DO UPDATE SET "created_at" = EXCLUDED."created_at"`)
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, `UPDATE "complex_records" SET "created_at" = $1 WHERE "group_id" = $2 AND "name" = $3`)
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{2}, {0}, {1}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{2}, {0}, {1}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "complex_records" WHERE "group_id" = $1 AND "name" = $2`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("SqliteDialect", func(t *testing.T) {
@@ -401,20 +401,20 @@ func TestQueryConstructionWithMultiplePrimaryKeyColumns(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, false)
 		assert.Equal(t, plan.Select.Query, `SELECT "group_id", "name", "created_at" FROM "complex_records" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "complex_records" ("group_id", "name", "created_at") VALUES (?, ?, ?)`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, nil)
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Insert.ScanIndexes, nil)
 		assert.Equal(t, plan.Upsert.Query, `INSERT INTO "complex_records" ("group_id", "name", "created_at") VALUES (?, ?, ?) ON CONFLICT ("group_id", "name") DO UPDATE SET "created_at" = EXCLUDED."created_at"`)
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, `UPDATE "complex_records" SET "created_at" = ? WHERE "group_id" = ? AND "name" = ?`)
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{2}, {0}, {1}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{2}, {0}, {1}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "complex_records" WHERE "group_id" = ? AND "name" = ?`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}, {1}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 }
 
@@ -436,20 +436,20 @@ func TestQueryConstructionWithMultipleAutoColumns(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, true)
 		assert.Equal(t, plan.Select.Query, "SELECT `id`, `name`, `created_at` FROM `autogenerated_records` WHERE ")
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, "INSERT INTO `autogenerated_records` (`name`) VALUES (?) RETURNING `id`, `created_at`")
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, [][]int{{0}, {2}})
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, [][]int{{0}, {2}})
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, "UPDATE `autogenerated_records` SET `name` = ?, `created_at` = ? WHERE `id` = ?")
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, "DELETE FROM `autogenerated_records` WHERE `id` = ?")
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("PostgresDialect", func(t *testing.T) {
@@ -459,20 +459,20 @@ func TestQueryConstructionWithMultipleAutoColumns(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, true)
 		assert.Equal(t, plan.Select.Query, `SELECT "id", "name", "created_at" FROM "autogenerated_records" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "autogenerated_records" ("name") VALUES ($1) RETURNING "id", "created_at"`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, [][]int{{0}, {2}})
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, [][]int{{0}, {2}})
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, `UPDATE "autogenerated_records" SET "name" = $1, "created_at" = $2 WHERE "id" = $3`)
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "autogenerated_records" WHERE "id" = $1`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 
 	t.Run("SqliteDialect", func(t *testing.T) {
@@ -482,20 +482,20 @@ func TestQueryConstructionWithMultipleAutoColumns(t *testing.T) {
 		}
 		assert.Equal(t, plan.InsertUsesQueryRow, true)
 		assert.Equal(t, plan.Select.Query, `SELECT "id", "name", "created_at" FROM "autogenerated_records" WHERE `)
-		assert.DeepEqual(t, plan.Select.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
+		assert.Equal(t, plan.Select.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Select.ScanIndexes, [][]int{{0}, {1}, {2}})
 		assert.Equal(t, plan.Insert.Query, `INSERT INTO "autogenerated_records" ("name") VALUES (?) RETURNING "id", "created_at"`)
-		assert.DeepEqual(t, plan.Insert.ArgumentIndexes, [][]int{{1}})
-		assert.DeepEqual(t, plan.Insert.ScanIndexes, [][]int{{0}, {2}})
+		assert.Equal(t, plan.Insert.ArgumentIndexes, [][]int{{1}})
+		assert.Equal(t, plan.Insert.ScanIndexes, [][]int{{0}, {2}})
 		assert.Equal(t, plan.Upsert.Query, "")
-		assert.DeepEqual(t, plan.Upsert.ArgumentIndexes, nil)
-		assert.DeepEqual(t, plan.Upsert.ScanIndexes, nil)
+		assert.Equal(t, plan.Upsert.ArgumentIndexes, nil)
+		assert.Equal(t, plan.Upsert.ScanIndexes, nil)
 		assert.Equal(t, plan.Update.Query, `UPDATE "autogenerated_records" SET "name" = ?, "created_at" = ? WHERE "id" = ?`)
-		assert.DeepEqual(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
-		assert.DeepEqual(t, plan.Update.ScanIndexes, nil)
+		assert.Equal(t, plan.Update.ArgumentIndexes, [][]int{{1}, {2}, {0}})
+		assert.Equal(t, plan.Update.ScanIndexes, nil)
 		assert.Equal(t, plan.Delete.Query, `DELETE FROM "autogenerated_records" WHERE "id" = ?`)
-		assert.DeepEqual(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
-		assert.DeepEqual(t, plan.Delete.ScanIndexes, nil)
+		assert.Equal(t, plan.Delete.ArgumentIndexes, [][]int{{0}})
+		assert.Equal(t, plan.Delete.ScanIndexes, nil)
 	})
 }
 
diff --git a/query_test.go b/query_test.go
index 6013201..7016c61 100644
--- a/query_test.go
+++ b/query_test.go
@@ -9,8 +9,8 @@ import (
 	"testing"
 	"time"
 
+	"go.xyrillian.de/gg/assert"
 	"go.xyrillian.de/oblast"
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
 	"go.xyrillian.de/oblast/internal/testhelpers/mock"
 	"go.xyrillian.de/oblast/internal/testhelpers/must"
 )
@@ -206,12 +206,12 @@ func TestUpsertBasicWithAutoColumn(t *testing.T) {
 	}
 	must.Succeed(t, store.Upsert(ctx, db, records...))
 
-	assert.SliceDeepEqual(t, records,
-		&basicRecord{ID: 1, Name: "first needs insert"},
-		&basicRecord{ID: 2, Name: "second needs update"},
-		&basicRecord{ID: 3, Name: "third needs insert"},
-		&basicRecord{ID: 4, Name: "fourth needs update"},
-	)
+	assert.Equal(t, records, []*basicRecord{
+		{ID: 1, Name: "first needs insert"},
+		{ID: 2, Name: "second needs update"},
+		{ID: 3, Name: "third needs insert"},
+		{ID: 4, Name: "fourth needs update"},
+	})
 }
 
 func TestWriteQueriesNotPossible(t *testing.T) {
diff --git a/runtimeindex_test.go b/runtimeindex_test.go
index ea77560..59044c4 100644
--- a/runtimeindex_test.go
+++ b/runtimeindex_test.go
@@ -7,8 +7,8 @@ import (
 	"database/sql"
 	"testing"
 
+	"go.xyrillian.de/gg/assert"
 	"go.xyrillian.de/oblast"
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
 	"go.xyrillian.de/oblast/internal/testhelpers/mock"
 	"go.xyrillian.de/oblast/internal/testhelpers/must"
 )
@@ -43,7 +43,7 @@ func TestRuntimeIndex(t *testing.T) {
 		// test success path
 		commonSetup()
 		result := must.Return(byName.IndexFrom(store.SelectWhere(ctx, db, `id > 0`)))(t)
-		assert.DeepEqual(t, result, map[string]basicRecord{
+		assert.Equal(t, result, map[string]basicRecord{
 			"foo": {1, "foo"},
 			"bar": {2, "bar"},
 			"baz": {3, "baz"},
@@ -60,7 +60,7 @@ func TestRuntimeIndex(t *testing.T) {
 		// test success path
 		commonSetup()
 		result := must.Return(byFirstLetter.PartitionFrom(store.SelectWhere(ctx, db, `id > 0`)))(t)
-		assert.DeepEqual(t, result, map[string][]basicRecord{
+		assert.Equal(t, result, map[string][]basicRecord{
 			"f": {{1, "foo"}},
 			"b": {{2, "bar"}, {3, "baz"}},
 		})
diff --git a/select_test.go b/select_test.go
index c55fe42..c76eb0b 100644
--- a/select_test.go
+++ b/select_test.go
@@ -11,8 +11,8 @@ import (
 
 	. "go.xyrillian.de/gg/option"
 
+	"go.xyrillian.de/gg/assert"
 	"go.xyrillian.de/oblast"
-	"go.xyrillian.de/oblast/internal/testhelpers/assert"
 	"go.xyrillian.de/oblast/internal/testhelpers/mock"
 	"go.xyrillian.de/oblast/internal/testhelpers/must"
 )
@@ -39,10 +39,10 @@ func TestSelectReturningSomeRecords(t *testing.T) {
 			WithRow("foo", 1).
 			WithRow("bar", 2)
 		records := must.Return(store.Select(ctx, db, `SELECT * FROM basic_records WHERE id < ?`, 3))(t)
-		assert.SliceEqual(t, records,
-			basicRecord{1, "foo"},
-			basicRecord{2, "bar"},
-		)
+		assert.Equal(t, records, []basicRecord{
+			{1, "foo"},
+			{2, "bar"},
+		})
 	})
 
 	t.Run("using Store.SelectWhere", func(t *testing.T) {
@@ -52,10 +52,10 @@ func TestSelectReturningSomeRecords(t *testing.T) {
 			WithRow(1, "ffoo").
 			WithRow(2, "bbar")
 		records := must.Return(store.SelectWhere(ctx, db, `id < ?`, 3))(t)
-		assert.SliceEqual(t, records,
-			basicRecord{1, "ffoo"},
-			basicRecord{2, "bbar"},
-		)
+		assert.Equal(t, records, []basicRecord{
+			{1, "ffoo"},
+			{2, "bbar"},
+		})
 	})
 
 	t.Run("using PreparedSelectQuery.Select", func(t *testing.T) {
@@ -66,10 +66,10 @@ func TestSelectReturningSomeRecords(t *testing.T) {
 			WithRow(2, "bbbar")
 		query := store.MustPrepareSelectQueryWhere(`id < ?`)
 		records := must.Return(query.Select(ctx, db, 3))(t)
-		assert.SliceEqual(t, records,
-			basicRecord{1, "fffoo"},
-			basicRecord{2, "bbbar"},
-		)
+		assert.Equal(t, records, []basicRecord{
+			{1, "fffoo"},
+			{2, "bbbar"},
+		})
 	})
 
 	t.Run("using Store.SelectOne", func(t *testing.T) {
@@ -155,7 +155,7 @@ func TestSelectReturningNoRecords(t *testing.T) {
 			ExpectQueryWithArgs(3).
 			AndReturnColumns("name", "id")
 		records := must.Return(store.Select(ctx, db, `SELECT * FROM basic_records WHERE id < ?`, 3))(t)
-		assert.SliceEqual(t, records, nil...)
+		assert.Equal(t, records, nil)
 	})
 
 	t.Run("using Store.SelectWhere", func(t *testing.T) {
@@ -163,7 +163,7 @@ func TestSelectReturningNoRecords(t *testing.T) {
 			ExpectQueryWithArgs(3).
 			AndReturnColumns("id", "name")
 		records := must.Return(store.SelectWhere(ctx, db, `id < ?`, 3))(t)
-		assert.SliceEqual(t, records, nil...)
+		assert.Equal(t, records, nil)
 	})
 
 	t.Run("using PreparedSelectQuery.Select", func(t *testing.T) {
@@ -172,7 +172,7 @@ func TestSelectReturningNoRecords(t *testing.T) {
 			AndReturnColumns("id", "name")
 		query := store.MustPrepareSelectQueryWhere(`id < ?`)
 		records := must.Return(query.Select(ctx, db, 3))(t)
-		assert.SliceEqual(t, records, nil...)
+		assert.Equal(t, records, nil)
 	})
 
 	t.Run("using Store.SelectOne", func(t *testing.T) {
@@ -363,35 +363,35 @@ func TestSelectIntoEmbeddedTypes(t *testing.T) {
 	t.Run("using Store.Select", func(t *testing.T) {
 		commonSetup(`SELECT * FROM composite_records`)
 		records := must.Return(store.Select(ctx, db, `SELECT * FROM composite_records`))(t)
-		assert.SliceDeepEqual(t, records,
-			compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
-			compositeRecord{2, HasCreatedAt{time.Unix(2, 0)}, &HasUpdatedAt{nil}},
-		)
+		assert.Equal(t, records, []compositeRecord{
+			{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
+			{2, HasCreatedAt{time.Unix(2, 0)}, &HasUpdatedAt{nil}},
+		})
 	})
 
 	t.Run("using Store.SelectWhere", func(t *testing.T) {
 		commonSetup(`SELECT "id", "created_at", "updated_at" FROM "composite_records" WHERE TRUE`)
 		records := must.Return(store.SelectWhere(ctx, db, `TRUE`))(t)
-		assert.SliceDeepEqual(t, records,
-			compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
-			compositeRecord{2, HasCreatedAt{time.Unix(2, 0)}, &HasUpdatedAt{nil}},
-		)
+		assert.Equal(t, records, []compositeRecord{
+			{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
+			{2, HasCreatedAt{time.Unix(2, 0)}, &HasUpdatedAt{nil}},
+		})
 	})
 
 	t.Run("using PreparedSelectQuery.Select", func(t *testing.T) {
 		commonSetup(`SELECT "id", "created_at", "updated_at" FROM "composite_records" WHERE TRUE`)
 		query := store.MustPrepareSelectQueryWhere(`TRUE`)
 		records := must.Return(query.Select(ctx, db))(t)
-		assert.SliceDeepEqual(t, records,
-			compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
-			compositeRecord{2, HasCreatedAt{time.Unix(2, 0)}, &HasUpdatedAt{nil}},
-		)
+		assert.Equal(t, records, []compositeRecord{
+			{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
+			{2, HasCreatedAt{time.Unix(2, 0)}, &HasUpdatedAt{nil}},
+		})
 	})
 
 	t.Run("using Store.SelectOne", func(t *testing.T) {
 		commonSetup(`SELECT * FROM composite_records`)
 		record := must.Return(store.SelectOne(ctx, db, `SELECT * FROM composite_records`))(t)
-		assert.DeepEqual(t, record,
+		assert.Equal(t, record,
 			compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
 		)
 	})
@@ -399,7 +399,7 @@ func TestSelectIntoEmbeddedTypes(t *testing.T) {
 	t.Run("using Store.SelectOneOrNone", func(t *testing.T) {
 		commonSetup(`SELECT * FROM composite_records`)
 		record := must.Return(store.SelectOneOrNone(ctx, db, `SELECT * FROM composite_records`))(t)
-		assert.DeepEqual(t, record,
+		assert.Equal(t, record,
 			Some(compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}}),
 		)
 	})
@@ -407,7 +407,7 @@ func TestSelectIntoEmbeddedTypes(t *testing.T) {
 	t.Run("using Store.SelectOneWhere", func(t *testing.T) {
 		commonSetup(`SELECT "id", "created_at", "updated_at" FROM "composite_records" WHERE TRUE`)
 		record := must.Return(store.SelectOneWhere(ctx, db, `TRUE`))(t)
-		assert.DeepEqual(t, record,
+		assert.Equal(t, record,
 			compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
 		)
 	})
@@ -415,7 +415,7 @@ func TestSelectIntoEmbeddedTypes(t *testing.T) {
 	t.Run("using Store.SelectOneOrNoneWhere", func(t *testing.T) {
 		commonSetup(`SELECT "id", "created_at", "updated_at" FROM "composite_records" WHERE TRUE`)
 		record := must.Return(store.SelectOneOrNoneWhere(ctx, db, `TRUE`))(t)
-		assert.DeepEqual(t, record,
+		assert.Equal(t, record,
 			Some(compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}}),
 		)
 	})
@@ -424,7 +424,7 @@ func TestSelectIntoEmbeddedTypes(t *testing.T) {
 		commonSetup(`SELECT "id", "created_at", "updated_at" FROM "composite_records" WHERE TRUE`)
 		query := store.MustPrepareSelectQueryWhere(`TRUE`)
 		record := must.Return(query.SelectOne(ctx, db))(t)
-		assert.DeepEqual(t, record,
+		assert.Equal(t, record,
 			compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}},
 		)
 	})
@@ -433,7 +433,7 @@ func TestSelectIntoEmbeddedTypes(t *testing.T) {
 		commonSetup(`SELECT "id", "created_at", "updated_at" FROM "composite_records" WHERE TRUE`)
 		query := store.MustPrepareSelectQueryWhere(`TRUE`)
 		record := must.Return(query.SelectOneOrNone(ctx, db))(t)
-		assert.DeepEqual(t, record,
+		assert.Equal(t, record,
 			Some(compositeRecord{1, HasCreatedAt{time.Unix(1, 0)}, &HasUpdatedAt{new(time.Unix(3, 0))}}),
 		)
 	})