diff --git a/README.md b/README.md index 77620217..114e5ec0 100644 --- a/README.md +++ b/README.md @@ -88,6 +88,20 @@ 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_committed` in a URL, to choose +the default transaction isolation. Supported values are `read_committed`, +`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`, 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 `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..91379598 --- /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 = 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..268a015f 100644 --- a/fbconn/config.go +++ b/fbconn/config.go @@ -49,12 +49,20 @@ type Config struct { DPB []byte ClientVersion string DefaultTransactionReadOnly bool - Autocommit bool - BlobBufferSize int - UseStreamBlobs bool - MaxInlineBlobSize int - MaxBlobCacheSize int - FetchBatchSize int + // DefaultTransactionIsolation is [Serializable], [RepeatableRead], or + // [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 TxIsoLevel + 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 @@ -349,6 +357,13 @@ func ParseConfigWithOptions(connString string, options ParseConfigOptions) (*Con UseStreamBlobs: convertToBool(settings["use_stream_blobs"], true), FetchBatchSize: DefaultFetchBatchSize, } + if s, ok := settings["default_transaction_isolation"]; ok { + 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 = isolation + } if s, ok := settings["max_inline_blob_size"]; ok { value, err := parsePositiveIntSetting(s) if err != nil { @@ -415,6 +430,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..38049fe6 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,19 @@ 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 +// DefaultTransactionIsolation, or the server's default isolation if the setting +// is empty. 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..a55097d9 --- /dev/null +++ b/fbconn/transaction_options.go @@ -0,0 +1,40 @@ +package fbconn + +import ( + "fmt" + + "github.com/firebirdsql/fbx/fbproto" +) + +// TxIsoLevel is the transaction isolation level ([Serializable], [RepeatableRead], [ReadCommitted]). +type TxIsoLevel string + +// Transaction isolation levels. +const ( + Serializable TxIsoLevel = "serializable" + RepeatableRead TxIsoLevel = "repeatable_read" + ReadCommitted TxIsoLevel = "read_committed" +) + +func defaultTransactionTPB(isolation TxIsoLevel, 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 RepeatableRead: + tpb.PutTag(fbproto.Isc_tpb_concurrency) + case ReadCommitted: + 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..dccaefd9 --- /dev/null +++ b/fbconn/transaction_options_test.go @@ -0,0 +1,96 @@ +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 TxIsoLevel + 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) + } + } + for _, isolation := range []TxIsoLevel{"invalid", "read committed", "repeatable read"} { + _, err := defaultTransactionTPB(isolation, false) + require.Error(t, err, "isolation=%q", isolation) + } +} + +func TestParseConfigDefaultTransactionIsolation(t *testing.T) { + for _, tt := range []struct { + connString 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) + 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", "read_uncommitted", "read__committed", "read committed", "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) { + 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 + 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..1befd705 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..546ff143 --- /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 []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 + config.DefaultQueryExecMode = mode + db := stdlib.OpenDB(*config) + defer closeDB(t, db) + db.SetMaxOpenConns(1) + want := map[fbx.TxIsoLevel]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..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 server'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 preserves the server -// default; repeatable-read and snapshot both 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: - // Empty options preserve the server and database defaults. + // 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 03cdea87..cd2a8572 100644 --- a/tx.go +++ b/tx.go @@ -12,14 +12,14 @@ import ( "github.com/firebirdsql/fbx/internal/operationerror" ) -// TxIsoLevel is the transaction isolation level ([fbx.Serializable], [fbx.RepeatableRead], [fbx.ReadCommitted]) -type TxIsoLevel string +// TxIsoLevel is the transaction isolation level ([fbx.Serializable], [fbx.RepeatableRead], [fbx.ReadCommitted]). +type TxIsoLevel = fbconn.TxIsoLevel // Transaction isolation levels const ( - Serializable TxIsoLevel = "serializable" - RepeatableRead TxIsoLevel = "repeatable read" - ReadCommitted TxIsoLevel = "read committed" + Serializable = fbconn.Serializable + RepeatableRead = fbconn.RepeatableRead + ReadCommitted = fbconn.ReadCommitted ) // TxAccessMode is the transaction access mode ([fbx.ReadWrite], [fbx.ReadOnly]) @@ -48,15 +48,21 @@ 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, +// 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 = c.config.DefaultTransactionIsolation + } tpb, err := txOptions.GetTPB() if err != nil { return nil, err @@ -98,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 } diff --git a/tx_internal_test.go b/tx_internal_test.go index e6a693ea..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" ) @@ -43,6 +44,13 @@ func TestNormalizeTxLockTimeout(t *testing.T) { func TestGetTPB(t *testing.T) { t.Parallel() + 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") + } + }) + t.Run("no options means nil tpb", func(t *testing.T) { tpb, err := TxOptions{}.GetTPB() require.NoError(t, err) @@ -67,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,