db+sqlc: introduce sqldb v2 types

Author: ViktorTigerstrom

db/interfaces.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/lightninglabs/lightning-terminal/db/sqlc"
+	"github.com/lightningnetwork/lnd/sqldb/v2"
 )
 
 var (
@@ -56,7 +57,7 @@ type BatchedTx[Q any] interface {
 		txBody func(Q) error) error
 
 	// Backend returns the type of the database backend used.
-	Backend() sqlc.BackendType
+	Backend() sqldb.BackendType
 }
 
 // Tx represents a database transaction that can be committed or rolled back.
@@ -277,7 +278,7 @@ func (t *TransactionExecutor[Q]) ExecTx(ctx context.Context,
 }
 
 // Backend returns the type of the database backend used.
-func (t *TransactionExecutor[Q]) Backend() sqlc.BackendType {
+func (t *TransactionExecutor[Q]) Backend() sqldb.BackendType {
 	return t.BatchedQuerier.Backend()
 }
 
@@ -301,7 +302,7 @@ func (s *BaseDB) BeginTx(ctx context.Context, opts TxOptions) (*sql.Tx, error) {
 }
 
 // Backend returns the type of the database backend used.
-func (s *BaseDB) Backend() sqlc.BackendType {
+func (s *BaseDB) Backend() sqldb.BackendType {
 	return s.Queries.Backend()
 }
 

db/postgres.go

@@ -9,6 +9,7 @@ import (
 	postgres_migrate "github.com/golang-migrate/migrate/v4/database/postgres"
 	_ "github.com/golang-migrate/migrate/v4/source/file"
 	"github.com/lightninglabs/lightning-terminal/db/sqlc"
+	"github.com/lightningnetwork/lnd/sqldb/v2"
 	"github.com/stretchr/testify/require"
 )
 
@@ -164,8 +165,26 @@ func (s *PostgresStore) ExecuteMigrations(target MigrationTarget,
 	)
 }
 
+// NewTestPostgresV2DB is a helper function that creates a Postgres database for
+// testing, using the sqldb v2 package's definition of the PostgresStore.
+func NewTestPostgresV2DB(t *testing.T) *sqldb.PostgresStore {
+	t.Helper()
+
+	t.Logf("Creating new Postgres DB for testing")
+
+	sqlFixture := sqldb.NewTestPgFixture(t, DefaultPostgresFixtureLifetime)
+	t.Cleanup(func() {
+		sqlFixture.TearDown(t)
+	})
+
+	return sqldb.NewTestPostgresDB(t, sqlFixture, LitdMigrationStreams)
+}
+
 // NewTestPostgresDB is a helper function that creates a Postgres database for
-// testing.
+// testing, using the litd db package's definition of the PostgresStore.
+//
+// TODO(viktor): remove this once the sqldb v2 package is implemented in
+// all of litd's packages.
 func NewTestPostgresDB(t *testing.T) *PostgresStore {
 	t.Helper()
 

db/sql_migrations.go

@@ -0,0 +1,30 @@
+package db
+
+import (
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database/pgx/v5"
+	"github.com/lightningnetwork/lnd/sqldb/v2"
+)
+
+var (
+	LitdMigrationStream = sqldb.MigrationStream{
+		MigrateTableName: pgx.DefaultMigrationsTable,
+		SQLFileDirectory: "sqlc/migrations",
+		Schemas:          sqlSchemas,
+
+		// LatestMigrationVersion is the latest migration version of the
+		// database.  This is used to implement downgrade protection for
+		// the daemon.
+		//
+		// NOTE: This MUST be updated when a new migration is added.
+		LatestMigrationVersion: LatestMigrationVersion,
+
+		MakePostMigrationChecks: func(
+			db *sqldb.BaseDB) (map[uint]migrate.PostStepCallback,
+			error) {
+
+			return make(map[uint]migrate.PostStepCallback), nil
+		},
+	}
+	LitdMigrationStreams = []sqldb.MigrationStream{LitdMigrationStream}
+)

db/sqlc/db_custom.go

@@ -2,51 +2,43 @@ package sqlc
 
 import (
 	"context"
-)
-
-// BackendType is an enum that represents the type of database backend we're
-// using.
-type BackendType uint8
-
-const (
-	// BackendTypeUnknown indicates we're using an unknown backend.
-	BackendTypeUnknown BackendType = iota
 
-	// BackendTypeSqlite indicates we're using a SQLite backend.
-	BackendTypeSqlite
-
-	// BackendTypePostgres indicates we're using a Postgres backend.
-	BackendTypePostgres
+	"github.com/lightningnetwork/lnd/sqldb/v2"
 )
 
 // wrappedTX is a wrapper around a DBTX that also stores the database backend
 // type.
 type wrappedTX struct {
 	DBTX
 
-	backendType BackendType
+	backendType sqldb.BackendType
 }
 
 // Backend returns the type of database backend we're using.
-func (q *Queries) Backend() BackendType {
+func (q *Queries) Backend() sqldb.BackendType {
 	wtx, ok := q.db.(*wrappedTX)
 	if !ok {
 		// Shouldn't happen unless a new database backend type is added
 		// but not initialized correctly.
-		return BackendTypeUnknown
+		return sqldb.BackendTypeUnknown
 	}
 
 	return wtx.backendType
 }
 
 // NewSqlite creates a new Queries instance for a SQLite database.
 func NewSqlite(db DBTX) *Queries {
-	return &Queries{db: &wrappedTX{db, BackendTypeSqlite}}
+	return &Queries{db: &wrappedTX{db, sqldb.BackendTypeSqlite}}
 }
 
 // NewPostgres creates a new Queries instance for a Postgres database.
 func NewPostgres(db DBTX) *Queries {
-	return &Queries{db: &wrappedTX{db, BackendTypePostgres}}
+	return &Queries{db: &wrappedTX{db, sqldb.BackendTypePostgres}}
+}
+
+// NewForType creates a new Queries instance for the given database type.
+func NewForType(db DBTX, typ sqldb.BackendType) *Queries {
+	return &Queries{db: &wrappedTX{db, typ}}
 }
 
 // CustomQueries defines a set of custom queries that we define in addition
@@ -62,5 +54,5 @@ type CustomQueries interface {
 		arg ListActionsParams) ([]Action, error)
 
 	// Backend returns the type of the database backend used.
-	Backend() BackendType
+	Backend() sqldb.BackendType
 }