Include database connection string in database options

appservice/appservice.go

@@ -48,7 +48,7 @@ func NewInternalAPI(
 	rsAPI roomserverAPI.RoomserverInternalAPI,
 ) appserviceAPI.AppServiceQueryAPI {
 	// Create a connection to the appservice postgres DB
-	appserviceDB, err := storage.NewDatabase(string(base.Cfg.AppServiceAPI.Database), base.Cfg.AppServiceAPI.DatabaseOptions)
+	appserviceDB, err := storage.NewDatabase(&base.Cfg.AppServiceAPI.Database)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to appservice db")
 	}

appservice/storage/postgres/storage.go

@@ -21,6 +21,7 @@ import (
 
 	// Import postgres database driver
 	_ "github.com/lib/pq"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/gomatrixserverlib"
 )
@@ -34,10 +35,10 @@ type Database struct {
 }
 
 // NewDatabase opens a new database
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var result Database
 	var err error
-	if result.db, err = sqlutil.Open("postgres", dataSourceName, dbProperties); err != nil {
+	if result.db, err = sqlutil.Open(dbProperties); err != nil {
 		return nil, err
 	}
 	if err = result.prepare(); err != nil {

appservice/storage/sqlite3/storage.go

@@ -20,6 +20,7 @@ import (
 	"database/sql"
 
 	// Import SQLite database driver
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/gomatrixserverlib"
 	_ "github.com/mattn/go-sqlite3"
@@ -34,14 +35,10 @@ type Database struct {
 }
 
 // NewDatabase opens a new database
-func NewDatabase(dataSourceName string) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var result Database
 	var err error
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	if result.db, err = sqlutil.Open(dbProperties); err != nil {
-	if err != nil {
-		return nil, err
-	}
-	if result.db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
 		return nil, err
 	}
 	if err = result.prepare(); err != nil {

appservice/storage/storage.go

@@ -17,26 +17,22 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
 	"github.com/matrix-org/dendrite/appservice/storage/postgres"
 	"github.com/matrix-org/dendrite/appservice/storage/sqlite3"
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
 // NewDatabase opens a new Postgres or Sqlite database (based on dataSourceName scheme)
 // and sets DB connection parameters
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return sqlite3.NewDatabase(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

appservice/storage/storage_wasm.go

@@ -16,26 +16,18 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
 	"github.com/matrix-org/dendrite/appservice/storage/sqlite3"
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
-func NewDatabase(
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.NewDatabase(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

build/gobind/monolith.go

@@ -92,15 +92,15 @@ func (m *DendriteMonolith) Start() {
 	cfg.Global.Kafka.Topics.OutputTypingEvent = "typingServerOutput"
 	cfg.Global.Kafka.Topics.OutputSendToDeviceEvent = "sendToDeviceOutput"
 	cfg.Global.Kafka.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-naffka.db", m.StorageDirectory))
-	cfg.UserAPI.AccountDatabase = config.DataSource(fmt.Sprintf("file:%s/dendrite-account.db", m.StorageDirectory))
+	cfg.UserAPI.AccountDatabase.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-account.db", m.StorageDirectory))
-	cfg.UserAPI.DeviceDatabase = config.DataSource(fmt.Sprintf("file:%s/dendrite-device.db", m.StorageDirectory))
+	cfg.UserAPI.DeviceDatabase.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-device.db", m.StorageDirectory))
-	cfg.MediaAPI.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-mediaapi.db", m.StorageDirectory))
+	cfg.MediaAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-mediaapi.db", m.StorageDirectory))
-	cfg.SyncAPI.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-syncapi.db", m.StorageDirectory))
+	cfg.SyncAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-syncapi.db", m.StorageDirectory))
-	cfg.RoomServer.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-roomserver.db", m.StorageDirectory))
+	cfg.RoomServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-roomserver.db", m.StorageDirectory))
-	cfg.ServerKeyAPI.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-serverkey.db", m.StorageDirectory))
+	cfg.ServerKeyAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-serverkey.db", m.StorageDirectory))
-	cfg.FederationSender.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-federationsender.db", m.StorageDirectory))
+	cfg.FederationSender.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-federationsender.db", m.StorageDirectory))
-	cfg.AppServiceAPI.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-appservice.db", m.StorageDirectory))
+	cfg.AppServiceAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-appservice.db", m.StorageDirectory))
-	cfg.CurrentStateServer.Database = config.DataSource(fmt.Sprintf("file:%s/dendrite-currentstate.db", m.StorageDirectory))
+	cfg.CurrentStateServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s/dendrite-currentstate.db", m.StorageDirectory))
 	cfg.MediaAPI.BasePath = config.Path(fmt.Sprintf("%s/tmp", m.StorageDirectory))
 	cfg.MediaAPI.AbsBasePath = config.Path(fmt.Sprintf("%s/tmp", m.StorageDirectory))
 	cfg.FederationSender.FederationMaxRetries = 6

cmd/create-account/main.go

@@ -20,6 +20,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/userapi/storage/accounts"
 	"github.com/matrix-org/dendrite/userapi/storage/devices"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -63,7 +64,9 @@ func main() {
 
 	serverName := gomatrixserverlib.ServerName(*serverNameStr)
 
-	accountDB, err := accounts.NewDatabase(*database, nil, serverName)
+	accountDB, err := accounts.NewDatabase(&config.DatabaseOptions{
+		ConnectionString: config.DataSource(*database),
+	}, serverName)
 	if err != nil {
 		fmt.Println(err.Error())
 		os.Exit(1)
@@ -75,7 +78,9 @@ func main() {
 		os.Exit(1)
 	}
 
-	deviceDB, err := devices.NewDatabase(*database, nil, serverName)
+	deviceDB, err := devices.NewDatabase(&config.DatabaseOptions{
+		ConnectionString: config.DataSource(*database),
+	}, serverName)
 	if err != nil {
 		fmt.Println(err.Error())
 		os.Exit(1)

cmd/dendrite-demo-libp2p/main.go

@@ -123,17 +123,17 @@ func main() {
 	cfg.Global.Kafka.Topics.OutputSendToDeviceEvent = "sendToDeviceOutput"
 	cfg.Global.Kafka.Topics.OutputKeyChangeEvent = "keyChangeOutput"
 	cfg.FederationSender.FederationMaxRetries = 6
-	cfg.UserAPI.AccountDatabase = config.DataSource(fmt.Sprintf("file:%s-account.db", *instanceName))
+	cfg.UserAPI.AccountDatabase.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-account.db", *instanceName))
-	cfg.UserAPI.DeviceDatabase = config.DataSource(fmt.Sprintf("file:%s-device.db", *instanceName))
+	cfg.UserAPI.DeviceDatabase.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-device.db", *instanceName))
-	cfg.MediaAPI.Database = config.DataSource(fmt.Sprintf("file:%s-mediaapi.db", *instanceName))
+	cfg.MediaAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-mediaapi.db", *instanceName))
-	cfg.SyncAPI.Database = config.DataSource(fmt.Sprintf("file:%s-syncapi.db", *instanceName))
+	cfg.SyncAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-syncapi.db", *instanceName))
-	cfg.RoomServer.Database = config.DataSource(fmt.Sprintf("file:%s-roomserver.db", *instanceName))
+	cfg.RoomServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-roomserver.db", *instanceName))
-	cfg.ServerKeyAPI.Database = config.DataSource(fmt.Sprintf("file:%s-serverkey.db", *instanceName))
+	cfg.ServerKeyAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-serverkey.db", *instanceName))
-	cfg.FederationSender.Database = config.DataSource(fmt.Sprintf("file:%s-federationsender.db", *instanceName))
+	cfg.FederationSender.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-federationsender.db", *instanceName))
-	cfg.AppServiceAPI.Database = config.DataSource(fmt.Sprintf("file:%s-appservice.db", *instanceName))
+	cfg.AppServiceAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-appservice.db", *instanceName))
-	cfg.CurrentStateServer.Database = config.DataSource(fmt.Sprintf("file:%s-currentstate.db", *instanceName))
+	cfg.CurrentStateServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-currentstate.db", *instanceName))
-	cfg.Global.Kafka.Database = config.DataSource(fmt.Sprintf("file:%s-naffka.db", *instanceName))
+	cfg.Global.Kafka.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-naffka.db", *instanceName))
-	cfg.KeyServer.Database = config.DataSource(fmt.Sprintf("file:%s-e2ekey.db", *instanceName))
+	cfg.KeyServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-e2ekey.db", *instanceName))
 	if err = cfg.Derive(); err != nil {
 		panic(err)
 	}

cmd/dendrite-demo-yggdrasil/main.go

@@ -79,17 +79,17 @@ func main() {
 	cfg.Global.Kafka.Topics.OutputSendToDeviceEvent = "sendToDeviceOutput"
 	cfg.Global.Kafka.Topics.OutputKeyChangeEvent = "keyChangeOutput"
 	cfg.FederationSender.FederationMaxRetries = 6
-	cfg.UserAPI.AccountDatabase = config.DataSource(fmt.Sprintf("file:%s-account.db", *instanceName))
+	cfg.UserAPI.AccountDatabase.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-account.db", *instanceName))
-	cfg.UserAPI.DeviceDatabase = config.DataSource(fmt.Sprintf("file:%s-device.db", *instanceName))
+	cfg.UserAPI.DeviceDatabase.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-device.db", *instanceName))
-	cfg.MediaAPI.Database = config.DataSource(fmt.Sprintf("file:%s-mediaapi.db", *instanceName))
+	cfg.MediaAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-mediaapi.db", *instanceName))
-	cfg.SyncAPI.Database = config.DataSource(fmt.Sprintf("file:%s-syncapi.db", *instanceName))
+	cfg.SyncAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-syncapi.db", *instanceName))
-	cfg.RoomServer.Database = config.DataSource(fmt.Sprintf("file:%s-roomserver.db", *instanceName))
+	cfg.RoomServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-roomserver.db", *instanceName))
-	cfg.ServerKeyAPI.Database = config.DataSource(fmt.Sprintf("file:%s-serverkey.db", *instanceName))
+	cfg.ServerKeyAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-serverkey.db", *instanceName))
-	cfg.FederationSender.Database = config.DataSource(fmt.Sprintf("file:%s-federationsender.db", *instanceName))
+	cfg.FederationSender.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-federationsender.db", *instanceName))
-	cfg.AppServiceAPI.Database = config.DataSource(fmt.Sprintf("file:%s-appservice.db", *instanceName))
+	cfg.AppServiceAPI.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-appservice.db", *instanceName))
-	cfg.CurrentStateServer.Database = config.DataSource(fmt.Sprintf("file:%s-currentstate.db", *instanceName))
+	cfg.CurrentStateServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-currentstate.db", *instanceName))
-	cfg.Global.Kafka.Database = config.DataSource(fmt.Sprintf("file:%s-naffka.db", *instanceName))
+	cfg.Global.Kafka.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-naffka.db", *instanceName))
-	cfg.KeyServer.Database = config.DataSource(fmt.Sprintf("file:%s-e2ekey.db", *instanceName))
+	cfg.KeyServer.Database.ConnectionString = config.DataSource(fmt.Sprintf("file:%s-e2ekey.db", *instanceName))
 	if err = cfg.Derive(); err != nil {
 		panic(err)
 	}

cmd/dendritejs/main.go

@@ -162,18 +162,18 @@ func createP2PNode(privKey ed25519.PrivateKey) (serverName string, node *go_http
 func main() {
 	cfg := &config.Dendrite{}
 	cfg.Defaults()
-	cfg.UserAPI.AccountDatabase = "file:/idb/dendritejs_account.db"
+	cfg.UserAPI.AccountDatabase.ConnectionString = "file:/idb/dendritejs_account.db"
-	cfg.AppServiceAPI.Database = "file:/idb/dendritejs_appservice.db"
+	cfg.AppServiceAPI.Database.ConnectionString = "file:/idb/dendritejs_appservice.db"
-	cfg.UserAPI.DeviceDatabase = "file:/idb/dendritejs_device.db"
+	cfg.UserAPI.DeviceDatabase.ConnectionString = "file:/idb/dendritejs_device.db"
-	cfg.FederationSender.Database = "file:/idb/dendritejs_fedsender.db"
+	cfg.FederationSender.Database.ConnectionString = "file:/idb/dendritejs_fedsender.db"
-	cfg.MediaAPI.Database = "file:/idb/dendritejs_mediaapi.db"
+	cfg.MediaAPI.Database.ConnectionString = "file:/idb/dendritejs_mediaapi.db"
-	cfg.RoomServer.Database = "file:/idb/dendritejs_roomserver.db"
+	cfg.RoomServer.Database.ConnectionString = "file:/idb/dendritejs_roomserver.db"
-	cfg.ServerKeyAPI.Database = "file:/idb/dendritejs_serverkey.db"
+	cfg.ServerKeyAPI.Database.ConnectionString = "file:/idb/dendritejs_serverkey.db"
-	cfg.SyncAPI.Database = "file:/idb/dendritejs_syncapi.db"
+	cfg.SyncAPI.Database.ConnectionString = "file:/idb/dendritejs_syncapi.db"
-	cfg.CurrentStateServer.Database = "file:/idb/dendritejs_currentstate.db"
+	cfg.CurrentStateServer.Database.ConnectionString = "file:/idb/dendritejs_currentstate.db"
-	cfg.KeyServer.Database = "file:/idb/dendritejs_e2ekey.db"
+	cfg.KeyServer.Database.ConnectionString = "file:/idb/dendritejs_e2ekey.db"
 	cfg.Global.Kafka.UseNaffka = true
-	cfg.Global.Kafka.Database = "file:/idb/dendritejs_naffka.db"
+	cfg.Global.Kafka.Database.ConnectionString = "file:/idb/dendritejs_naffka.db"
 	cfg.Global.Kafka.Topics.OutputTypingEvent = "output_typing_event"
 	cfg.Global.Kafka.Topics.OutputSendToDeviceEvent = "output_send_to_device_event"
 	cfg.Global.Kafka.Topics.OutputClientData = "output_client_data"

currentstateserver/currentstateserver.go

@@ -35,7 +35,7 @@ func AddInternalRoutes(router *mux.Router, intAPI api.CurrentStateInternalAPI) {
 // NewInternalAPI returns a concrete implementation of the internal API. Callers
 // can call functions directly on the returned API or via an HTTP interface using AddInternalRoutes.
 func NewInternalAPI(cfg *config.CurrentStateServer, consumer sarama.Consumer) api.CurrentStateInternalAPI {
-	csDB, err := storage.NewDatabase(string(cfg.Database), cfg.DatabaseOptions)
+	csDB, err := storage.NewDatabase(&cfg.Database)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to open database")
 	}

currentstateserver/currentstateserver_test.go

@@ -97,8 +97,8 @@ func MustMakeInternalAPI(t *testing.T) (api.CurrentStateInternalAPI, sarama.Sync
 	cfg.Defaults()
 	cfg.Global.ServerName = "kaer.morhen"
 	cfg.Global.Kafka.Topics.OutputRoomEvent = config.Topic(kafkaTopic)
-	cfg.CurrentStateServer.Database = config.DataSource("file::memory:")
+	cfg.CurrentStateServer.Database.ConnectionString = config.DataSource("file::memory:")
-	db, err := sqlutil.Open(sqlutil.SQLiteDriverName(), "file::memory:", nil)
+	db, err := sqlutil.Open(&cfg.CurrentStateServer.Database)
 	if err != nil {
 		t.Fatalf("Failed to open naffka database: %s", err)
 	}

currentstateserver/storage/postgres/storage.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/currentstateserver/storage/shared"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 )
 
@@ -14,10 +15,10 @@ type Database struct {
 }
 
 // NewDatabase creates a new sync server database
-func NewDatabase(dbDataSourceName string, dbProperties sqlutil.DbProperties) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
 	var err error
-	if d.db, err = sqlutil.Open("postgres", dbDataSourceName, dbProperties); err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
 		return nil, err
 	}
 	if err = d.PartitionOffsetStatements.Prepare(d.db, "currentstate"); err != nil {

currentstateserver/storage/sqlite3/storage.go

@@ -4,6 +4,7 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/currentstateserver/storage/shared"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 )
 
@@ -15,13 +16,10 @@ type Database struct {
 
 // NewDatabase creates a new sync server database
 // nolint: gocyclo
-func NewDatabase(dataSourceName string) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	var err error
-	if err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
-		return nil, err
-	}
-	if d.db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
 		return nil, err
 	}
 	if err = d.PartitionOffsetStatements.Prepare(d.db, "currentstate"); err != nil {

currentstateserver/storage/storage.go

@@ -17,25 +17,21 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
 	"github.com/matrix-org/dendrite/currentstateserver/storage/postgres"
 	"github.com/matrix-org/dendrite/currentstateserver/storage/sqlite3"
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
 // NewDatabase opens a database connection.
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return sqlite3.NewDatabase(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

currentstateserver/storage/storage_wasm.go

@@ -16,27 +16,19 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
 	"github.com/matrix-org/dendrite/currentstateserver/storage/sqlite3"
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
 // NewDatabase opens a database connection.
-func NewDatabase(
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.NewDatabase(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

federationapi/federationapi_test.go

@@ -26,7 +26,7 @@ func TestRoomsV3URLEscapeDoNot404(t *testing.T) {
 	cfg.Global.PrivateKey = privKey
 	cfg.Global.Kafka.UseNaffka = true
 	cfg.Global.Kafka.Database = "file::memory:"
-	cfg.FederationSender.Database = "file::memory:"
+	cfg.FederationSender.Database.ConnectionString = config.DataSource("file::memory:")
 	base := setup.NewBaseDendrite(cfg, "Test", false)
 	keyRing := &test.NopJSONVerifier{}
 	fsAPI := base.FederationSenderHTTPClient()

federationsender/federationsender.go

@@ -45,7 +45,7 @@ func NewInternalAPI(
 ) api.FederationSenderInternalAPI {
 	cfg := &base.Cfg.FederationSender
 
-	federationSenderDB, err := storage.NewDatabase(string(cfg.Database), cfg.DatabaseOptions)
+	federationSenderDB, err := storage.NewDatabase(&cfg.Database)
 	if err != nil {
 		logrus.WithError(err).Panic("failed to connect to federation sender db")
 	}

federationsender/storage/postgres/storage.go

@@ -19,6 +19,7 @@ import (
 	"database/sql"
 
 	"github.com/matrix-org/dendrite/federationsender/storage/shared"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 )
 
@@ -30,10 +31,10 @@ type Database struct {
 }
 
 // NewDatabase opens a new database
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
 	var err error
-	if d.db, err = sqlutil.Open("postgres", dataSourceName, dbProperties); err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
 		return nil, err
 	}
 	joinedHosts, err := NewPostgresJoinedHostsTable(d.db)

federationsender/storage/sqlite3/storage.go

@@ -21,6 +21,7 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 
 	"github.com/matrix-org/dendrite/federationsender/storage/shared"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 )
 
@@ -32,14 +33,10 @@ type Database struct {
 }
 
 // NewDatabase opens a new database
-func NewDatabase(dataSourceName string) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
 	var err error
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
-	if err != nil {
-		return nil, err
-	}
-	if d.db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
 		return nil, err
 	}
 	joinedHosts, err := NewSQLiteJoinedHostsTable(d.db)

federationsender/storage/storage.go

@@ -17,25 +17,21 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
 	"github.com/matrix-org/dendrite/federationsender/storage/postgres"
 	"github.com/matrix-org/dendrite/federationsender/storage/sqlite3"
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
 // NewDatabase opens a new database
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return sqlite3.NewDatabase(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

federationsender/storage/storage_wasm.go

@@ -16,27 +16,19 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
 	"github.com/matrix-org/dendrite/federationsender/storage/sqlite3"
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
 // NewDatabase opens a new database
-func NewDatabase(
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.NewDatabase(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

internal/config/config.go

@@ -131,6 +131,16 @@ type Path string
 // A DataSource for opening a postgresql database using lib/pq.
 type DataSource string
 
+func (d DataSource) IsSQLite() bool {
+	return strings.HasPrefix(string(d), "file:")
+}
+
+func (d DataSource) IsPostgres() bool {
+	// commented line may not always be true?
+	// return strings.HasPrefix(string(d), "postgres:")
+	return !d.IsSQLite()
+}
+
 // A Topic in kafka.
 type Topic string
 

internal/config/config_appservice.go

@@ -32,8 +32,7 @@ type AppServiceAPI struct {
 	Listen Address `yaml:"listen"`
 	Bind   Address `yaml:"bind"`
 
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 
 	ConfigFiles []string `yaml:"config_files"`
 }
@@ -41,14 +40,14 @@ type AppServiceAPI struct {
 func (c *AppServiceAPI) Defaults() {
 	c.Listen = "localhost:7777"
 	c.Bind = "localhost:7777"
-	c.Database = "file:appservice.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:appservice.db"
 }
 
 func (c *AppServiceAPI) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "app_service_api.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "app_service_api.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "app_service_api.database", string(c.Database))
+	checkNotEmpty(configErrs, "app_service_api.database.connection_string", string(c.Database.ConnectionString))
 }
 
 // ApplicationServiceNamespace is the namespace that a specific application

internal/config/config_currentstate.go

@@ -8,19 +8,18 @@ type CurrentStateServer struct {
 
 	// The CurrentState database stores the current state of all rooms.
 	// It is accessed by the CurrentStateServer.
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 }
 
 func (c *CurrentStateServer) Defaults() {
 	c.Listen = "localhost:7782"
 	c.Bind = "localhost:7782"
-	c.Database = "file:currentstate.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:currentstate.db"
 }
 
 func (c *CurrentStateServer) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "current_state_server.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "current_state_server.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "current_state_server.database", string(c.Database))
+	checkNotEmpty(configErrs, "current_state_server.database.connection_string", string(c.Database.ConnectionString))
 }

internal/config/config_federationsender.go

@@ -8,8 +8,7 @@ type FederationSender struct {
 
 	// The FederationSender database stores information used by the FederationSender
 	// It is only accessed by the FederationSender.
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 
 	// Federation failure threshold. How many consecutive failures that we should
 	// tolerate when sending federation requests to a specific server. The backoff
@@ -23,8 +22,8 @@ type FederationSender struct {
 func (c *FederationSender) Defaults() {
 	c.Listen = "localhost:7775"
 	c.Bind = "localhost:7775"
-	c.Database = "file:federationsender.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:federationsender.db"
 
 	c.FederationMaxRetries = 16
 
@@ -34,7 +33,7 @@ func (c *FederationSender) Defaults() {
 func (c *FederationSender) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "federation_sender.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "federation_sender.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "federation_sender.database", string(c.Database))
+	checkNotEmpty(configErrs, "federation_sender.database.connection_string", string(c.Database.ConnectionString))
 }
 
 // The config for setting a proxy to use for server->server requests

internal/config/config_global.go

@@ -69,8 +69,7 @@ type Kafka struct {
 	// components as separate servers.
 	UseNaffka bool `yaml:"use_naffka"`
 	// The Naffka database is used internally by the naffka library, if used.
-	Database        DataSource      `yaml:"naffka_database"`
+	Database DatabaseOptions `yaml:"naffka_database"`
-	DatabaseOptions DatabaseOptions `yaml:"naffka_database_options"`
 	// The names of the topics to use when reading and writing from kafka.
 	Topics struct {
 		// Topic for roomserver/api.OutputRoomEvent events.
@@ -88,8 +87,8 @@ type Kafka struct {
 
 func (c *Kafka) Defaults() {
 	c.UseNaffka = true
-	c.Database = DataSource("file:naffka.db")
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = DataSource("file:naffka.db")
 	c.Topics.OutputRoomEvent = "OutputRoomEventTopic"
 	c.Topics.OutputClientData = "OutputClientDataTopic"
 	c.Topics.OutputTypingEvent = "OutputTypingEventTopic"
@@ -105,7 +104,7 @@ func (c *Kafka) Verify(configErrs *configErrors) {
 				configErrs.Add(fmt.Sprintf("naffka can only be used in a monolithic server"))
 			}
 		*/
-		checkNotEmpty(configErrs, "global.kafka.database", string(c.Database))
+		checkNotEmpty(configErrs, "global.kafka.database.connection_string", string(c.Database.ConnectionString))
 	} else {
 		// If we aren't using naffka then we need to have at least one kafka
 		// server to talk to.
@@ -141,12 +140,14 @@ func (c *Metrics) Verify(configErrs *configErrors) {
 }
 
 type DatabaseOptions struct {
+	// The connection string, file:filename.db or postgres://server....
+	ConnectionString DataSource `yaml:"connection_string"`
 	// Maximum open connections to the DB (0 = use default, negative means unlimited)
-	MaxOpenConnections int `yaml:"database_max_open_conns"`
+	MaxOpenConnections int `yaml:"max_open_conns"`
 	// Maximum idle connections to the DB (0 = use default, negative means unlimited)
-	MaxIdleConnections int `yaml:"database_max_idle_conns"`
+	MaxIdleConnections int `yaml:"max_idle_conns"`
 	// maximum amount of time (in seconds) a connection may be reused (<= 0 means unlimited)
-	ConnMaxLifetimeSeconds int `yaml:"database_conn_max_lifetime"`
+	ConnMaxLifetimeSeconds int `yaml:"conn_max_lifetime"`
 }
 
 func (c *DatabaseOptions) Defaults() {

internal/config/config_keyserver.go

@@ -6,19 +6,18 @@ type KeyServer struct {
 	Listen Address `yaml:"listen"`
 	Bind   Address `yaml:"bind"`
 
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 }
 
 func (c *KeyServer) Defaults() {
 	c.Listen = "localhost:7779"
 	c.Bind = "localhost:7779"
-	c.Database = "file:keyserver.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:keyserver.db"
 }
 
 func (c *KeyServer) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "key_server.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "key_server.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "key_server.database", string(c.Database))
+	checkNotEmpty(configErrs, "key_server.database.connection_string", string(c.Database.ConnectionString))
 }

internal/config/config_mediaapi.go

@@ -12,8 +12,7 @@ type MediaAPI struct {
 
 	// The MediaAPI database stores information about files uploaded and downloaded
 	// by local users. It is only accessed by the MediaAPI.
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 
 	// The base path to where the media files will be stored. May be relative or absolute.
 	BasePath Path `yaml:"base_path"`
@@ -39,8 +38,8 @@ type MediaAPI struct {
 func (c *MediaAPI) Defaults() {
 	c.Listen = "localhost:7774"
 	c.Bind = "localhost:7774"
-	c.Database = "file:mediaapi.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:mediaapi.db"
 
 	defaultMaxFileSizeBytes := FileSizeBytes(10485760)
 	c.MaxFileSizeBytes = &defaultMaxFileSizeBytes
@@ -50,7 +49,7 @@ func (c *MediaAPI) Defaults() {
 func (c *MediaAPI) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "media_api.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "media_api.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "media_api.database", string(c.Database))
+	checkNotEmpty(configErrs, "media_api.database.connection_string", string(c.Database.ConnectionString))
 
 	checkNotEmpty(configErrs, "media_api.base_path", string(c.BasePath))
 	checkPositive(configErrs, "media_api.max_file_size_bytes", int64(*c.MaxFileSizeBytes))

internal/config/config_roomserver.go

@@ -6,19 +6,18 @@ type RoomServer struct {
 	Listen Address `yaml:"listen"`
 	Bind   Address `yaml:"bind"`
 
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 }
 
 func (c *RoomServer) Defaults() {
 	c.Listen = "localhost:7770"
 	c.Bind = "localhost:7770"
-	c.Database = "file:roomserver.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:roomserver.db"
 }
 
 func (c *RoomServer) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "room_server.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "room_server.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "room_server.database", string(c.Database))
+	checkNotEmpty(configErrs, "room_server.database.connection_string", string(c.Database.ConnectionString))
 }

internal/config/config_serverkey.go

@@ -8,8 +8,7 @@ type ServerKeyAPI struct {
 
 	// The ServerKey database caches the public keys of remote servers.
 	// It may be accessed by the FederationAPI, the ClientAPI, and the MediaAPI.
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 
 	// Perspective keyservers, to use as a backup when direct key fetch
 	// requests don't succeed
@@ -19,12 +18,12 @@ type ServerKeyAPI struct {
 func (c *ServerKeyAPI) Defaults() {
 	c.Listen = "localhost:7780"
 	c.Bind = "localhost:7780"
-	c.Database = "file:serverkeyapi.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:serverkeyapi.db"
 }
 
 func (c *ServerKeyAPI) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "server_key_api.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "server_key_api.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "server_key_api.database", string(c.Database))
+	checkNotEmpty(configErrs, "server_key_api.database.connection_string", string(c.Database.ConnectionString))
 }

internal/config/config_syncapi.go

@@ -6,19 +6,18 @@ type SyncAPI struct {
 	Listen Address `yaml:"listen"`
 	Bind   Address `yaml:"bind"`
 
-	Database        DataSource      `yaml:"database"`
+	Database DatabaseOptions `yaml:"database"`
-	DatabaseOptions DatabaseOptions `yaml:"database_options"`
 }
 
 func (c *SyncAPI) Defaults() {
 	c.Listen = "localhost:7773"
 	c.Bind = "localhost:7773"
-	c.Database = "file:syncapi.db"
+	c.Database.Defaults()
-	c.DatabaseOptions.Defaults()
+	c.Database.ConnectionString = "file:syncapi.db"
 }
 
 func (c *SyncAPI) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "sync_api.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "sync_api.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "sync_api.database", string(c.Database))
+	checkNotEmpty(configErrs, "sync_api.database", string(c.Database.ConnectionString))
 }

internal/config/config_userapi.go

@@ -8,26 +8,24 @@ type UserAPI struct {
 
 	// The Account database stores the login details and account information
 	// for local users. It is accessed by the UserAPI.
-	AccountDatabase        DataSource      `yaml:"account_database"`
+	AccountDatabase DatabaseOptions `yaml:"account_database"`
-	AccountDatabaseOptions DatabaseOptions `yaml:"account_database_options"`
 	// The Device database stores session information for the devices of logged
 	// in local users. It is accessed by the UserAPI.
-	DeviceDatabase        DataSource      `yaml:"device_database"`
+	DeviceDatabase DatabaseOptions `yaml:"device_database"`
-	DeviceDatabaseOptions DatabaseOptions `yaml:"device_database_options"`
 }
 
 func (c *UserAPI) Defaults() {
 	c.Listen = "localhost:7781"
 	c.Bind = "localhost:7781"
-	c.AccountDatabase = "file:userapi_accounts.db"
+	c.AccountDatabase.Defaults()
-	c.DeviceDatabase = "file:userapi_devices.db"
+	c.DeviceDatabase.Defaults()
-	c.AccountDatabaseOptions.Defaults()
+	c.AccountDatabase.ConnectionString = "file:userapi_accounts.db"
-	c.DeviceDatabaseOptions.Defaults()
+	c.DeviceDatabase.ConnectionString = "file:userapi_devices.db"
 }
 
 func (c *UserAPI) Verify(configErrs *configErrors) {
 	checkNotEmpty(configErrs, "user_api.listen", string(c.Listen))
 	checkNotEmpty(configErrs, "user_api.bind", string(c.Bind))
-	checkNotEmpty(configErrs, "user_api.account_database", string(c.AccountDatabase))
+	checkNotEmpty(configErrs, "user_api.account_database.connection_string", string(c.AccountDatabase.ConnectionString))
-	checkNotEmpty(configErrs, "user_api.device_database", string(c.DeviceDatabase))
+	checkNotEmpty(configErrs, "user_api.device_database.connection_string", string(c.DeviceDatabase.ConnectionString))
 }

internal/setup/base.go

@@ -15,7 +15,6 @@
 package setup
 
 import (
-	"database/sql"
 	"fmt"
 	"io"
 	"net/http"
@@ -228,7 +227,7 @@ func (b *BaseDendrite) KeyServerHTTPClient() keyserverAPI.KeyInternalAPI {
 // CreateDeviceDB creates a new instance of the device database. Should only be
 // called once per component.
 func (b *BaseDendrite) CreateDeviceDB() devices.Database {
-	db, err := devices.NewDatabase(string(b.Cfg.UserAPI.DeviceDatabase), &b.Cfg.UserAPI.DeviceDatabaseOptions, b.Cfg.Global.ServerName)
+	db, err := devices.NewDatabase(&b.Cfg.UserAPI.DeviceDatabase, b.Cfg.Global.ServerName)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to devices db")
 	}
@@ -239,7 +238,7 @@ func (b *BaseDendrite) CreateDeviceDB() devices.Database {
 // CreateAccountsDB creates a new instance of the accounts database. Should only
 // be called once per component.
 func (b *BaseDendrite) CreateAccountsDB() accounts.Database {
-	db, err := accounts.NewDatabase(string(b.Cfg.UserAPI.AccountDatabase), &b.Cfg.UserAPI.AccountDatabaseOptions, b.Cfg.Global.ServerName)
+	db, err := accounts.NewDatabase(&b.Cfg.UserAPI.AccountDatabase, b.Cfg.Global.ServerName)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to accounts db")
 	}
@@ -307,36 +306,26 @@ func setupKafka(cfg *config.Dendrite) (sarama.Consumer, sarama.SyncProducer) {
 
 // setupNaffka creates kafka consumer/producer pair from the config.
 func setupNaffka(cfg *config.Dendrite) (sarama.Consumer, sarama.SyncProducer) {
-	var err error
-	var db *sql.DB
 	var naffkaDB *naffka.DatabaseImpl
 
-	uri, err := url.Parse(string(cfg.Global.Kafka.Database))
+	db, err := sqlutil.Open(&cfg.Global.Kafka.Database)
-	if err != nil || uri.Scheme == "file" {
+	if err != nil {
-		var cs string
+		logrus.WithError(err).Panic("Failed to open naffka database")
-		cs, err = sqlutil.ParseFileURI(string(cfg.Global.Kafka.Database))
+	}
-		if err != nil {
-			logrus.WithError(err).Panic("Failed to parse naffka database file URI")
-		}
-		db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil)
-		if err != nil {
-			logrus.WithError(err).Panic("Failed to open naffka database")
-		}
 
+	switch {
+	case cfg.Global.Kafka.Database.ConnectionString.IsSQLite():
 		naffkaDB, err = naffka.NewSqliteDatabase(db)
 		if err != nil {
 			logrus.WithError(err).Panic("Failed to setup naffka database")
 		}
-	} else {
+	case cfg.Global.Kafka.Database.ConnectionString.IsPostgres():
-		db, err = sqlutil.Open("postgres", string(cfg.Global.Kafka.Database), nil)
-		if err != nil {
-			logrus.WithError(err).Panic("Failed to open naffka database")
-		}
-
 		naffkaDB, err = naffka.NewPostgresqlDatabase(db)
 		if err != nil {
 			logrus.WithError(err).Panic("Failed to setup naffka database")
 		}
+	default:
+		panic("unknown naffka database type")
 	}
 
 	if naffkaDB == nil {

internal/sqlutil/sql.go

@@ -19,7 +19,6 @@ import (
 	"errors"
 	"fmt"
 	"runtime"
-	"time"
 
 	"go.uber.org/atomic"
 )
@@ -107,13 +106,6 @@ func SQLiteDriverName() string {
 	return "sqlite3"
 }
 
-// DbProperties functions return properties used by database/sql/DB
-type DbProperties interface {
-	MaxIdleConns() int
-	MaxOpenConns() int
-	ConnMaxLifetime() time.Duration
-}
-
 // TransactionWriter allows queuing database writes so that you don't
 // contend on database locks in, e.g. SQLite. Only one task will run
 // at a time on a given TransactionWriter.

internal/sqlutil/trace.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 	"time"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/ngrok/sqlmw"
 	"github.com/sirupsen/logrus"
 )
@@ -77,7 +78,22 @@ func (in *traceInterceptor) RowsNext(c context.Context, rows driver.Rows, dest [
 // Open opens a database specified by its database driver name and a driver-specific data source name,
 // usually consisting of at least a database name and connection information. Includes tracing driver
 // if DENDRITE_TRACE_SQL=1
-func Open(driverName, dsn string, dbProperties DbProperties) (*sql.DB, error) {
+func Open(dbProperties *config.DatabaseOptions) (*sql.DB, error) {
+	var err error
+	var driverName, dsn string
+	switch {
+	case dbProperties.ConnectionString.IsSQLite():
+		driverName = SQLiteDriverName()
+		dsn, err = ParseFileURI(dbProperties.ConnectionString)
+		if err != nil {
+			return nil, fmt.Errorf("ParseFileURI: %w", err)
+		}
+	case dbProperties.ConnectionString.IsPostgres():
+		driverName = "postgres"
+		dsn = string(dbProperties.ConnectionString)
+	default:
+		return nil, fmt.Errorf("invalid database connection string %q", dbProperties.ConnectionString)
+	}
 	if tracingEnabled {
 		// install the wrapped driver
 		driverName += "-trace"
@@ -86,11 +102,11 @@ func Open(driverName, dsn string, dbProperties DbProperties) (*sql.DB, error) {
 	if err != nil {
 		return nil, err
 	}
-	if driverName != SQLiteDriverName() && dbProperties != nil {
+	if driverName != SQLiteDriverName() {
 		logrus.WithFields(logrus.Fields{
-			"MaxOpenConns":    dbProperties.MaxOpenConns(),
+			"MaxOpenConns":    dbProperties.MaxOpenConns,
-			"MaxIdleConns":    dbProperties.MaxIdleConns(),
+			"MaxIdleConns":    dbProperties.MaxIdleConns,
-			"ConnMaxLifetime": dbProperties.ConnMaxLifetime(),
+			"ConnMaxLifetime": dbProperties.ConnMaxLifetime,
 			"dataSourceName":  regexp.MustCompile(`://[^@]*@`).ReplaceAllLiteralString(dsn, "://"),
 		}).Debug("Setting DB connection limits")
 		db.SetMaxOpenConns(dbProperties.MaxOpenConns())

internal/sqlutil/uri.go

@@ -15,14 +15,20 @@
 package sqlutil
 
 import (
+	"errors"
 	"fmt"
 	"net/url"
+
+	"github.com/matrix-org/dendrite/internal/config"
 )
 
 // ParseFileURI returns the filepath in the given file: URI. Specifically, this will handle
 // both relative (file:foo.db) and absolute (file:///path/to/foo) paths.
-func ParseFileURI(dataSourceName string) (string, error) {
+func ParseFileURI(dataSourceName config.DataSource) (string, error) {
-	uri, err := url.Parse(dataSourceName)
+	if !dataSourceName.IsSQLite() {
+		return "", errors.New("ParseFileURI expects SQLite connection string")
+	}
+	uri, err := url.Parse(string(dataSourceName))
 	if err != nil {
 		return "", err
 	}

internal/test/config.go

@@ -86,16 +86,16 @@ func MakeConfig(configDir, kafkaURI, database, host string, startPort int) (*con
 	// Using the same database for every schema currently works because
 	// the table names are globally unique. But we might not want to
 	// rely on that in the future.
-	cfg.AppServiceAPI.Database = config.DataSource(database)
+	cfg.AppServiceAPI.Database.ConnectionString = config.DataSource(database)
-	cfg.CurrentStateServer.Database = config.DataSource(database)
+	cfg.CurrentStateServer.Database.ConnectionString = config.DataSource(database)
-	cfg.FederationSender.Database = config.DataSource(database)
+	cfg.FederationSender.Database.ConnectionString = config.DataSource(database)
-	cfg.KeyServer.Database = config.DataSource(database)
+	cfg.KeyServer.Database.ConnectionString = config.DataSource(database)
-	cfg.MediaAPI.Database = config.DataSource(database)
+	cfg.MediaAPI.Database.ConnectionString = config.DataSource(database)
-	cfg.RoomServer.Database = config.DataSource(database)
+	cfg.RoomServer.Database.ConnectionString = config.DataSource(database)
-	cfg.ServerKeyAPI.Database = config.DataSource(database)
+	cfg.ServerKeyAPI.Database.ConnectionString = config.DataSource(database)
-	cfg.SyncAPI.Database = config.DataSource(database)
+	cfg.SyncAPI.Database.ConnectionString = config.DataSource(database)
-	cfg.UserAPI.AccountDatabase = config.DataSource(database)
+	cfg.UserAPI.AccountDatabase.ConnectionString = config.DataSource(database)
-	cfg.UserAPI.DeviceDatabase = config.DataSource(database)
+	cfg.UserAPI.DeviceDatabase.ConnectionString = config.DataSource(database)
 
 	cfg.AppServiceAPI.Listen = assignAddress()
 	cfg.CurrentStateServer.Listen = assignAddress()

keyserver/keyserver.go

@@ -39,7 +39,7 @@ func AddInternalRoutes(router *mux.Router, intAPI api.KeyInternalAPI) {
 func NewInternalAPI(
 	cfg *config.KeyServer, fedClient *gomatrixserverlib.FederationClient, userAPI userapi.UserInternalAPI, producer sarama.SyncProducer,
 ) api.KeyInternalAPI {
-	db, err := storage.NewDatabase(string(cfg.Database), cfg.DatabaseOptions)
+	db, err := storage.NewDatabase(&cfg.Database)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to key server database")
 	}

keyserver/storage/postgres/storage.go

@@ -15,14 +15,15 @@
 package postgres
 
 import (
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/keyserver/storage/shared"
 )
 
 // NewDatabase creates a new sync server database
-func NewDatabase(dbDataSourceName string, dbProperties sqlutil.DbProperties) (*shared.Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*shared.Database, error) {
 	var err error
-	db, err := sqlutil.Open("postgres", dbDataSourceName, dbProperties)
+	db, err := sqlutil.Open(dbProperties)
 	if err != nil {
 		return nil, err
 	}

keyserver/storage/sqlite3/storage.go

@@ -15,17 +15,13 @@
 package sqlite3
 
 import (
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/keyserver/storage/shared"
 )
 
-func NewDatabase(dataSourceName string) (*shared.Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*shared.Database, error) {
-	var err error
+	db, err := sqlutil.Open(dbProperties)
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
-	if err != nil {
-		return nil, err
-	}
-	db, err := sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil)
 	if err != nil {
 		return nil, err
 	}

keyserver/storage/storage.go

@@ -17,26 +17,22 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/keyserver/storage/postgres"
 	"github.com/matrix-org/dendrite/keyserver/storage/sqlite3"
 )
 
 // NewDatabase opens a new Postgres or Sqlite database (based on dataSourceName scheme)
 // and sets postgres connection parameters
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return sqlite3.NewDatabase(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

keyserver/storage/storage_wasm.go

@@ -16,26 +16,18 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/keyserver/storage/sqlite3"
 )
 
-func NewDatabase(
+func NewDatabase(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.NewDatabase(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

mediaapi/mediaapi.go

@@ -30,7 +30,7 @@ func AddPublicRoutes(
 	userAPI userapi.UserInternalAPI,
 	client *gomatrixserverlib.Client,
 ) {
-	mediaDB, err := storage.Open(string(cfg.Database), cfg.DatabaseOptions)
+	mediaDB, err := storage.Open(&cfg.Database)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to media db")
 	}

mediaapi/storage/postgres/storage.go

@@ -21,6 +21,7 @@ import (
 
 	// Import the postgres database driver.
 	_ "github.com/lib/pq"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/mediaapi/types"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -33,10 +34,10 @@ type Database struct {
 }
 
 // Open opens a postgres database.
-func Open(dataSourceName string, dbProperties sqlutil.DbProperties) (*Database, error) {
+func Open(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
 	var err error
-	if d.db, err = sqlutil.Open("postgres", dataSourceName, dbProperties); err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
 		return nil, err
 	}
 	if err = d.statements.prepare(d.db); err != nil {

mediaapi/storage/sqlite3/storage.go

@@ -20,6 +20,7 @@ import (
 	"database/sql"
 
 	// Import the postgres database driver.
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/mediaapi/types"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -33,14 +34,10 @@ type Database struct {
 }
 
 // Open opens a postgres database.
-func Open(dataSourceName string) (*Database, error) {
+func Open(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
 	var err error
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
-	if err != nil {
-		return nil, err
-	}
-	if d.db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
 		return nil, err
 	}
 	if err = d.statements.prepare(d.db); err != nil {

mediaapi/storage/storage.go

@@ -17,25 +17,21 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/mediaapi/storage/postgres"
 	"github.com/matrix-org/dendrite/mediaapi/storage/sqlite3"
 )
 
 // Open opens a postgres database.
-func Open(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func Open(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.Open(dataSourceName, dbProperties)
+		return sqlite3.Open(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.Open(dbProperties)
-	case "postgres":
-		return postgres.Open(dataSourceName, dbProperties)
-	case "file":
-		return sqlite3.Open(dataSourceName)
 	default:
-		return postgres.Open(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

mediaapi/storage/storage_wasm.go

@@ -16,27 +16,19 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/mediaapi/storage/sqlite3"
 )
 
 // Open opens a postgres database.
-func Open(
+func Open(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.Open(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.Open(dataSourceName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

roomserver/roomserver.go

@@ -41,7 +41,7 @@ func NewInternalAPI(
 ) api.RoomserverInternalAPI {
 	cfg := &base.Cfg.RoomServer
 
-	roomserverDB, err := storage.Open(string(cfg.Database), cfg.DatabaseOptions)
+	roomserverDB, err := storage.Open(&cfg.Database)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to room server db")
 	}

roomserver/roomserver_test.go

@@ -98,7 +98,7 @@ func mustSendEvents(t *testing.T, ver gomatrixserverlib.RoomVersion, events []js
 	cfg.Defaults()
 	cfg.Global.ServerName = testOrigin
 	cfg.Global.Kafka.UseNaffka = true
-	cfg.RoomServer.Database = roomserverDBFileURI
+	cfg.RoomServer.Database.ConnectionString = config.DataSource(roomserverDBFileURI)
 	dp := &dummyProducer{
 		topic: string(cfg.Global.Kafka.Topics.OutputRoomEvent),
 	}

roomserver/storage/postgres/storage.go

@@ -18,6 +18,7 @@ package postgres
 import (
 	"database/sql"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 
 	// Import the postgres database driver.
@@ -32,11 +33,11 @@ type Database struct {
 
 // Open a postgres database.
 // nolint: gocyclo
-func Open(dataSourceName string, dbProperties sqlutil.DbProperties) (*Database, error) {
+func Open(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
 	var db *sql.DB
 	var err error
-	if db, err = sqlutil.Open("postgres", dataSourceName, dbProperties); err != nil {
+	if db, err = sqlutil.Open(dbProperties); err != nil {
 		return nil, err
 	}
 	eventStateKeys, err := NewPostgresEventStateKeysTable(db)

roomserver/storage/sqlite3/storage.go

@@ -19,6 +19,7 @@ import (
 	"context"
 	"database/sql"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/roomserver/storage/shared"
 	"github.com/matrix-org/dendrite/roomserver/storage/tables"
@@ -44,13 +45,10 @@ type Database struct {
 
 // Open a sqlite database.
 // nolint: gocyclo
-func Open(dataSourceName string) (*Database, error) {
+func Open(dbProperties *config.DatabaseOptions) (*Database, error) {
 	var d Database
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	var err error
-	if err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
-		return nil, err
-	}
-	if d.db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
 		return nil, err
 	}
 	//d.db.Exec("PRAGMA journal_mode=WAL;")

roomserver/storage/storage.go

@@ -17,25 +17,21 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/roomserver/storage/postgres"
 	"github.com/matrix-org/dendrite/roomserver/storage/sqlite3"
 )
 
 // Open opens a database connection.
-func Open(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func Open(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.Open(dataSourceName, dbProperties)
+		return sqlite3.Open(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.Open(dbProperties)
-	case "postgres":
-		return postgres.Open(dataSourceName, dbProperties)
-	case "file":
-		return sqlite3.Open(dataSourceName)
 	default:
-		return postgres.Open(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

roomserver/storage/storage_wasm.go

@@ -16,27 +16,19 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/roomserver/storage/sqlite3"
 )
 
 // NewPublicRoomsServerDatabase opens a database connection.
-func Open(
+func Open(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.Open(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.Open(dataSourceName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

serverkeyapi/serverkeyapi.go

@@ -30,8 +30,7 @@ func NewInternalAPI(
 	caches *caching.Caches,
 ) api.ServerKeyInternalAPI {
 	innerDB, err := storage.NewDatabase(
-		string(cfg.Database),
+		&cfg.Database,
-		cfg.DatabaseOptions,
 		cfg.Matrix.ServerName,
 		cfg.Matrix.PrivateKey.Public().(ed25519.PublicKey),
 		cfg.Matrix.KeyID,

serverkeyapi/serverkeyapi_test.go

@@ -76,7 +76,7 @@ func TestMain(m *testing.M) {
 		cfg.Global.PrivateKey = testPriv
 		cfg.Global.KeyID = serverKeyID
 		cfg.Global.KeyValidityPeriod = s.validity
-		cfg.ServerKeyAPI.Database = config.DataSource("file::memory:")
+		cfg.ServerKeyAPI.Database.ConnectionString = config.DataSource("file::memory:")
 		s.config = &cfg.ServerKeyAPI
 		s.fedconfig = &cfg.FederationAPI
 

serverkeyapi/storage/keydb.go

@@ -17,11 +17,11 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
 	"golang.org/x/crypto/ed25519"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/serverkeyapi/storage/postgres"
 	"github.com/matrix-org/dendrite/serverkeyapi/storage/sqlite3"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -29,22 +29,17 @@ import (
 
 // NewDatabase opens a database connection.
 func NewDatabase(
-	dataSourceName string,
+	dbProperties *config.DatabaseOptions,
-	dbProperties sqlutil.DbProperties,
 	serverName gomatrixserverlib.ServerName,
 	serverKey ed25519.PublicKey,
 	serverKeyID gomatrixserverlib.KeyID,
 ) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName, serverKey, serverKeyID)
+		return sqlite3.NewDatabase(dbProperties, serverName, serverKey, serverKeyID)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties, serverName, serverKey, serverKeyID)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName, serverKey, serverKeyID)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName, serverKey, serverKeyID)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName, serverKey, serverKeyID)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

serverkeyapi/storage/postgres/keydb.go

@@ -20,6 +20,7 @@ import (
 
 	"golang.org/x/crypto/ed25519"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/gomatrixserverlib"
 )
@@ -35,13 +36,12 @@ type Database struct {
 // It prepares all the SQL statements that it will use.
 // Returns an error if there was a problem talking to the database.
 func NewDatabase(
-	dataSourceName string,
+	dbProperties *config.DatabaseOptions,
-	dbProperties sqlutil.DbProperties,
 	serverName gomatrixserverlib.ServerName,
 	serverKey ed25519.PublicKey,
 	serverKeyID gomatrixserverlib.KeyID,
 ) (*Database, error) {
-	db, err := sqlutil.Open("postgres", dataSourceName, dbProperties)
+	db, err := sqlutil.Open(dbProperties)
 	if err != nil {
 		return nil, err
 	}

serverkeyapi/storage/sqlite3/keydb.go

@@ -20,6 +20,7 @@ import (
 
 	"golang.org/x/crypto/ed25519"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/gomatrixserverlib"
 
@@ -37,16 +38,12 @@ type Database struct {
 // It prepares all the SQL statements that it will use.
 // Returns an error if there was a problem talking to the database.
 func NewDatabase(
-	dataSourceName string,
+	dbProperties *config.DatabaseOptions,
 	serverName gomatrixserverlib.ServerName,
 	serverKey ed25519.PublicKey,
 	serverKeyID gomatrixserverlib.KeyID,
 ) (*Database, error) {
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	db, err := sqlutil.Open(dbProperties)
-	if err != nil {
-		return nil, err
-	}
-	db, err := sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil)
 	if err != nil {
 		return nil, err
 	}

syncapi/storage/postgres/syncserver.go

@@ -21,6 +21,7 @@ import (
 	// Import the postgres database driver.
 	_ "github.com/lib/pq"
 	"github.com/matrix-org/dendrite/eduserver/cache"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/syncapi/storage/shared"
 )
@@ -34,10 +35,10 @@ type SyncServerDatasource struct {
 }
 
 // NewDatabase creates a new sync server database
-func NewDatabase(dbDataSourceName string, dbProperties sqlutil.DbProperties) (*SyncServerDatasource, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*SyncServerDatasource, error) {
 	var d SyncServerDatasource
 	var err error
-	if d.db, err = sqlutil.Open("postgres", dbDataSourceName, dbProperties); err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
 		return nil, err
 	}
 	if err = d.PartitionOffsetStatements.Prepare(d.db, "syncapi"); err != nil {

syncapi/storage/sqlite3/syncserver.go

@@ -22,6 +22,7 @@ import (
 	_ "github.com/mattn/go-sqlite3"
 
 	"github.com/matrix-org/dendrite/eduserver/cache"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/syncapi/storage/shared"
 )
@@ -37,13 +38,10 @@ type SyncServerDatasource struct {
 
 // NewDatabase creates a new sync server database
 // nolint: gocyclo
-func NewDatabase(dataSourceName string) (*SyncServerDatasource, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions) (*SyncServerDatasource, error) {
 	var d SyncServerDatasource
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
+	var err error
-	if err != nil {
+	if d.db, err = sqlutil.Open(dbProperties); err != nil {
-		return nil, err
-	}
-	if d.db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
 		return nil, err
 	}
 	if err = d.prepare(); err != nil {

syncapi/storage/storage.go

@@ -17,25 +17,21 @@
 package storage
 
 import (
-	"net/url"
+	"fmt"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/syncapi/storage/postgres"
 	"github.com/matrix-org/dendrite/syncapi/storage/sqlite3"
 )
 
 // NewSyncServerDatasource opens a database connection.
-func NewSyncServerDatasource(dataSourceName string, dbProperties sqlutil.DbProperties) (Database, error) {
+func NewSyncServerDatasource(dbProperties *config.DatabaseOptions) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return sqlite3.NewDatabase(dbProperties)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

syncapi/storage/storage_test.go

@@ -9,6 +9,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/syncapi/storage"
 	"github.com/matrix-org/dendrite/syncapi/storage/sqlite3"
 	"github.com/matrix-org/dendrite/syncapi/types"
@@ -59,7 +60,9 @@ func MustCreateDatabase(t *testing.T) storage.Database {
 			t.Fatalf("tried to delete stale test database but failed: %s", err)
 		}
 	}
-	db, err := sqlite3.NewDatabase(fmt.Sprintf("file:%s", dbname))
+	db, err := sqlite3.NewDatabase(&config.DatabaseOptions{
+		ConnectionString: config.DataSource(fmt.Sprintf("file:%s", dbname)),
+	})
 	if err != nil {
 		t.Fatalf("NewSyncServerDatasource returned %s", err)
 	}

syncapi/storage/storage_wasm.go

@@ -16,27 +16,19 @@ package storage
 
 import (
 	"fmt"
-	"net/url"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/syncapi/storage/sqlite3"
 )
 
 // NewPublicRoomsServerDatabase opens a database connection.
-func NewSyncServerDatasource(
+func NewSyncServerDatasource(dbProperties *config.DatabaseOptions) (Database, error) {
-	dataSourceName string,
+	switch {
-	dbProperties sqlutil.DbProperties, // nolint:unparam
+	case dbProperties.ConnectionString.IsSQLite():
-) (Database, error) {
+		return sqlite3.NewDatabase(dbProperties)
-	uri, err := url.Parse(dataSourceName)
+	case dbProperties.ConnectionString.IsPostgres():
-	if err != nil {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	}
-	switch uri.Scheme {
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

syncapi/syncapi.go

@@ -42,7 +42,7 @@ func AddPublicRoutes(
 	federation *gomatrixserverlib.FederationClient,
 	cfg *config.SyncAPI,
 ) {
-	syncDB, err := storage.NewSyncServerDatasource(string(cfg.Database), cfg.DatabaseOptions)
+	syncDB, err := storage.NewSyncServerDatasource(&cfg.Database)
 	if err != nil {
 		logrus.WithError(err).Panicf("failed to connect to sync db")
 	}

userapi/storage/accounts/postgres/storage.go

@@ -22,6 +22,7 @@ import (
 	"strconv"
 
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -43,10 +44,9 @@ type Database struct {
 }
 
 // NewDatabase creates a new accounts and profiles database
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties, serverName gomatrixserverlib.ServerName) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions, serverName gomatrixserverlib.ServerName) (*Database, error) {
-	var db *sql.DB
+	db, err := sqlutil.Open(dbProperties)
-	var err error
+	if err != nil {
-	if db, err = sqlutil.Open("postgres", dataSourceName, dbProperties); err != nil {
 		return nil, err
 	}
 	partitions := sqlutil.PartitionOffsetStatements{}

userapi/storage/accounts/sqlite3/storage.go

@@ -23,6 +23,7 @@ import (
 	"sync"
 
 	"github.com/matrix-org/dendrite/clientapi/auth/authtypes"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -47,16 +48,11 @@ type Database struct {
 }
 
 // NewDatabase creates a new accounts and profiles database
-func NewDatabase(dataSourceName string, serverName gomatrixserverlib.ServerName) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions, serverName gomatrixserverlib.ServerName) (*Database, error) {
-	var db *sql.DB
+	db, err := sqlutil.Open(dbProperties)
-	var err error
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
 	if err != nil {
 		return nil, err
 	}
-	if db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
-		return nil, err
-	}
 	partitions := sqlutil.PartitionOffsetStatements{}
 	if err = partitions.Prepare(db, "account"); err != nil {
 		return nil, err

userapi/storage/accounts/storage.go

@@ -17,9 +17,9 @@
 package accounts
 
 import (
-	"net/url"
+	"fmt"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/userapi/storage/accounts/postgres"
 	"github.com/matrix-org/dendrite/userapi/storage/accounts/sqlite3"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -27,17 +27,13 @@ import (
 
 // NewDatabase opens a new Postgres or Sqlite database (based on dataSourceName scheme)
 // and sets postgres connection parameters
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties, serverName gomatrixserverlib.ServerName) (Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions, serverName gomatrixserverlib.ServerName) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName)
+		return sqlite3.NewDatabase(dbProperties, serverName)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties, serverName)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

userapi/storage/accounts/storage_wasm.go

@@ -16,28 +16,22 @@ package accounts
 
 import (
 	"fmt"
-	"net/url"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/userapi/storage/accounts/sqlite3"
 	"github.com/matrix-org/gomatrixserverlib"
 )
 
 func NewDatabase(
-	dataSourceName string,
+	dbProperties *config.DatabaseOptions,
-	dbProperties sqlutil.DbProperties, // nolint:unparam
 	serverName gomatrixserverlib.ServerName,
 ) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return sqlite3.NewDatabase(dbProperties, serverName)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

userapi/storage/devices/postgres/storage.go

@@ -20,6 +20,7 @@ import (
 	"database/sql"
 	"encoding/base64"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -35,10 +36,9 @@ type Database struct {
 }
 
 // NewDatabase creates a new device database
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties, serverName gomatrixserverlib.ServerName) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions, serverName gomatrixserverlib.ServerName) (*Database, error) {
-	var db *sql.DB
+	db, err := sqlutil.Open(dbProperties)
-	var err error
+	if err != nil {
-	if db, err = sqlutil.Open("postgres", dataSourceName, dbProperties); err != nil {
 		return nil, err
 	}
 	d := devicesStatements{}

userapi/storage/devices/sqlite3/storage.go

@@ -20,6 +20,7 @@ import (
 	"database/sql"
 	"encoding/base64"
 
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/sqlutil"
 	"github.com/matrix-org/dendrite/userapi/api"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -37,16 +38,11 @@ type Database struct {
 }
 
 // NewDatabase creates a new device database
-func NewDatabase(dataSourceName string, serverName gomatrixserverlib.ServerName) (*Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions, serverName gomatrixserverlib.ServerName) (*Database, error) {
-	var db *sql.DB
+	db, err := sqlutil.Open(dbProperties)
-	var err error
-	cs, err := sqlutil.ParseFileURI(dataSourceName)
 	if err != nil {
 		return nil, err
 	}
-	if db, err = sqlutil.Open(sqlutil.SQLiteDriverName(), cs, nil); err != nil {
-		return nil, err
-	}
 	d := devicesStatements{}
 	if err = d.prepare(db, serverName); err != nil {
 		return nil, err

userapi/storage/devices/storage.go

@@ -17,9 +17,9 @@
 package devices
 
 import (
-	"net/url"
+	"fmt"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/userapi/storage/devices/postgres"
 	"github.com/matrix-org/dendrite/userapi/storage/devices/sqlite3"
 	"github.com/matrix-org/gomatrixserverlib"
@@ -27,17 +27,13 @@ import (
 
 // NewDatabase opens a new Postgres or Sqlite database (based on dataSourceName scheme)
 // and sets postgres connection parameters
-func NewDatabase(dataSourceName string, dbProperties sqlutil.DbProperties, serverName gomatrixserverlib.ServerName) (Database, error) {
+func NewDatabase(dbProperties *config.DatabaseOptions, serverName gomatrixserverlib.ServerName) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName)
+		return sqlite3.NewDatabase(dbProperties, serverName)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return postgres.NewDatabase(dbProperties, serverName)
-	case "postgres":
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName)
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName)
 	default:
-		return postgres.NewDatabase(dataSourceName, dbProperties, serverName)
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

userapi/storage/devices/storage_wasm.go

@@ -16,28 +16,22 @@ package devices
 
 import (
 	"fmt"
-	"net/url"
 
-	"github.com/matrix-org/dendrite/internal/sqlutil"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/userapi/storage/devices/sqlite3"
 	"github.com/matrix-org/gomatrixserverlib"
 )
 
 func NewDatabase(
-	dataSourceName string,
+	dbProperties *config.DatabaseOptions,
-	dbProperties sqlutil.DbProperties, // nolint:unparam
 	serverName gomatrixserverlib.ServerName,
 ) (Database, error) {
-	uri, err := url.Parse(dataSourceName)
+	switch {
-	if err != nil {
+	case dbProperties.ConnectionString.IsSQLite():
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return sqlite3.NewDatabase(dbProperties, serverName)
-	}
+	case dbProperties.ConnectionString.IsPostgres():
-	switch uri.Scheme {
+		return nil, fmt.Errorf("can't use Postgres implementation")
-	case "postgres":
-		return nil, fmt.Errorf("Cannot use postgres implementation")
-	case "file":
-		return sqlite3.NewDatabase(dataSourceName, serverName)
 	default:
-		return nil, fmt.Errorf("Cannot use postgres implementation")
+		return nil, fmt.Errorf("unexpected database type")
 	}
 }

userapi/userapi_test.go

@@ -8,6 +8,7 @@ import (
 	"testing"
 
 	"github.com/gorilla/mux"
+	"github.com/matrix-org/dendrite/internal/config"
 	"github.com/matrix-org/dendrite/internal/httputil"
 	"github.com/matrix-org/dendrite/internal/test"
 	"github.com/matrix-org/dendrite/userapi"
@@ -23,11 +24,15 @@ const (
 )
 
 func MustMakeInternalAPI(t *testing.T) (api.UserInternalAPI, accounts.Database, devices.Database) {
-	accountDB, err := accounts.NewDatabase("file::memory:", nil, serverName)
+	accountDB, err := accounts.NewDatabase(&config.DatabaseOptions{
+		ConnectionString: "file::memory:",
+	}, serverName)
 	if err != nil {
 		t.Fatalf("failed to create account DB: %s", err)
 	}
-	deviceDB, err := devices.NewDatabase("file::memory:", nil, serverName)
+	deviceDB, err := devices.NewDatabase(&config.DatabaseOptions{
+		ConnectionString: "file::memory:",
+	}, serverName)
 	if err != nil {
 		t.Fatalf("failed to create device DB: %s", err)
 	}