From 86b6e37e552ec0f6f627f3942425904513b413c7 Mon Sep 17 00:00:00 2001 From: MrTeeett Date: Mon, 16 Nov 2026 16:55:34 +0300 Subject: [PATCH 1/4] Add default transaction isolation setting, including autocommit. --- README.md | 11 ++++ default_transaction_test.go | 85 ++++++++++++++++++++++++++++++ fbconn/config.go | 47 ++++++++++------- fbconn/config_test.go | 1 + fbconn/fbconn.go | 30 ++++++----- fbconn/transaction_options.go | 30 +++++++++++ fbconn/transaction_options_test.go | 82 ++++++++++++++++++++++++++++ fbservice/backup_test.go | 2 + fbservice/config.go | 1 + stdlib/default_transaction_test.go | 62 ++++++++++++++++++++++ stdlib/sql.go | 8 +-- tx.go | 4 ++ 12 files changed, 329 insertions(+), 34 deletions(-) create mode 100644 default_transaction_test.go create mode 100644 fbconn/transaction_options.go create mode 100644 fbconn/transaction_options_test.go create mode 100644 stdlib/default_transaction_test.go diff --git a/README.md b/README.md index 77620217..ee8ddf60 100644 --- a/README.md +++ b/README.md @@ -88,6 +88,17 @@ See documentation and more usage examples at https://pkg.go.dev/github.com/fireb Wire compression is disabled by default. Enable it with `wire_compression=true` in the connection string (`wire_compress` and `wireCompression` are accepted aliases) or with `FBWIRECOMPRESSION=true`. +Set `default_transaction_isolation='read committed'` in a keyword/value connection +string, or `?default_transaction_isolation=read%20committed` in a URL, to choose +the default transaction isolation. Supported values are `read committed`, +`repeatable read`, and `serializable`; an empty value preserves the server default. +The setting also applies to autocommit, `Begin`, and `database/sql` transactions +using `sql.LevelDefault`. An explicit `TxOptions.IsoLevel` or `sql.TxOptions.Isolation` +overrides it. Raw TPBs passed to `BeginTxTPB` or `StartTransactionTPB` are unchanged. +SQL `SET TRANSACTION` statements use the options in the SQL and server defaults +for any omitted options. +The same setting is available as `Config.DefaultTransactionIsolation`. + For cursor queries, the driver automatically uses the server's deferred-execute flag from `Prepare`. When supported, `Exec` buffers `Execute`; the first row read sends `Execute` and `Fetch` together. A result closed before reading sends `Execute` diff --git a/default_transaction_test.go b/default_transaction_test.go new file mode 100644 index 00000000..10ddab86 --- /dev/null +++ b/default_transaction_test.go @@ -0,0 +1,85 @@ +package fbx_test + +import ( + "context" + "fmt" + "os" + "testing" + "time" + + "github.com/firebirdsql/fbx" + "github.com/firebirdsql/fbx/fbproto" + "github.com/stretchr/testify/require" +) + +func TestDefaultTransactionIsolation(t *testing.T) { + if os.Getenv("FBX_TEST_DATABASE") == "" { + t.Skip("FBX_TEST_DATABASE is not set") + } + t.Parallel() + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + const query = "select mon$isolation_mode, mon$read_only, mon$lock_timeout from mon$transactions where mon$transaction_id = current_transaction" + for _, isolation := range []fbx.TxIsoLevel{fbx.ReadCommitted, fbx.RepeatableRead, fbx.Serializable} { + for _, autocommit := range []bool{true, false} { + t.Run(fmt.Sprintf("%s/autocommit=%t", isolation, autocommit), func(t *testing.T) { + config, err := fbx.ParseConfig(os.Getenv("FBX_TEST_DATABASE")) + require.NoError(t, err) + config.DefaultTransactionIsolation = string(isolation) + config.DefaultTransactionReadOnly = true + config.Autocommit = autocommit + conn := mustConnect(t, config) + defer closeConn(t, conn) + want := map[fbx.TxIsoLevel]int{fbx.ReadCommitted: 4, fbx.RepeatableRead: 1, fbx.Serializable: 0}[isolation] + if isolation == fbx.ReadCommitted && conn.ServerVersion().Major <= 3 { + want = 2 + } + + var iso, readOnly, lockTimeout int + for _, mode := range []fbx.QueryExecMode{fbx.QueryExecModeCacheStatement, fbx.QueryExecModeExec} { + require.NoError(t, conn.QueryRow(ctx, query, mode).Scan(&iso, &readOnly, &lockTimeout)) + require.Equal(t, want, iso) + require.Equal(t, 1, readOnly) + } + if !autocommit { + require.NoError(t, conn.Commit(ctx)) + } + + for _, opts := range []fbx.TxOptions{ + {}, + {AccessMode: fbx.ReadOnly, LockTimeout: 7 * time.Second}, + {IsoLevel: fbx.RepeatableRead}, + } { + tx, err := conn.BeginTx(ctx, opts) + require.NoError(t, err) + func() { + defer func() { require.NoError(t, tx.Rollback(ctx)) }() + require.NoError(t, tx.QueryRow(ctx, query).Scan(&iso, &readOnly, &lockTimeout)) + if opts.IsoLevel != "" { + require.Equal(t, 1, iso) + } else { + require.Equal(t, want, iso) + } + if opts.AccessMode == fbx.ReadOnly { + require.Equal(t, 1, readOnly) + require.Equal(t, 7, lockTimeout) + } else { + require.Zero(t, readOnly, "implicit read-only setting must not change explicit transactions") + } + }() + } + + for _, raw := range [][]byte{nil, {}, {fbproto.Isc_tpb_version3, fbproto.Isc_tpb_concurrency}} { + tx, err := conn.BeginTxTPB(ctx, raw) + require.NoError(t, err) + func() { + defer func() { require.NoError(t, tx.Rollback(ctx)) }() + require.NoError(t, tx.QueryRow(ctx, query).Scan(&iso, &readOnly, &lockTimeout)) + require.Equal(t, 1, iso, "raw TPB must preserve server defaults") + require.Zero(t, readOnly) + }() + } + }) + } + } +} diff --git a/fbconn/config.go b/fbconn/config.go index b08e25c4..686ca824 100644 --- a/fbconn/config.go +++ b/fbconn/config.go @@ -49,12 +49,18 @@ type Config struct { DPB []byte ClientVersion string DefaultTransactionReadOnly bool - Autocommit bool - BlobBufferSize int - UseStreamBlobs bool - MaxInlineBlobSize int - MaxBlobCacheSize int - FetchBatchSize int + // DefaultTransactionIsolation is "serializable", "repeatable read", or + // "read committed". Empty preserves the server default. It applies to + // implicit transactions (including autocommit) and transaction APIs called + // without an explicit isolation level. Raw TPBs and SQL transaction commands + // are passed through unchanged. + DefaultTransactionIsolation string + Autocommit bool + BlobBufferSize int + UseStreamBlobs bool + MaxInlineBlobSize int + MaxBlobCacheSize int + FetchBatchSize int // ConstructorOptions allows to pass callbacks for setting parameters to authentication plugins. ConstructorOptions map[string][]auth.ConstructorOption @@ -336,18 +342,22 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con BuildContextWatcherHandler: func(fbConn *FbConn) ctxwatch.Handler { return &CancelRequestContextWatcherHandler{Conn: fbConn} }, - OnFbError: defaultOnFbError, - AuthPluginList: pluginList, - WireCrypt: convertToBool(settings["wire_crypt"], true), - WireCompression: convertToBool(settings["wire_compression"], false), - SystemUser: settings["system_user"], - SystemHost: settings["system_host"], - ClientVersion: settings["client_version"], - Encoding: settings["encoding"], - DefaultTransactionReadOnly: convertToBool(settings["default_transaction_read_only"], false), - Autocommit: convertToBool(settings["autocommit"], true), - UseStreamBlobs: convertToBool(settings["use_stream_blobs"], true), - FetchBatchSize: DefaultFetchBatchSize, + OnFbError: defaultOnFbError, + AuthPluginList: pluginList, + WireCrypt: convertToBool(settings["wire_crypt"], true), + WireCompression: convertToBool(settings["wire_compression"], false), + SystemUser: settings["system_user"], + SystemHost: settings["system_host"], + ClientVersion: settings["client_version"], + Encoding: settings["encoding"], + DefaultTransactionReadOnly: convertToBool(settings["default_transaction_read_only"], false), + DefaultTransactionIsolation: strings.ToLower(strings.TrimSpace(settings["default_transaction_isolation"])), + Autocommit: convertToBool(settings["autocommit"], true), + UseStreamBlobs: convertToBool(settings["use_stream_blobs"], true), + FetchBatchSize: DefaultFetchBatchSize, + } + if _, err := defaultTransactionTPB(config.DefaultTransactionIsolation, false); err != nil { + return nil, &ParseConfigError{ConnString: connString, msg: "invalid default_transaction_isolation", err: err} } if s, ok := settings["max_inline_blob_size"]; ok { value, err := parsePositiveIntSetting(s) @@ -415,6 +425,7 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con "client_version": {}, "encoding": {}, "default_transaction_read_only": {}, + "default_transaction_isolation": {}, "autocommit": {}, "blob_buffer_size": {}, "use_stream_blobs": {}, diff --git a/fbconn/config_test.go b/fbconn/config_test.go index b35d721d..dfeebac8 100644 --- a/fbconn/config_test.go +++ b/fbconn/config_test.go @@ -674,6 +674,7 @@ func assertConfigsEqual(t *testing.T, expected, actual *fbconn.Config, testName assert.Equalf(t, expected.Password, actual.Password, "%s - Password", testName) assert.Equalf(t, expected.ConnectTimeout, actual.ConnectTimeout, "%s - ConnectTimeout", testName) assert.Equalf(t, expected.WireCompression, actual.WireCompression, "%s - WireCompression", testName) + assert.Equalf(t, expected.DefaultTransactionIsolation, actual.DefaultTransactionIsolation, "%s - DefaultTransactionIsolation", testName) assert.Equalf(t, expected.RuntimeParams, actual.RuntimeParams, "%s - RuntimeParams", testName) expectedFetchBatchSize := expected.FetchBatchSize if expectedFetchBatchSize == 0 { diff --git a/fbconn/fbconn.go b/fbconn/fbconn.go index ab6073d3..3c5a6f0a 100644 --- a/fbconn/fbconn.go +++ b/fbconn/fbconn.go @@ -247,6 +247,9 @@ func connectConfig(ctx context.Context, config *Config, target connectTarget) (* if !config.createdByParseConfig { panic("config must be created by ParseConfig") } + if _, err := defaultTransactionTPB(config.DefaultTransactionIsolation, false); err != nil { + return nil, &ConnectError{Config: config, err: err} + } var allErrors []error @@ -3269,17 +3272,14 @@ func Construct(hc *HijackedConn) (*FbConn, error) { func (fbConn *FbConn) ensureInternalTransaction(ctx context.Context, tpb []byte, locked bool) (*FBTransaction, error) { if fbConn.internalTransaction == nil || fbConn.internalTransaction.Closed { - var txTpb []byte - if tpb != nil { - txTpb = tpb - } else { - if fbConn.config.DefaultTransactionReadOnly { - w := fbproto.NewTPBWriterV3() - w.PutTag(fbproto.Isc_tpb_read) - txTpb = w.Bytes() + if tpb == nil { + var err error + tpb, err = defaultTransactionTPB(fbConn.config.DefaultTransactionIsolation, fbConn.config.DefaultTransactionReadOnly) + if err != nil { + return nil, err } } - tx, err := fbConn.startTransactionTPB(ctx, txTpb, locked) + tx, err := fbConn.startTransactionTPB(ctx, tpb, locked) if err != nil { return nil, err } @@ -3289,12 +3289,18 @@ func (fbConn *FbConn) ensureInternalTransaction(ctx context.Context, tpb []byte, return fbConn.internalTransaction, nil } -// StartTransaction starts new transaction not bound to connection +// StartTransaction starts a transaction not bound to the connection, using +// its default isolation setting. func (fbConn *FbConn) StartTransaction(ctx context.Context) (*FBTransaction, error) { - return fbConn.StartTransactionTPB(ctx, nil) + tpb, err := defaultTransactionTPB(fbConn.config.DefaultTransactionIsolation, false) + if err != nil { + return nil, err + } + return fbConn.StartTransactionTPB(ctx, tpb) } -// StartTransactionTPB starts new transaction not bound to connection with TPB block +// StartTransactionTPB starts a transaction not bound to the connection. The TPB +// is passed to the server as-is, including nil or empty TPBs. func (fbConn *FbConn) StartTransactionTPB(ctx context.Context, tpb []byte) (*FBTransaction, error) { return fbConn.startTransactionTPB(ctx, tpb, false) } diff --git a/fbconn/transaction_options.go b/fbconn/transaction_options.go new file mode 100644 index 00000000..612ab142 --- /dev/null +++ b/fbconn/transaction_options.go @@ -0,0 +1,30 @@ +package fbconn + +import ( + "fmt" + + "github.com/firebirdsql/fbx/fbproto" +) + +func defaultTransactionTPB(isolation string, readOnly bool) ([]byte, error) { + if isolation == "" && !readOnly { + return nil, nil + } + tpb := fbproto.NewTPBWriterV3() + if readOnly { + tpb.PutTag(fbproto.Isc_tpb_read) + } + switch isolation { + case "": + case "serializable": + tpb.PutTag(fbproto.Isc_tpb_consistency) + case "repeatable read": + tpb.PutTag(fbproto.Isc_tpb_concurrency) + case "read committed": + tpb.PutTag(fbproto.Isc_tpb_read_committed) + tpb.PutTag(fbproto.Isc_tpb_rec_version) + default: + return nil, fmt.Errorf("unknown default transaction isolation: %q", isolation) + } + return tpb.Bytes(), nil +} diff --git a/fbconn/transaction_options_test.go b/fbconn/transaction_options_test.go new file mode 100644 index 00000000..57e20e57 --- /dev/null +++ b/fbconn/transaction_options_test.go @@ -0,0 +1,82 @@ +package fbconn + +import ( + "context" + "net" + "testing" + + "github.com/firebirdsql/fbx/fbproto" + "github.com/stretchr/testify/require" +) + +func TestDefaultTransactionTPB(t *testing.T) { + for _, tt := range []struct { + isolation string + tags []byte + }{ + {"", nil}, + {"serializable", []byte{fbproto.Isc_tpb_consistency}}, + {"repeatable read", []byte{fbproto.Isc_tpb_concurrency}}, + {"read committed", []byte{fbproto.Isc_tpb_read_committed, fbproto.Isc_tpb_rec_version}}, + } { + for _, readOnly := range []bool{false, true} { + tpb, err := defaultTransactionTPB(tt.isolation, readOnly) + require.NoError(t, err) + var expected []byte + if readOnly || tt.isolation != "" { + expected = []byte{fbproto.Isc_tpb_version3} + if readOnly { + expected = append(expected, fbproto.Isc_tpb_read) + } + expected = append(expected, tt.tags...) + } + require.Equal(t, expected, tpb, "isolation=%q readOnly=%t", tt.isolation, readOnly) + } + } + _, err := defaultTransactionTPB("invalid", false) + require.Error(t, err) +} + +func TestParseConfigDefaultTransactionIsolation(t *testing.T) { + for _, tt := range []struct { + connString string + isolation string + }{ + {"", ""}, + {"default_transaction_isolation=''", ""}, + {"default_transaction_isolation='read committed'", "read committed"}, + {"default_transaction_isolation=' REPEATABLE READ '", "repeatable read"}, + {"default_transaction_isolation=serializable", "serializable"}, + {"firebird://localhost/test?default_transaction_isolation=read%20committed", "read committed"}, + } { + t.Run(tt.connString, func(t *testing.T) { + config, err := ParseConfig(tt.connString) + require.NoError(t, err) + require.Equal(t, tt.isolation, config.DefaultTransactionIsolation) + require.Equal(t, tt.isolation, config.Copy().DefaultTransactionIsolation) + require.NotContains(t, config.RuntimeParams, "default_transaction_isolation") + }) + } + for _, value := range []string{"read uncommitted", "snapshot", "invalid"} { + config, err := ParseConfig("default_transaction_isolation='" + value + "'") + require.Nil(t, config) + var parseErr *ParseConfigError + require.ErrorAs(t, err, &parseErr) + require.Contains(t, err.Error(), "default_transaction_isolation") + } +} + +func TestConnectRejectsInvalidDefaultTransactionIsolation(t *testing.T) { + config, err := ParseConfig("") + require.NoError(t, err) + config.DefaultTransactionIsolation = "invalid" + config.DialFunc = func(context.Context, string, string) (net.Conn, error) { + t.Fatal("invalid isolation must be rejected before dialing") + return nil, nil + } + conn, err := ConnectConfig(context.Background(), config) + require.Nil(t, conn) + var connectErr *ConnectError + require.ErrorAs(t, err, &connectErr) + require.ErrorContains(t, err, "unknown default transaction isolation") +} diff --git a/fbservice/backup_test.go b/fbservice/backup_test.go index c47718b1..b8b6dcb7 100644 --- a/fbservice/backup_test.go +++ b/fbservice/backup_test.go @@ -254,6 +254,7 @@ func TestManagerClearsDatabaseOnlyConnectionSettings(t *testing.T) { "host=localhost user=sysdba password=masterkey database=employee " + "create_database=true target_session_attrs=read-write " + "default_transaction_read_only=true application_name=fbservice-test " + + "default_transaction_isolation='read committed' " + "autocommit=true blob_buffer_size=1 use_stream_blobs=true " + "max_inline_blob_size=1 max_blob_cache_size=1 fetch_batch_size=1", ) @@ -375,6 +376,7 @@ func requireDatabaseConnectionSettingsCleared(t *testing.T, config *fbconn.Confi require.Empty(t, config.Database) require.False(t, config.CreateDatabase) require.False(t, config.DefaultTransactionReadOnly) + require.Empty(t, config.DefaultTransactionIsolation) require.False(t, config.Autocommit) require.Zero(t, config.BlobBufferSize) require.False(t, config.UseStreamBlobs) diff --git a/fbservice/config.go b/fbservice/config.go index 9fb6bb7d..a86717a0 100644 --- a/fbservice/config.go +++ b/fbservice/config.go @@ -141,6 +141,7 @@ func scrubDatabaseConnectionSettings(config *fbconn.Config) { config.Database = "" config.CreateDatabase = false config.DefaultTransactionReadOnly = false + config.DefaultTransactionIsolation = "" config.Autocommit = false config.BlobBufferSize = 0 config.UseStreamBlobs = false diff --git a/stdlib/default_transaction_test.go b/stdlib/default_transaction_test.go new file mode 100644 index 00000000..0ac632d3 --- /dev/null +++ b/stdlib/default_transaction_test.go @@ -0,0 +1,62 @@ +package stdlib_test + +import ( + "context" + "database/sql" + "os" + "testing" + "time" + + "github.com/firebirdsql/fbx" + "github.com/firebirdsql/fbx/stdlib" + "github.com/stretchr/testify/require" +) + +func TestDefaultTransactionIsolation(t *testing.T) { + if os.Getenv("FBX_TEST_DATABASE") == "" { + t.Skip("FBX_TEST_DATABASE is not set") + } + ctx, cancel := context.WithTimeout(context.Background(), time.Minute) + defer cancel() + const query = "select mon$isolation_mode, mon$read_only from mon$transactions where mon$transaction_id = current_transaction" + for _, mode := range []fbx.QueryExecMode{fbx.QueryExecModeCacheStatement, fbx.QueryExecModeExec} { + for _, isolation := range []string{"read committed", "repeatable read", "serializable"} { + t.Run(mode.String()+"/"+isolation, func(t *testing.T) { + config, err := fbx.ParseConfig(os.Getenv("FBX_TEST_DATABASE")) + require.NoError(t, err) + config.DefaultTransactionIsolation = isolation + config.DefaultQueryExecMode = mode + db := stdlib.OpenDB(*config) + defer closeDB(t, db) + db.SetMaxOpenConns(1) + want := map[string]int{"read committed": 4, "repeatable read": 1, "serializable": 0}[isolation] + if isolation == "read committed" && getServerMajorVersion(t, db) <= 3 { + want = 2 + } + var iso, readOnly int + require.NoError(t, db.QueryRowContext(ctx, query).Scan(&iso, &readOnly)) + require.Equal(t, want, iso) + for _, opts := range []*sql.TxOptions{nil, {}, {ReadOnly: true}, {Isolation: sql.LevelRepeatableRead}} { + tx, err := db.BeginTx(ctx, opts) + require.NoError(t, err) + func() { + defer func() { require.NoError(t, tx.Rollback()) }() + require.NoError(t, tx.QueryRowContext(ctx, query).Scan(&iso, &readOnly)) + if opts != nil && opts.Isolation == sql.LevelRepeatableRead { + require.Equal(t, 1, iso) + } else { + require.Equal(t, want, iso) + } + if opts != nil && opts.ReadOnly { + require.Equal(t, 1, readOnly) + } else { + require.Zero(t, readOnly) + } + }() + } + require.NoError(t, db.QueryRowContext(ctx, query).Scan(&iso, &readOnly)) + require.Equal(t, want, iso, "explicit override must not change the connection default") + }) + } + } +} diff --git a/stdlib/sql.go b/stdlib/sql.go index c690c62e..5b0c70db 100644 --- a/stdlib/sql.go +++ b/stdlib/sql.go @@ -529,14 +529,14 @@ func (c *Conn) Close() error { return c.close(ctx) } -// Begin implements [driver.Conn] using the server's default transaction +// Begin implements [driver.Conn] using the connection's default transaction // options and a background context. func (c *Conn) Begin() (driver.Tx, error) { return c.BeginTx(context.Background(), driver.TxOptions{}) } -// BeginTx implements [driver.ConnBeginTx]. LevelDefault preserves the server -// default; repeatable-read and snapshot both map to Firebird concurrency mode. +// BeginTx implements [driver.ConnBeginTx]. LevelDefault uses the connection's +// default isolation; repeatable-read and snapshot map to Firebird concurrency mode. func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { if c.conn.IsClosed() { return nil, driver.ErrBadConn @@ -545,7 +545,7 @@ func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e var fbxOpts fbx.TxOptions switch sql.IsolationLevel(opts.Isolation) { case sql.LevelDefault: - // Empty options preserve the server and database defaults. + // An empty IsoLevel inherits the connection's default isolation. case sql.LevelReadCommitted: fbxOpts.IsoLevel = fbx.ReadCommitted case sql.LevelRepeatableRead, sql.LevelSnapshot: diff --git a/tx.go b/tx.go index 03cdea87..6fa45e42 100644 --- a/tx.go +++ b/tx.go @@ -56,7 +56,11 @@ func (c *Conn) Begin(ctx context.Context) (Tx, error) { // BeginTx starts a transaction with txOptions determining the transaction mode. Unlike database/sql, the context only // affects the begin command. i.e. there is no auto-rollback on context cancellation. +// An empty IsoLevel uses the connection's DefaultTransactionIsolation setting. func (c *Conn) BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error) { + if txOptions.IsoLevel == "" { + txOptions.IsoLevel = TxIsoLevel(c.config.DefaultTransactionIsolation) + } tpb, err := txOptions.GetTPB() if err != nil { return nil, err From 8c9a8c6c015dd7e788dbc2593c4860f6e506c8fc Mon Sep 17 00:00:00 2001 From: MrTeeett Date: Tue, 17 Nov 2026 21:17:28 +0300 Subject: [PATCH 2/4] Add shared isolation constants and aliases. --- README.md | 3 ++- fbconn/config.go | 5 +++-- fbconn/transaction_options.go | 16 ++++++++++++---- fbconn/transaction_options_test.go | 9 ++++++++- tx.go | 10 ++++++---- tx_internal_test.go | 18 ++++++++++++++++++ 6 files changed, 49 insertions(+), 12 deletions(-) diff --git a/README.md b/README.md index ee8ddf60..6e6901e7 100644 --- a/README.md +++ b/README.md @@ -91,7 +91,8 @@ Wire compression is disabled by default. Enable it with `wire_compression=true` Set `default_transaction_isolation='read committed'` in a keyword/value connection string, or `?default_transaction_isolation=read%20committed` in a URL, to choose the default transaction isolation. Supported values are `read committed`, -`repeatable read`, and `serializable`; an empty value preserves the server default. +`repeatable read`, and `serializable`. The aliases `read_committed` and +`repeatable_read` are also accepted; an empty value preserves the server default. The setting also applies to autocommit, `Begin`, and `database/sql` transactions using `sql.LevelDefault`. An explicit `TxOptions.IsoLevel` or `sql.TxOptions.Isolation` overrides it. Raw TPBs passed to `BeginTxTPB` or `StartTransactionTPB` are unchanged. diff --git a/fbconn/config.go b/fbconn/config.go index 686ca824..94ea3ae6 100644 --- a/fbconn/config.go +++ b/fbconn/config.go @@ -49,8 +49,9 @@ type Config struct { DPB []byte ClientVersion string DefaultTransactionReadOnly bool - // DefaultTransactionIsolation is "serializable", "repeatable read", or - // "read committed". Empty preserves the server default. It applies to + // DefaultTransactionIsolation is [Serializable], [RepeatableRead], or + // [ReadCommitted]. The aliases "repeatable_read" and "read_committed" are + // also accepted. Empty preserves the server default. It applies to // implicit transactions (including autocommit) and transaction APIs called // without an explicit isolation level. Raw TPBs and SQL transaction commands // are passed through unchanged. diff --git a/fbconn/transaction_options.go b/fbconn/transaction_options.go index 612ab142..f4b836d0 100644 --- a/fbconn/transaction_options.go +++ b/fbconn/transaction_options.go @@ -2,10 +2,18 @@ package fbconn import ( "fmt" + "strings" "github.com/firebirdsql/fbx/fbproto" ) +// Transaction isolation levels accepted by Config.DefaultTransactionIsolation. +const ( + Serializable = "serializable" + RepeatableRead = "repeatable read" + ReadCommitted = "read committed" +) + func defaultTransactionTPB(isolation string, readOnly bool) ([]byte, error) { if isolation == "" && !readOnly { return nil, nil @@ -14,13 +22,13 @@ func defaultTransactionTPB(isolation string, readOnly bool) ([]byte, error) { if readOnly { tpb.PutTag(fbproto.Isc_tpb_read) } - switch isolation { + switch strings.ReplaceAll(isolation, "_", " ") { case "": - case "serializable": + case Serializable: tpb.PutTag(fbproto.Isc_tpb_consistency) - case "repeatable read": + case RepeatableRead: tpb.PutTag(fbproto.Isc_tpb_concurrency) - case "read committed": + case ReadCommitted: tpb.PutTag(fbproto.Isc_tpb_read_committed) tpb.PutTag(fbproto.Isc_tpb_rec_version) default: diff --git a/fbconn/transaction_options_test.go b/fbconn/transaction_options_test.go index 57e20e57..eea842a2 100644 --- a/fbconn/transaction_options_test.go +++ b/fbconn/transaction_options_test.go @@ -18,6 +18,8 @@ func TestDefaultTransactionTPB(t *testing.T) { {"serializable", []byte{fbproto.Isc_tpb_consistency}}, {"repeatable read", []byte{fbproto.Isc_tpb_concurrency}}, {"read committed", []byte{fbproto.Isc_tpb_read_committed, fbproto.Isc_tpb_rec_version}}, + {"repeatable_read", []byte{fbproto.Isc_tpb_concurrency}}, + {"read_committed", []byte{fbproto.Isc_tpb_read_committed, fbproto.Isc_tpb_rec_version}}, } { for _, readOnly := range []bool{false, true} { tpb, err := defaultTransactionTPB(tt.isolation, readOnly) @@ -47,7 +49,12 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { {"default_transaction_isolation='read committed'", "read committed"}, {"default_transaction_isolation=' REPEATABLE READ '", "repeatable read"}, {"default_transaction_isolation=serializable", "serializable"}, + {"default_transaction_isolation=read_committed", "read_committed"}, + {"default_transaction_isolation=repeatable_read", "repeatable_read"}, + {"default_transaction_isolation=' READ_COMMITTED '", "read_committed"}, {"firebird://localhost/test?default_transaction_isolation=read%20committed", "read committed"}, + {"firebird://localhost/test?default_transaction_isolation=read_committed", "read_committed"}, + {"firebird://localhost/test?default_transaction_isolation=repeatable_read", "repeatable_read"}, } { t.Run(tt.connString, func(t *testing.T) { config, err := ParseConfig(tt.connString) @@ -57,7 +64,7 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { require.NotContains(t, config.RuntimeParams, "default_transaction_isolation") }) } - for _, value := range []string{"read uncommitted", "snapshot", "invalid"} { + for _, value := range []string{"read uncommitted", "read_uncommitted", "read__committed", "snapshot", "invalid"} { config, err := ParseConfig("default_transaction_isolation='" + value + "'") require.Nil(t, config) var parseErr *ParseConfigError diff --git a/tx.go b/tx.go index 6fa45e42..57683352 100644 --- a/tx.go +++ b/tx.go @@ -5,6 +5,7 @@ import ( "errors" "fmt" "strconv" + "strings" "time" "github.com/firebirdsql/fbx/fbconn" @@ -13,13 +14,14 @@ import ( ) // TxIsoLevel is the transaction isolation level ([fbx.Serializable], [fbx.RepeatableRead], [fbx.ReadCommitted]) +// The strings "repeatable_read" and "read_committed" are accepted aliases. type TxIsoLevel string // Transaction isolation levels const ( - Serializable TxIsoLevel = "serializable" - RepeatableRead TxIsoLevel = "repeatable read" - ReadCommitted TxIsoLevel = "read committed" + Serializable TxIsoLevel = fbconn.Serializable + RepeatableRead TxIsoLevel = fbconn.RepeatableRead + ReadCommitted TxIsoLevel = fbconn.ReadCommitted ) // TxAccessMode is the transaction access mode ([fbx.ReadWrite], [fbx.ReadOnly]) @@ -124,7 +126,7 @@ func (txOptions TxOptions) GetTPB() ([]byte, error) { } if txOptions.IsoLevel != "" { - switch txOptions.IsoLevel { + switch TxIsoLevel(strings.ReplaceAll(string(txOptions.IsoLevel), "_", " ")) { case Serializable: tpb.PutTag(fbproto.Isc_tpb_consistency) case RepeatableRead: diff --git a/tx_internal_test.go b/tx_internal_test.go index e6a693ea..6e518467 100644 --- a/tx_internal_test.go +++ b/tx_internal_test.go @@ -43,6 +43,24 @@ func TestNormalizeTxLockTimeout(t *testing.T) { func TestGetTPB(t *testing.T) { t.Parallel() + t.Run("isolation aliases preserve transaction options", func(t *testing.T) { + for _, tt := range []struct { + alias TxIsoLevel + canonical TxIsoLevel + }{ + {"read_committed", ReadCommitted}, + {"repeatable_read", RepeatableRead}, + } { + for _, accessMode := range []TxAccessMode{"", ReadOnly, ReadWrite} { + want, err := (TxOptions{IsoLevel: tt.canonical, AccessMode: accessMode, LockTimeout: 7 * time.Second}).GetTPB() + require.NoError(t, err) + got, err := (TxOptions{IsoLevel: tt.alias, AccessMode: accessMode, LockTimeout: 7 * time.Second}).GetTPB() + require.NoError(t, err) + require.Equal(t, want, got, "isolation=%q accessMode=%q", tt.alias, accessMode) + } + } + }) + t.Run("no options means nil tpb", func(t *testing.T) { tpb, err := TxOptions{}.GetTPB() require.NoError(t, err) From bbd9584d11fb0f18c14da11bf43d4ecf85527c9e Mon Sep 17 00:00:00 2001 From: MrTeeett Date: Wed, 18 Nov 2026 12:58:03 +0300 Subject: [PATCH 3/4] Use underscore-separated transaction isolation values Accept read_committed, repeatable_read and serializable consistently across connection settings and transaction options. Validate isolation before assigning it to Config and document that an empty value preserves the server's default isolation. --- README.md | 9 +++---- fbconn/config.go | 38 ++++++++++++++-------------- fbconn/fbconn.go | 3 ++- fbconn/transaction_options.go | 7 +++--- fbconn/transaction_options_test.go | 40 ++++++++++++++++-------------- fbservice/backup_test.go | 2 +- stdlib/default_transaction_test.go | 6 ++--- stdlib/sql.go | 11 ++++---- tx.go | 16 ++++++------ tx_internal_test.go | 19 +++----------- 10 files changed, 71 insertions(+), 80 deletions(-) diff --git a/README.md b/README.md index 6e6901e7..bbb75f90 100644 --- a/README.md +++ b/README.md @@ -88,11 +88,10 @@ See documentation and more usage examples at https://pkg.go.dev/github.com/fireb Wire compression is disabled by default. Enable it with `wire_compression=true` in the connection string (`wire_compress` and `wireCompression` are accepted aliases) or with `FBWIRECOMPRESSION=true`. -Set `default_transaction_isolation='read committed'` in a keyword/value connection -string, or `?default_transaction_isolation=read%20committed` in a URL, to choose -the default transaction isolation. Supported values are `read committed`, -`repeatable read`, and `serializable`. The aliases `read_committed` and -`repeatable_read` are also accepted; an empty value preserves the server default. +Set `default_transaction_isolation=read_committed` in a keyword/value connection +string, or `?default_transaction_isolation=read_committed` in a URL, to choose +the default transaction isolation. Supported values are `read_committed`, +`repeatable_read`, and `serializable`; an empty value preserves the server default. The setting also applies to autocommit, `Begin`, and `database/sql` transactions using `sql.LevelDefault`. An explicit `TxOptions.IsoLevel` or `sql.TxOptions.Isolation` overrides it. Raw TPBs passed to `BeginTxTPB` or `StartTransactionTPB` are unchanged. diff --git a/fbconn/config.go b/fbconn/config.go index 94ea3ae6..807c45b7 100644 --- a/fbconn/config.go +++ b/fbconn/config.go @@ -50,8 +50,7 @@ type Config struct { ClientVersion string DefaultTransactionReadOnly bool // DefaultTransactionIsolation is [Serializable], [RepeatableRead], or - // [ReadCommitted]. The aliases "repeatable_read" and "read_committed" are - // also accepted. Empty preserves the server default. It applies to + // [ReadCommitted]. Empty preserves the server default. It applies to // implicit transactions (including autocommit) and transaction APIs called // without an explicit isolation level. Raw TPBs and SQL transaction commands // are passed through unchanged. @@ -343,22 +342,25 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con BuildContextWatcherHandler: func(fbConn *FbConn) ctxwatch.Handler { return &CancelRequestContextWatcherHandler{Conn: fbConn} }, - OnFbError: defaultOnFbError, - AuthPluginList: pluginList, - WireCrypt: convertToBool(settings["wire_crypt"], true), - WireCompression: convertToBool(settings["wire_compression"], false), - SystemUser: settings["system_user"], - SystemHost: settings["system_host"], - ClientVersion: settings["client_version"], - Encoding: settings["encoding"], - DefaultTransactionReadOnly: convertToBool(settings["default_transaction_read_only"], false), - DefaultTransactionIsolation: strings.ToLower(strings.TrimSpace(settings["default_transaction_isolation"])), - Autocommit: convertToBool(settings["autocommit"], true), - UseStreamBlobs: convertToBool(settings["use_stream_blobs"], true), - FetchBatchSize: DefaultFetchBatchSize, - } - if _, err := defaultTransactionTPB(config.DefaultTransactionIsolation, false); err != nil { - return nil, &ParseConfigError{ConnString: connString, msg: "invalid default_transaction_isolation", err: err} + OnFbError: defaultOnFbError, + AuthPluginList: pluginList, + WireCrypt: convertToBool(settings["wire_crypt"], true), + WireCompression: convertToBool(settings["wire_compression"], false), + SystemUser: settings["system_user"], + SystemHost: settings["system_host"], + ClientVersion: settings["client_version"], + Encoding: settings["encoding"], + DefaultTransactionReadOnly: convertToBool(settings["default_transaction_read_only"], false), + Autocommit: convertToBool(settings["autocommit"], true), + UseStreamBlobs: convertToBool(settings["use_stream_blobs"], true), + FetchBatchSize: DefaultFetchBatchSize, + } + if s, ok := settings["default_transaction_isolation"]; ok { + s = strings.ToLower(strings.TrimSpace(s)) + if _, err := defaultTransactionTPB(s, false); err != nil { + return nil, &ParseConfigError{ConnString: connString, msg: "invalid default_transaction_isolation", err: err} + } + config.DefaultTransactionIsolation = s } if s, ok := settings["max_inline_blob_size"]; ok { value, err := parsePositiveIntSetting(s) diff --git a/fbconn/fbconn.go b/fbconn/fbconn.go index 3c5a6f0a..38049fe6 100644 --- a/fbconn/fbconn.go +++ b/fbconn/fbconn.go @@ -3290,7 +3290,8 @@ func (fbConn *FbConn) ensureInternalTransaction(ctx context.Context, tpb []byte, } // StartTransaction starts a transaction not bound to the connection, using -// its default isolation setting. +// DefaultTransactionIsolation, or the server's default isolation if the setting +// is empty. func (fbConn *FbConn) StartTransaction(ctx context.Context) (*FBTransaction, error) { tpb, err := defaultTransactionTPB(fbConn.config.DefaultTransactionIsolation, false) if err != nil { diff --git a/fbconn/transaction_options.go b/fbconn/transaction_options.go index f4b836d0..a6ba091d 100644 --- a/fbconn/transaction_options.go +++ b/fbconn/transaction_options.go @@ -2,7 +2,6 @@ package fbconn import ( "fmt" - "strings" "github.com/firebirdsql/fbx/fbproto" ) @@ -10,8 +9,8 @@ import ( // Transaction isolation levels accepted by Config.DefaultTransactionIsolation. const ( Serializable = "serializable" - RepeatableRead = "repeatable read" - ReadCommitted = "read committed" + RepeatableRead = "repeatable_read" + ReadCommitted = "read_committed" ) func defaultTransactionTPB(isolation string, readOnly bool) ([]byte, error) { @@ -22,7 +21,7 @@ func defaultTransactionTPB(isolation string, readOnly bool) ([]byte, error) { if readOnly { tpb.PutTag(fbproto.Isc_tpb_read) } - switch strings.ReplaceAll(isolation, "_", " ") { + switch isolation { case "": case Serializable: tpb.PutTag(fbproto.Isc_tpb_consistency) diff --git a/fbconn/transaction_options_test.go b/fbconn/transaction_options_test.go index eea842a2..ca4d401e 100644 --- a/fbconn/transaction_options_test.go +++ b/fbconn/transaction_options_test.go @@ -16,8 +16,6 @@ func TestDefaultTransactionTPB(t *testing.T) { }{ {"", nil}, {"serializable", []byte{fbproto.Isc_tpb_consistency}}, - {"repeatable read", []byte{fbproto.Isc_tpb_concurrency}}, - {"read committed", []byte{fbproto.Isc_tpb_read_committed, fbproto.Isc_tpb_rec_version}}, {"repeatable_read", []byte{fbproto.Isc_tpb_concurrency}}, {"read_committed", []byte{fbproto.Isc_tpb_read_committed, fbproto.Isc_tpb_rec_version}}, } { @@ -35,8 +33,10 @@ func TestDefaultTransactionTPB(t *testing.T) { require.Equal(t, expected, tpb, "isolation=%q readOnly=%t", tt.isolation, readOnly) } } - _, err := defaultTransactionTPB("invalid", false) - require.Error(t, err) + for _, isolation := range []string{"invalid", "read committed", "repeatable read"} { + _, err := defaultTransactionTPB(isolation, false) + require.Error(t, err, "isolation=%q", isolation) + } } func TestParseConfigDefaultTransactionIsolation(t *testing.T) { @@ -46,13 +46,11 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { }{ {"", ""}, {"default_transaction_isolation=''", ""}, - {"default_transaction_isolation='read committed'", "read committed"}, - {"default_transaction_isolation=' REPEATABLE READ '", "repeatable read"}, + {"default_transaction_isolation=' REPEATABLE_READ '", "repeatable_read"}, {"default_transaction_isolation=serializable", "serializable"}, {"default_transaction_isolation=read_committed", "read_committed"}, {"default_transaction_isolation=repeatable_read", "repeatable_read"}, {"default_transaction_isolation=' READ_COMMITTED '", "read_committed"}, - {"firebird://localhost/test?default_transaction_isolation=read%20committed", "read committed"}, {"firebird://localhost/test?default_transaction_isolation=read_committed", "read_committed"}, {"firebird://localhost/test?default_transaction_isolation=repeatable_read", "repeatable_read"}, } { @@ -64,7 +62,7 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { require.NotContains(t, config.RuntimeParams, "default_transaction_isolation") }) } - for _, value := range []string{"read uncommitted", "read_uncommitted", "read__committed", "snapshot", "invalid"} { + for _, value := range []string{"read committed", "repeatable read", "read uncommitted", "read_uncommitted", "read__committed", "snapshot", "invalid"} { config, err := ParseConfig("default_transaction_isolation='" + value + "'") require.Nil(t, config) var parseErr *ParseConfigError @@ -74,16 +72,20 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { } func TestConnectRejectsInvalidDefaultTransactionIsolation(t *testing.T) { - config, err := ParseConfig("") - require.NoError(t, err) - config.DefaultTransactionIsolation = "invalid" - config.DialFunc = func(context.Context, string, string) (net.Conn, error) { - t.Fatal("invalid isolation must be rejected before dialing") - return nil, nil + for _, isolation := range []string{"invalid", "read committed", "repeatable read"} { + t.Run(isolation, func(t *testing.T) { + config, err := ParseConfig("") + require.NoError(t, err) + config.DefaultTransactionIsolation = isolation + config.DialFunc = func(context.Context, string, string) (net.Conn, error) { + t.Fatal("invalid isolation must be rejected before dialing") + return nil, nil + } + conn, err := ConnectConfig(context.Background(), config) + require.Nil(t, conn) + var connectErr *ConnectError + require.ErrorAs(t, err, &connectErr) + require.ErrorContains(t, err, "unknown default transaction isolation") + }) } - conn, err := ConnectConfig(context.Background(), config) - require.Nil(t, conn) - var connectErr *ConnectError - require.ErrorAs(t, err, &connectErr) - require.ErrorContains(t, err, "unknown default transaction isolation") } diff --git a/fbservice/backup_test.go b/fbservice/backup_test.go index b8b6dcb7..1befd705 100644 --- a/fbservice/backup_test.go +++ b/fbservice/backup_test.go @@ -254,7 +254,7 @@ func TestManagerClearsDatabaseOnlyConnectionSettings(t *testing.T) { "host=localhost user=sysdba password=masterkey database=employee " + "create_database=true target_session_attrs=read-write " + "default_transaction_read_only=true application_name=fbservice-test " + - "default_transaction_isolation='read committed' " + + "default_transaction_isolation=read_committed " + "autocommit=true blob_buffer_size=1 use_stream_blobs=true " + "max_inline_blob_size=1 max_blob_cache_size=1 fetch_batch_size=1", ) diff --git a/stdlib/default_transaction_test.go b/stdlib/default_transaction_test.go index 0ac632d3..cec5cbbf 100644 --- a/stdlib/default_transaction_test.go +++ b/stdlib/default_transaction_test.go @@ -20,7 +20,7 @@ func TestDefaultTransactionIsolation(t *testing.T) { defer cancel() const query = "select mon$isolation_mode, mon$read_only from mon$transactions where mon$transaction_id = current_transaction" for _, mode := range []fbx.QueryExecMode{fbx.QueryExecModeCacheStatement, fbx.QueryExecModeExec} { - for _, isolation := range []string{"read committed", "repeatable read", "serializable"} { + for _, isolation := range []string{"read_committed", "repeatable_read", "serializable"} { t.Run(mode.String()+"/"+isolation, func(t *testing.T) { config, err := fbx.ParseConfig(os.Getenv("FBX_TEST_DATABASE")) require.NoError(t, err) @@ -29,8 +29,8 @@ func TestDefaultTransactionIsolation(t *testing.T) { db := stdlib.OpenDB(*config) defer closeDB(t, db) db.SetMaxOpenConns(1) - want := map[string]int{"read committed": 4, "repeatable read": 1, "serializable": 0}[isolation] - if isolation == "read committed" && getServerMajorVersion(t, db) <= 3 { + want := map[string]int{"read_committed": 4, "repeatable_read": 1, "serializable": 0}[isolation] + if isolation == "read_committed" && getServerMajorVersion(t, db) <= 3 { want = 2 } var iso, readOnly int diff --git a/stdlib/sql.go b/stdlib/sql.go index 5b0c70db..48cbcfea 100644 --- a/stdlib/sql.go +++ b/stdlib/sql.go @@ -529,14 +529,15 @@ func (c *Conn) Close() error { return c.close(ctx) } -// Begin implements [driver.Conn] using the connection's default transaction -// options and a background context. +// Begin implements [driver.Conn] using a background context and the configured +// default isolation, or the server's default isolation if none is configured. func (c *Conn) Begin() (driver.Tx, error) { return c.BeginTx(context.Background(), driver.TxOptions{}) } -// BeginTx implements [driver.ConnBeginTx]. LevelDefault uses the connection's -// default isolation; repeatable-read and snapshot map to Firebird concurrency mode. +// BeginTx implements [driver.ConnBeginTx]. LevelDefault uses the configured default +// isolation, or the server's default if none is configured. Repeatable-read and +// snapshot map to Firebird concurrency mode. func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error) { if c.conn.IsClosed() { return nil, driver.ErrBadConn @@ -545,7 +546,7 @@ func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, e var fbxOpts fbx.TxOptions switch sql.IsolationLevel(opts.Isolation) { case sql.LevelDefault: - // An empty IsoLevel inherits the connection's default isolation. + // An empty IsoLevel uses the configured default isolation, or the server's default. case sql.LevelReadCommitted: fbxOpts.IsoLevel = fbx.ReadCommitted case sql.LevelRepeatableRead, sql.LevelSnapshot: diff --git a/tx.go b/tx.go index 57683352..bd7ef26e 100644 --- a/tx.go +++ b/tx.go @@ -5,7 +5,6 @@ import ( "errors" "fmt" "strconv" - "strings" "time" "github.com/firebirdsql/fbx/fbconn" @@ -13,8 +12,7 @@ import ( "github.com/firebirdsql/fbx/internal/operationerror" ) -// TxIsoLevel is the transaction isolation level ([fbx.Serializable], [fbx.RepeatableRead], [fbx.ReadCommitted]) -// The strings "repeatable_read" and "read_committed" are accepted aliases. +// TxIsoLevel is the transaction isolation level ([fbx.Serializable], [fbx.RepeatableRead], [fbx.ReadCommitted]). type TxIsoLevel string // Transaction isolation levels @@ -50,15 +48,17 @@ var ErrTxClosed = errors.New("tx is closed") // ErrTxCommitRollback indicates that Commit() did not commit changes and the transaction was rolled back instead var ErrTxCommitRollback = errors.New("commit unexpectedly resulted in rollback") -// Begin starts a transaction. Unlike database/sql, the context only affects the begin command. i.e. there is no -// auto-rollback on context cancellation. +// Begin starts a transaction using DefaultTransactionIsolation, or the server's +// default isolation if the setting is empty. Unlike database/sql, the context only +// affects the begin command; there is no auto-rollback on context cancellation. func (c *Conn) Begin(ctx context.Context) (Tx, error) { return c.BeginTx(ctx, TxOptions{}) } // BeginTx starts a transaction with txOptions determining the transaction mode. Unlike database/sql, the context only // affects the begin command. i.e. there is no auto-rollback on context cancellation. -// An empty IsoLevel uses the connection's DefaultTransactionIsolation setting. +// An empty IsoLevel uses the connection's DefaultTransactionIsolation setting, +// or the server's default isolation if that setting is empty. func (c *Conn) BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error) { if txOptions.IsoLevel == "" { txOptions.IsoLevel = TxIsoLevel(c.config.DefaultTransactionIsolation) @@ -104,8 +104,6 @@ func (txOptions TxOptions) GetTPB() ([]byte, error) { return nil, err } - // If no options are specified, use server / database defaults. This matches Firebird semantics and keeps - // database/sql LevelDefault behaving as expected (i.e. do not silently force READ COMMITTED). if txOptions.AccessMode == "" && txOptions.IsoLevel == "" && lockTimeoutSeconds == 0 { return nil, nil } @@ -126,7 +124,7 @@ func (txOptions TxOptions) GetTPB() ([]byte, error) { } if txOptions.IsoLevel != "" { - switch TxIsoLevel(strings.ReplaceAll(string(txOptions.IsoLevel), "_", " ")) { + switch txOptions.IsoLevel { case Serializable: tpb.PutTag(fbproto.Isc_tpb_consistency) case RepeatableRead: diff --git a/tx_internal_test.go b/tx_internal_test.go index 6e518467..9ff82c2a 100644 --- a/tx_internal_test.go +++ b/tx_internal_test.go @@ -43,21 +43,10 @@ func TestNormalizeTxLockTimeout(t *testing.T) { func TestGetTPB(t *testing.T) { t.Parallel() - t.Run("isolation aliases preserve transaction options", func(t *testing.T) { - for _, tt := range []struct { - alias TxIsoLevel - canonical TxIsoLevel - }{ - {"read_committed", ReadCommitted}, - {"repeatable_read", RepeatableRead}, - } { - for _, accessMode := range []TxAccessMode{"", ReadOnly, ReadWrite} { - want, err := (TxOptions{IsoLevel: tt.canonical, AccessMode: accessMode, LockTimeout: 7 * time.Second}).GetTPB() - require.NoError(t, err) - got, err := (TxOptions{IsoLevel: tt.alias, AccessMode: accessMode, LockTimeout: 7 * time.Second}).GetTPB() - require.NoError(t, err) - require.Equal(t, want, got, "isolation=%q accessMode=%q", tt.alias, accessMode) - } + t.Run("spaced isolation names fail", func(t *testing.T) { + for _, isolation := range []TxIsoLevel{"read committed", "repeatable read"} { + _, err := (TxOptions{IsoLevel: isolation}).GetTPB() + require.ErrorContains(t, err, "unknown transaction iso level") } }) From 0c9a0856fbaa30d50f30850ff3b6596013aab826 Mon Sep 17 00:00:00 2001 From: MrTeeett Date: Thu, 19 Nov 2026 12:26:00 +0300 Subject: [PATCH 4/4] Move TxIsoLevel to fbconn and accept spaced DSN aliases. --- README.md | 7 +++++-- default_transaction_test.go | 2 +- fbconn/config.go | 12 +++++++----- fbconn/transaction_options.go | 13 ++++++++----- fbconn/transaction_options_test.go | 17 +++++++++++------ stdlib/default_transaction_test.go | 6 +++--- tx.go | 10 +++++----- tx_internal_test.go | 3 ++- 8 files changed, 42 insertions(+), 28 deletions(-) diff --git a/README.md b/README.md index bbb75f90..114e5ec0 100644 --- a/README.md +++ b/README.md @@ -91,13 +91,16 @@ Wire compression is disabled by default. Enable it with `wire_compression=true` Set `default_transaction_isolation=read_committed` in a keyword/value connection string, or `?default_transaction_isolation=read_committed` in a URL, to choose the default transaction isolation. Supported values are `read_committed`, -`repeatable_read`, and `serializable`; an empty value preserves the server default. +`repeatable_read`, and `serializable`. In connection strings, the aliases +`read committed` and `repeatable read` are also accepted and normalized to the +underscore values; an empty value preserves the server default. The setting also applies to autocommit, `Begin`, and `database/sql` transactions using `sql.LevelDefault`. An explicit `TxOptions.IsoLevel` or `sql.TxOptions.Isolation` overrides it. Raw TPBs passed to `BeginTxTPB` or `StartTransactionTPB` are unchanged. SQL `SET TRANSACTION` statements use the options in the SQL and server defaults for any omitted options. -The same setting is available as `Config.DefaultTransactionIsolation`. +The same setting is available as `Config.DefaultTransactionIsolation`, using +`fbconn.TxIsoLevel` and its constants (`fbx.TxIsoLevel` is an alias). For cursor queries, the driver automatically uses the server's deferred-execute flag from `Prepare`. When supported, `Exec` buffers `Execute`; the first row read sends diff --git a/default_transaction_test.go b/default_transaction_test.go index 10ddab86..91379598 100644 --- a/default_transaction_test.go +++ b/default_transaction_test.go @@ -25,7 +25,7 @@ func TestDefaultTransactionIsolation(t *testing.T) { t.Run(fmt.Sprintf("%s/autocommit=%t", isolation, autocommit), func(t *testing.T) { config, err := fbx.ParseConfig(os.Getenv("FBX_TEST_DATABASE")) require.NoError(t, err) - config.DefaultTransactionIsolation = string(isolation) + config.DefaultTransactionIsolation = isolation config.DefaultTransactionReadOnly = true config.Autocommit = autocommit conn := mustConnect(t, config) diff --git a/fbconn/config.go b/fbconn/config.go index 807c45b7..268a015f 100644 --- a/fbconn/config.go +++ b/fbconn/config.go @@ -50,11 +50,13 @@ type Config struct { ClientVersion string DefaultTransactionReadOnly bool // DefaultTransactionIsolation is [Serializable], [RepeatableRead], or - // [ReadCommitted]. Empty preserves the server default. It applies to + // [ReadCommitted]. Connection strings also accept "repeatable read" and + // "read committed", normalized to the corresponding constants. + // Empty preserves the server default. It applies to // implicit transactions (including autocommit) and transaction APIs called // without an explicit isolation level. Raw TPBs and SQL transaction commands // are passed through unchanged. - DefaultTransactionIsolation string + DefaultTransactionIsolation TxIsoLevel Autocommit bool BlobBufferSize int UseStreamBlobs bool @@ -356,11 +358,11 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con FetchBatchSize: DefaultFetchBatchSize, } if s, ok := settings["default_transaction_isolation"]; ok { - s = strings.ToLower(strings.TrimSpace(s)) - if _, err := defaultTransactionTPB(s, false); err != nil { + isolation := TxIsoLevel(strings.ReplaceAll(strings.ToLower(strings.TrimSpace(s)), " ", "_")) + if _, err := defaultTransactionTPB(isolation, false); err != nil { return nil, &ParseConfigError{ConnString: connString, msg: "invalid default_transaction_isolation", err: err} } - config.DefaultTransactionIsolation = s + config.DefaultTransactionIsolation = isolation } if s, ok := settings["max_inline_blob_size"]; ok { value, err := parsePositiveIntSetting(s) diff --git a/fbconn/transaction_options.go b/fbconn/transaction_options.go index a6ba091d..a55097d9 100644 --- a/fbconn/transaction_options.go +++ b/fbconn/transaction_options.go @@ -6,14 +6,17 @@ import ( "github.com/firebirdsql/fbx/fbproto" ) -// Transaction isolation levels accepted by Config.DefaultTransactionIsolation. +// TxIsoLevel is the transaction isolation level ([Serializable], [RepeatableRead], [ReadCommitted]). +type TxIsoLevel string + +// Transaction isolation levels. const ( - Serializable = "serializable" - RepeatableRead = "repeatable_read" - ReadCommitted = "read_committed" + Serializable TxIsoLevel = "serializable" + RepeatableRead TxIsoLevel = "repeatable_read" + ReadCommitted TxIsoLevel = "read_committed" ) -func defaultTransactionTPB(isolation string, readOnly bool) ([]byte, error) { +func defaultTransactionTPB(isolation TxIsoLevel, readOnly bool) ([]byte, error) { if isolation == "" && !readOnly { return nil, nil } diff --git a/fbconn/transaction_options_test.go b/fbconn/transaction_options_test.go index ca4d401e..dccaefd9 100644 --- a/fbconn/transaction_options_test.go +++ b/fbconn/transaction_options_test.go @@ -11,7 +11,7 @@ import ( func TestDefaultTransactionTPB(t *testing.T) { for _, tt := range []struct { - isolation string + isolation TxIsoLevel tags []byte }{ {"", nil}, @@ -33,7 +33,7 @@ func TestDefaultTransactionTPB(t *testing.T) { require.Equal(t, expected, tpb, "isolation=%q readOnly=%t", tt.isolation, readOnly) } } - for _, isolation := range []string{"invalid", "read committed", "repeatable read"} { + for _, isolation := range []TxIsoLevel{"invalid", "read committed", "repeatable read"} { _, err := defaultTransactionTPB(isolation, false) require.Error(t, err, "isolation=%q", isolation) } @@ -42,17 +42,22 @@ func TestDefaultTransactionTPB(t *testing.T) { func TestParseConfigDefaultTransactionIsolation(t *testing.T) { for _, tt := range []struct { connString string - isolation string + isolation TxIsoLevel }{ {"", ""}, {"default_transaction_isolation=''", ""}, + {"default_transaction_isolation=' '", ""}, {"default_transaction_isolation=' REPEATABLE_READ '", "repeatable_read"}, + {"default_transaction_isolation=' REPEATABLE READ '", "repeatable_read"}, + {"default_transaction_isolation='read committed'", "read_committed"}, {"default_transaction_isolation=serializable", "serializable"}, {"default_transaction_isolation=read_committed", "read_committed"}, {"default_transaction_isolation=repeatable_read", "repeatable_read"}, {"default_transaction_isolation=' READ_COMMITTED '", "read_committed"}, {"firebird://localhost/test?default_transaction_isolation=read_committed", "read_committed"}, {"firebird://localhost/test?default_transaction_isolation=repeatable_read", "repeatable_read"}, + {"firebird://localhost/test?default_transaction_isolation=read%20committed", "read_committed"}, + {"firebird://localhost/test?default_transaction_isolation=repeatable%20read", "repeatable_read"}, } { t.Run(tt.connString, func(t *testing.T) { config, err := ParseConfig(tt.connString) @@ -62,7 +67,7 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { require.NotContains(t, config.RuntimeParams, "default_transaction_isolation") }) } - for _, value := range []string{"read committed", "repeatable read", "read uncommitted", "read_uncommitted", "read__committed", "snapshot", "invalid"} { + for _, value := range []string{"read uncommitted", "read_uncommitted", "read__committed", "read committed", "snapshot", "invalid"} { config, err := ParseConfig("default_transaction_isolation='" + value + "'") require.Nil(t, config) var parseErr *ParseConfigError @@ -72,8 +77,8 @@ func TestParseConfigDefaultTransactionIsolation(t *testing.T) { } func TestConnectRejectsInvalidDefaultTransactionIsolation(t *testing.T) { - for _, isolation := range []string{"invalid", "read committed", "repeatable read"} { - t.Run(isolation, func(t *testing.T) { + for _, isolation := range []TxIsoLevel{"invalid", "read committed", "repeatable read"} { + t.Run(string(isolation), func(t *testing.T) { config, err := ParseConfig("") require.NoError(t, err) config.DefaultTransactionIsolation = isolation diff --git a/stdlib/default_transaction_test.go b/stdlib/default_transaction_test.go index cec5cbbf..546ff143 100644 --- a/stdlib/default_transaction_test.go +++ b/stdlib/default_transaction_test.go @@ -20,8 +20,8 @@ func TestDefaultTransactionIsolation(t *testing.T) { defer cancel() const query = "select mon$isolation_mode, mon$read_only from mon$transactions where mon$transaction_id = current_transaction" for _, mode := range []fbx.QueryExecMode{fbx.QueryExecModeCacheStatement, fbx.QueryExecModeExec} { - for _, isolation := range []string{"read_committed", "repeatable_read", "serializable"} { - t.Run(mode.String()+"/"+isolation, func(t *testing.T) { + for _, isolation := range []fbx.TxIsoLevel{"read_committed", "repeatable_read", "serializable"} { + t.Run(mode.String()+"/"+string(isolation), func(t *testing.T) { config, err := fbx.ParseConfig(os.Getenv("FBX_TEST_DATABASE")) require.NoError(t, err) config.DefaultTransactionIsolation = isolation @@ -29,7 +29,7 @@ func TestDefaultTransactionIsolation(t *testing.T) { db := stdlib.OpenDB(*config) defer closeDB(t, db) db.SetMaxOpenConns(1) - want := map[string]int{"read_committed": 4, "repeatable_read": 1, "serializable": 0}[isolation] + want := map[fbx.TxIsoLevel]int{"read_committed": 4, "repeatable_read": 1, "serializable": 0}[isolation] if isolation == "read_committed" && getServerMajorVersion(t, db) <= 3 { want = 2 } diff --git a/tx.go b/tx.go index bd7ef26e..cd2a8572 100644 --- a/tx.go +++ b/tx.go @@ -13,13 +13,13 @@ import ( ) // TxIsoLevel is the transaction isolation level ([fbx.Serializable], [fbx.RepeatableRead], [fbx.ReadCommitted]). -type TxIsoLevel string +type TxIsoLevel = fbconn.TxIsoLevel // Transaction isolation levels const ( - Serializable TxIsoLevel = fbconn.Serializable - RepeatableRead TxIsoLevel = fbconn.RepeatableRead - ReadCommitted TxIsoLevel = fbconn.ReadCommitted + Serializable = fbconn.Serializable + RepeatableRead = fbconn.RepeatableRead + ReadCommitted = fbconn.ReadCommitted ) // TxAccessMode is the transaction access mode ([fbx.ReadWrite], [fbx.ReadOnly]) @@ -61,7 +61,7 @@ func (c *Conn) Begin(ctx context.Context) (Tx, error) { // or the server's default isolation if that setting is empty. func (c *Conn) BeginTx(ctx context.Context, txOptions TxOptions) (Tx, error) { if txOptions.IsoLevel == "" { - txOptions.IsoLevel = TxIsoLevel(c.config.DefaultTransactionIsolation) + txOptions.IsoLevel = c.config.DefaultTransactionIsolation } tpb, err := txOptions.GetTPB() if err != nil { diff --git a/tx_internal_test.go b/tx_internal_test.go index 9ff82c2a..d06d6e68 100644 --- a/tx_internal_test.go +++ b/tx_internal_test.go @@ -4,6 +4,7 @@ import ( "testing" "time" + "github.com/firebirdsql/fbx/fbconn" "github.com/firebirdsql/fbx/fbproto" "github.com/stretchr/testify/require" ) @@ -74,7 +75,7 @@ func TestGetTPB(t *testing.T) { }) t.Run("isolation only defaults to read write", func(t *testing.T) { - tpb, err := TxOptions{IsoLevel: RepeatableRead}.GetTPB() + tpb, err := TxOptions{IsoLevel: fbconn.RepeatableRead}.GetTPB() require.NoError(t, err) require.Equal(t, []byte{ fbproto.Isc_tpb_version3,