diff --git a/go/test/endtoend/cluster/cluster_process.go b/go/test/endtoend/cluster/cluster_process.go index 8618591b444..fb6b0cbdb99 100644 --- a/go/test/endtoend/cluster/cluster_process.go +++ b/go/test/endtoend/cluster/cluster_process.go @@ -960,7 +960,7 @@ func (cluster *LocalProcessCluster) ExecOnTablet(ctx context.Context, vttablet * Keyspace: tablet.Keyspace, Shard: tablet.Shard, TabletType: tablet.Type, - }, sql, bindvars, int64(txID), int64(reservedID)) + }, sql, bindvars, int64(txID), int64(reservedID), opts) } // ExecOnVTGate executes a query on a local cluster VTGate with the provided diff --git a/go/vt/vtcombo/tablet_map.go b/go/vt/vtcombo/tablet_map.go index 45166d04665..0185ab00d42 100644 --- a/go/vt/vtcombo/tablet_map.go +++ b/go/vt/vtcombo/tablet_map.go @@ -465,9 +465,10 @@ func (itc *internalTabletConn) Execute( query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64, + options *querypb.ExecuteOptions, ) (*sqltypes.Result, error) { bindVars = sqltypes.CopyBindVariables(bindVars) - reply, err := itc.tablet.qsc.QueryService().Execute(ctx, session, target, query, bindVars, transactionID, reservedID) + reply, err := itc.tablet.qsc.QueryService().Execute(ctx, session, target, query, bindVars, transactionID, reservedID, options) if err != nil { return nil, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -484,10 +485,11 @@ func (itc *internalTabletConn) StreamExecute( bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) error { bindVars = sqltypes.CopyBindVariables(bindVars) - err := itc.tablet.qsc.QueryService().StreamExecute(ctx, session, target, query, bindVars, transactionID, reservedID, callback) + err := itc.tablet.qsc.QueryService().StreamExecute(ctx, session, target, query, bindVars, transactionID, reservedID, options, callback) return tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -496,8 +498,9 @@ func (itc *internalTabletConn) Begin( ctx context.Context, session queryservice.Session, target *querypb.Target, + options *querypb.ExecuteOptions, ) (queryservice.TransactionState, error) { - state, err := itc.tablet.qsc.QueryService().Begin(ctx, session, target) + state, err := itc.tablet.qsc.QueryService().Begin(ctx, session, target, options) return state, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -581,9 +584,10 @@ func (itc *internalTabletConn) BeginExecute( query string, bindVars map[string]*querypb.BindVariable, reserveID int64, + options *querypb.ExecuteOptions, ) (queryservice.TransactionState, *sqltypes.Result, error) { bindVars = sqltypes.CopyBindVariables(bindVars) - state, result, err := itc.tablet.qsc.QueryService().BeginExecute(ctx, session, target, preQueries, query, bindVars, reserveID) + state, result, err := itc.tablet.qsc.QueryService().BeginExecute(ctx, session, target, preQueries, query, bindVars, reserveID, options) return state, result, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -596,10 +600,11 @@ func (itc *internalTabletConn) BeginStreamExecute( query string, bindVars map[string]*querypb.BindVariable, reservedID int64, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) (queryservice.TransactionState, error) { bindVars = sqltypes.CopyBindVariables(bindVars) - state, err := itc.tablet.qsc.QueryService().BeginStreamExecute(ctx, session, target, preQueries, query, bindVars, reservedID, callback) + state, err := itc.tablet.qsc.QueryService().BeginStreamExecute(ctx, session, target, preQueries, query, bindVars, reservedID, options, callback) return state, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -628,9 +633,10 @@ func (itc *internalTabletConn) ReserveBeginExecute( postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, + options *querypb.ExecuteOptions, ) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { bindVariables = sqltypes.CopyBindVariables(bindVariables) - state, result, err := itc.tablet.qsc.QueryService().ReserveBeginExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables) + state, result, err := itc.tablet.qsc.QueryService().ReserveBeginExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables, options) return state, result, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -643,10 +649,11 @@ func (itc *internalTabletConn) ReserveBeginStreamExecute( postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) (queryservice.ReservedTransactionState, error) { bindVariables = sqltypes.CopyBindVariables(bindVariables) - state, err := itc.tablet.qsc.QueryService().ReserveBeginStreamExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables, callback) + state, err := itc.tablet.qsc.QueryService().ReserveBeginStreamExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables, options, callback) return state, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -659,9 +666,10 @@ func (itc *internalTabletConn) ReserveExecute( sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, + options *querypb.ExecuteOptions, ) (queryservice.ReservedState, *sqltypes.Result, error) { bindVariables = sqltypes.CopyBindVariables(bindVariables) - state, result, err := itc.tablet.qsc.QueryService().ReserveExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID) + state, result, err := itc.tablet.qsc.QueryService().ReserveExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID, options) return state, result, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } @@ -674,10 +682,11 @@ func (itc *internalTabletConn) ReserveStreamExecute( sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) (queryservice.ReservedState, error) { bindVariables = sqltypes.CopyBindVariables(bindVariables) - state, err := itc.tablet.qsc.QueryService().ReserveStreamExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID, callback) + state, err := itc.tablet.qsc.QueryService().ReserveStreamExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID, options, callback) return state, tabletconn.ErrorFromGRPC(vterrors.ToGRPC(err)) } diff --git a/go/vt/vtexplain/vtexplain_vttablet.go b/go/vt/vtexplain/vtexplain_vttablet.go index 6dd2fc250a9..37a91691552 100644 --- a/go/vt/vtexplain/vtexplain_vttablet.go +++ b/go/vt/vtexplain/vtexplain_vttablet.go @@ -155,7 +155,7 @@ func (vte *VTExplain) newTablet(ctx context.Context, env *vtenv.Environment, opt var _ queryservice.QueryService = (*explainTablet)(nil) // compile-time interface check // Begin is part of the QueryService interface. -func (t *explainTablet) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (queryservice.TransactionState, error) { +func (t *explainTablet) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (queryservice.TransactionState, error) { t.mu.Lock() t.currentTime = t.vte.batchTime.Wait() t.tabletQueries = append(t.tabletQueries, &TabletQuery{ @@ -165,7 +165,7 @@ func (t *explainTablet) Begin(ctx context.Context, session queryservice.Session, t.mu.Unlock() - return t.tsv.Begin(ctx, session, target) + return t.tsv.Begin(ctx, session, target, options) } // Commit is part of the QueryService interface. @@ -190,7 +190,7 @@ func (t *explainTablet) Rollback(ctx context.Context, target *querypb.Target, tr } // Execute is part of the QueryService interface. -func (t *explainTablet) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) { +func (t *explainTablet) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { t.mu.Lock() t.currentTime = t.vte.batchTime.Wait() @@ -204,7 +204,7 @@ func (t *explainTablet) Execute(ctx context.Context, session queryservice.Sessio }) t.mu.Unlock() - return t.tsv.Execute(ctx, session, target, sql, bindVariables, transactionID, reservedID) + return t.tsv.Execute(ctx, session, target, sql, bindVariables, transactionID, reservedID, options) } // Prepare is part of the QueryService interface. @@ -264,7 +264,7 @@ func (t *explainTablet) ReadTransaction(ctx context.Context, target *querypb.Tar } // BeginExecute is part of the QueryService interface. -func (t *explainTablet) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64) (queryservice.TransactionState, *sqltypes.Result, error) { +func (t *explainTablet) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (queryservice.TransactionState, *sqltypes.Result, error) { t.mu.Lock() t.currentTime = t.vte.batchTime.Wait() bindVariables = sqltypes.CopyBindVariables(bindVariables) @@ -275,7 +275,7 @@ func (t *explainTablet) BeginExecute(ctx context.Context, session queryservice.S }) t.mu.Unlock() - return t.tsv.BeginExecute(ctx, session, target, preQueries, sql, bindVariables, reservedID) + return t.tsv.BeginExecute(ctx, session, target, preQueries, sql, bindVariables, reservedID, options) } // Close is part of the QueryService interface. diff --git a/go/vt/vtgate/executor.go b/go/vt/vtgate/executor.go index f12aeb0d0d8..776b04aabc2 100644 --- a/go/vt/vtgate/executor.go +++ b/go/vt/vtgate/executor.go @@ -1012,7 +1012,7 @@ func (e *Executor) ShowVitessReplicationStatus(ctx context.Context, filter *sqlp replicaSQLRunningField = "Slave_SQL_Running" secondsBehindSourceField = "Seconds_Behind_Master" } - results, err := e.txConn.tabletGateway.Execute(ctx, nil, ts.Target, sql, nil, 0, 0) + results, err := e.txConn.tabletGateway.Execute(ctx, nil, ts.Target, sql, nil, 0, 0, nil) if err != nil || results == nil { log.Warningf("Could not get replication status from %s: %v", tabletHostPort, err) } else if row := results.Named().Row(); row != nil { diff --git a/go/vt/vtgate/scatter_conn.go b/go/vt/vtgate/scatter_conn.go index a2e46442c31..344b2af3e2b 100644 --- a/go/vt/vtgate/scatter_conn.go +++ b/go/vt/vtgate/scatter_conn.go @@ -193,7 +193,6 @@ func (stc *ScatterConn) ExecuteMultiShard( if opts == nil && fetchLastInsertID { opts = &querypb.ExecuteOptions{FetchLastInsertId: fetchLastInsertID} - session = econtext.NewSafeSession(&vtgatepb.Session{Options: opts}) } if autocommit { @@ -224,21 +223,21 @@ func (stc *ScatterConn) ExecuteMultiShard( switch info.actionNeeded { case nothing: - innerqr, err = qs.Execute(ctx, session, rs.Target, queries[i].Sql, queries[i].BindVariables, info.transactionID, info.reservedID) + innerqr, err = qs.Execute(ctx, session, rs.Target, queries[i].Sql, queries[i].BindVariables, info.transactionID, info.reservedID, opts) if err != nil { retryRequest(func() { // we seem to have lost our connection. it was a reserved connection, let's try to recreate it info.actionNeeded = reserve info.ignoreOldSession = true var state queryservice.ReservedState - state, innerqr, err = qs.ReserveExecute(ctx, session, rs.Target, session.SetPreQueries(), queries[i].Sql, queries[i].BindVariables, 0 /*transactionId*/) + state, innerqr, err = qs.ReserveExecute(ctx, session, rs.Target, session.SetPreQueries(), queries[i].Sql, queries[i].BindVariables, 0 /*transactionId*/, opts) reservedID = state.ReservedID alias = state.TabletAlias }) } case begin: var state queryservice.TransactionState - state, innerqr, err = qs.BeginExecute(ctx, session, rs.Target, session.SavePoints(), queries[i].Sql, queries[i].BindVariables, reservedID) + state, innerqr, err = qs.BeginExecute(ctx, session, rs.Target, session.SavePoints(), queries[i].Sql, queries[i].BindVariables, reservedID, opts) transactionID = state.TransactionID alias = state.TabletAlias if err != nil { @@ -247,7 +246,7 @@ func (stc *ScatterConn) ExecuteMultiShard( info.actionNeeded = reserveBegin info.ignoreOldSession = true var state queryservice.ReservedTransactionState - state, innerqr, err = qs.ReserveBeginExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), queries[i].Sql, queries[i].BindVariables) + state, innerqr, err = qs.ReserveBeginExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), queries[i].Sql, queries[i].BindVariables, opts) transactionID = state.TransactionID reservedID = state.ReservedID alias = state.TabletAlias @@ -255,12 +254,12 @@ func (stc *ScatterConn) ExecuteMultiShard( } case reserve: var state queryservice.ReservedState - state, innerqr, err = qs.ReserveExecute(ctx, session, rs.Target, session.SetPreQueries(), queries[i].Sql, queries[i].BindVariables, transactionID) + state, innerqr, err = qs.ReserveExecute(ctx, session, rs.Target, session.SetPreQueries(), queries[i].Sql, queries[i].BindVariables, transactionID, opts) reservedID = state.ReservedID alias = state.TabletAlias case reserveBegin: var state queryservice.ReservedTransactionState - state, innerqr, err = qs.ReserveBeginExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), queries[i].Sql, queries[i].BindVariables) + state, innerqr, err = qs.ReserveBeginExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), queries[i].Sql, queries[i].BindVariables, opts) transactionID = state.TransactionID reservedID = state.ReservedID alias = state.TabletAlias @@ -425,7 +424,6 @@ func (stc *ScatterConn) StreamExecuteMulti( if opts == nil && fetchLastInsertID { opts = &querypb.ExecuteOptions{FetchLastInsertId: fetchLastInsertID} - session = econtext.NewSafeSession(&vtgatepb.Session{Options: opts}) } if autocommit { @@ -456,20 +454,20 @@ func (stc *ScatterConn) StreamExecuteMulti( switch info.actionNeeded { case nothing: - err = qs.StreamExecute(ctx, session, rs.Target, query, bindVars[i], transactionID, reservedID, observedCallback) + err = qs.StreamExecute(ctx, session, rs.Target, query, bindVars[i], transactionID, reservedID, opts, observedCallback) if err != nil { retryRequest(func() { // we seem to have lost our connection. it was a reserved connection, let's try to recreate it info.actionNeeded = reserve var state queryservice.ReservedState - state, err = qs.ReserveStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), query, bindVars[i], 0 /*transactionId*/, observedCallback) + state, err = qs.ReserveStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), query, bindVars[i], 0 /*transactionId*/, opts, observedCallback) reservedID = state.ReservedID alias = state.TabletAlias }) } case begin: var state queryservice.TransactionState - state, err = qs.BeginStreamExecute(ctx, session, rs.Target, session.SavePoints(), query, bindVars[i], reservedID, observedCallback) + state, err = qs.BeginStreamExecute(ctx, session, rs.Target, session.SavePoints(), query, bindVars[i], reservedID, opts, observedCallback) transactionID = state.TransactionID alias = state.TabletAlias if err != nil { @@ -477,7 +475,7 @@ func (stc *ScatterConn) StreamExecuteMulti( // we seem to have lost our connection. it was a reserved connection, let's try to recreate it info.actionNeeded = reserveBegin var state queryservice.ReservedTransactionState - state, err = qs.ReserveBeginStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), query, bindVars[i], observedCallback) + state, err = qs.ReserveBeginStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), query, bindVars[i], opts, observedCallback) transactionID = state.TransactionID reservedID = state.ReservedID alias = state.TabletAlias @@ -485,12 +483,12 @@ func (stc *ScatterConn) StreamExecuteMulti( } case reserve: var state queryservice.ReservedState - state, err = qs.ReserveStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), query, bindVars[i], transactionID, observedCallback) + state, err = qs.ReserveStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), query, bindVars[i], transactionID, opts, observedCallback) reservedID = state.ReservedID alias = state.TabletAlias case reserveBegin: var state queryservice.ReservedTransactionState - state, err = qs.ReserveBeginStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), query, bindVars[i], observedCallback) + state, err = qs.ReserveBeginStreamExecute(ctx, session, rs.Target, session.SetPreQueries(), session.SavePoints(), query, bindVars[i], opts, observedCallback) transactionID = state.TransactionID reservedID = state.ReservedID alias = state.TabletAlias @@ -761,6 +759,7 @@ func (stc *ScatterConn) ExecuteLock(ctx context.Context, rs *srvtopo.ResolvedSha var ( qr *sqltypes.Result err error + opts *querypb.ExecuteOptions alias *topodatapb.TabletAlias ) allErrors := new(concurrency.AllErrorRecorder) @@ -771,6 +770,7 @@ func (stc *ScatterConn) ExecuteLock(ctx context.Context, rs *srvtopo.ResolvedSha return nil, vterrors.VT13001("session cannot be nil") } + opts = session.Options info, err := lockInfo(rs.Target, session, lockFuncType) // Lock session is created on alphabetic sorted keyspace. // This error will occur if the existing session target does not match the current target. @@ -788,7 +788,7 @@ func (stc *ScatterConn) ExecuteLock(ctx context.Context, rs *srvtopo.ResolvedSha switch info.actionNeeded { case nothing: - qr, err = qs.Execute(ctx, session, rs.Target, query.Sql, query.BindVariables, 0 /* transactionID */, reservedID) + qr, err = qs.Execute(ctx, session, rs.Target, query.Sql, query.BindVariables, 0 /* transactionID */, reservedID, opts) if err != nil && wasConnectionClosed(err) { // TODO: try to acquire lock again. session.ResetLock() @@ -799,7 +799,7 @@ func (stc *ScatterConn) ExecuteLock(ctx context.Context, rs *srvtopo.ResolvedSha } case reserve: var state queryservice.ReservedState - state, qr, err = qs.ReserveExecute(ctx, session, rs.Target, session.SetPreQueries(), query.Sql, query.BindVariables, 0 /* transactionID */) + state, qr, err = qs.ReserveExecute(ctx, session, rs.Target, session.SetPreQueries(), query.Sql, query.BindVariables, 0 /* transactionID */, opts) reservedID = state.ReservedID alias = state.TabletAlias if err != nil && reservedID != 0 { diff --git a/go/vt/vtgate/tabletgateway_flaky_test.go b/go/vt/vtgate/tabletgateway_flaky_test.go index 875ae9c18fb..760c0dba9da 100644 --- a/go/vt/vtgate/tabletgateway_flaky_test.go +++ b/go/vt/vtgate/tabletgateway_flaky_test.go @@ -94,7 +94,7 @@ func TestGatewayBufferingWhenPrimarySwitchesServingState(t *testing.T) { sbc.SetResults([]*sqltypes.Result{sqlResult1}) // run a query that we indeed get the result added to the sandbox connection back - res, err := tg.Execute(ctx, nil, target, "query", nil, 0, 0) + res, err := tg.Execute(ctx, nil, target, "query", nil, 0, 0, nil) require.NoError(t, err) require.Equal(t, res, sqlResult1) @@ -114,7 +114,7 @@ func TestGatewayBufferingWhenPrimarySwitchesServingState(t *testing.T) { // execute the query in a go routine since it should be buffered, and check that it eventually succeed queryChan := make(chan struct{}) go func() { - res, err = tg.Execute(ctx, nil, target, "query", nil, 0, 0) + res, err = tg.Execute(ctx, nil, target, "query", nil, 0, 0, nil) queryChan <- struct{}{} }() @@ -186,7 +186,7 @@ func TestGatewayBufferingWhileReparenting(t *testing.T) { // run a query that we indeed get the result added to the sandbox connection back // this also checks that the query reaches the primary tablet and not the replica - res, err := tg.Execute(ctx, nil, target, "query", nil, 0, 0) + res, err := tg.Execute(ctx, nil, target, "query", nil, 0, 0, nil) require.NoError(t, err) require.Equal(t, res, sqlResult1) @@ -224,7 +224,7 @@ func TestGatewayBufferingWhileReparenting(t *testing.T) { // execute the query in a go routine since it should be buffered, and check that it eventually succeed queryChan := make(chan struct{}) go func() { - res, err = tg.Execute(ctx, nil, target, "query", nil, 0, 0) + res, err = tg.Execute(ctx, nil, target, "query", nil, 0, 0, nil) queryChan <- struct{}{} }() @@ -332,7 +332,7 @@ func TestInconsistentStateDetectedBuffering(t *testing.T) { var err error queryChan := make(chan struct{}) go func() { - res, err = tg.Execute(ctx, nil, target, "query", nil, 0, 0) + res, err = tg.Execute(ctx, nil, target, "query", nil, 0, 0, nil) queryChan <- struct{}{} }() diff --git a/go/vt/vtgate/tabletgateway_test.go b/go/vt/vtgate/tabletgateway_test.go index c7a7eebd98e..9a6a401e310 100644 --- a/go/vt/vtgate/tabletgateway_test.go +++ b/go/vt/vtgate/tabletgateway_test.go @@ -43,14 +43,14 @@ import ( func TestTabletGatewayExecute(t *testing.T) { ctx := utils.LeakCheckContext(t) testTabletGatewayGeneric(t, ctx, func(ctx context.Context, tg *TabletGateway, target *querypb.Target) error { - _, err := tg.Execute(ctx, nil, target, "query", nil, 0, 0) + _, err := tg.Execute(ctx, nil, target, "query", nil, 0, 0, nil) return err }, func(t *testing.T, sc *sandboxconn.SandboxConn, want int64) { assert.Equal(t, want, sc.ExecCount.Load()) }) testTabletGatewayTransact(t, ctx, func(ctx context.Context, tg *TabletGateway, target *querypb.Target) error { - _, err := tg.Execute(ctx, nil, target, "query", nil, 1, 0) + _, err := tg.Execute(ctx, nil, target, "query", nil, 1, 0, nil) return err }) } @@ -58,7 +58,7 @@ func TestTabletGatewayExecute(t *testing.T) { func TestTabletGatewayExecuteStream(t *testing.T) { ctx := utils.LeakCheckContext(t) testTabletGatewayGeneric(t, ctx, func(ctx context.Context, tg *TabletGateway, target *querypb.Target) error { - err := tg.StreamExecute(ctx, nil, target, "query", nil, 0, 0, func(qr *sqltypes.Result) error { + err := tg.StreamExecute(ctx, nil, target, "query", nil, 0, 0, nil, func(qr *sqltypes.Result) error { return nil }) return err @@ -71,7 +71,7 @@ func TestTabletGatewayExecuteStream(t *testing.T) { func TestTabletGatewayBegin(t *testing.T) { ctx := utils.LeakCheckContext(t) testTabletGatewayGeneric(t, ctx, func(ctx context.Context, tg *TabletGateway, target *querypb.Target) error { - _, err := tg.Begin(ctx, nil, target) + _, err := tg.Begin(ctx, nil, target, nil) return err }, func(t *testing.T, sc *sandboxconn.SandboxConn, want int64) { @@ -98,7 +98,7 @@ func TestTabletGatewayRollback(t *testing.T) { func TestTabletGatewayBeginExecute(t *testing.T) { ctx := utils.LeakCheckContext(t) testTabletGatewayGeneric(t, ctx, func(ctx context.Context, tg *TabletGateway, target *querypb.Target) error { - _, _, err := tg.BeginExecute(ctx, nil, target, nil, "query", nil, 0) + _, _, err := tg.BeginExecute(ctx, nil, target, nil, "query", nil, 0, nil) return err }, func(t *testing.T, sc *sandboxconn.SandboxConn, want int64) { @@ -190,7 +190,7 @@ func TestTabletGatewayReplicaTransactionError(t *testing.T) { defer tg.Close(ctx) _ = hc.AddTestTablet("cell", host, port, keyspace, shard, tabletType, true, 10, nil) - _, err := tg.Execute(ctx, nil, target, "query", nil, 1, 0) + _, err := tg.Execute(ctx, nil, target, "query", nil, 1, 0, nil) verifyContainsError(t, err, "query service can only be used for non-transactional queries on replicas", vtrpcpb.Code_INTERNAL) } diff --git a/go/vt/vttablet/endtoend/framework/client.go b/go/vt/vttablet/endtoend/framework/client.go index 94bb3ccd154..9cf6a05e682 100644 --- a/go/vt/vttablet/endtoend/framework/client.go +++ b/go/vt/vttablet/endtoend/framework/client.go @@ -28,7 +28,6 @@ import ( querypb "vitess.io/vitess/go/vt/proto/query" topodatapb "vitess.io/vitess/go/vt/proto/topodata" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) @@ -100,9 +99,11 @@ func (client *QueryClient) Begin(clientFoundRows bool) error { if client.transactionID != 0 { return errors.New("already in transaction") } - - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{ClientFoundRows: clientFoundRows}} - state, err := client.server.Begin(client.ctx, session, client.target) + var options *querypb.ExecuteOptions + if clientFoundRows { + options = &querypb.ExecuteOptions{ClientFoundRows: clientFoundRows} + } + state, err := client.server.Begin(client.ctx, nil, client.target, options) if err != nil { return err } @@ -201,16 +202,15 @@ func (client *QueryClient) BeginExecute(query string, bindvars map[string]*query if client.transactionID != 0 { return nil, errors.New("already in transaction") } - - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}} state, qr, err := client.server.BeginExecute( client.ctx, - session, + nil, client.target, preQueries, query, bindvars, client.reservedID, + &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}, ) client.transactionID = state.TransactionID client.sessionStateChanges = state.SessionStateChanges @@ -222,15 +222,15 @@ func (client *QueryClient) BeginExecute(query string, bindvars map[string]*query // ExecuteWithOptions executes a query using 'options'. func (client *QueryClient) ExecuteWithOptions(query string, bindvars map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { - session := &vtgatepb.Session{Options: options} return client.server.Execute( client.ctx, - session, + nil, client.target, query, bindvars, client.transactionID, client.reservedID, + options, ) } @@ -242,14 +242,14 @@ func (client *QueryClient) StreamExecute(query string, bindvars map[string]*quer // StreamExecuteWithOptions executes a query & returns the results using 'options'. func (client *QueryClient) StreamExecuteWithOptions(query string, bindvars map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { result := &sqltypes.Result{} - session := &vtgatepb.Session{Options: options} err := client.server.StreamExecute(client.ctx, - session, + nil, client.target, query, bindvars, client.transactionID, client.reservedID, + options, func(res *sqltypes.Result) error { if result.Fields == nil { result.Fields = res.Fields @@ -266,15 +266,15 @@ func (client *QueryClient) StreamExecuteWithOptions(query string, bindvars map[s // StreamBeginExecuteWithOptions starts a tx and executes a query using 'options', returning the results . func (client *QueryClient) StreamBeginExecuteWithOptions(query string, preQueries []string, bindvars map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { result := &sqltypes.Result{} - session := &vtgatepb.Session{Options: options} state, err := client.server.BeginStreamExecute( client.ctx, - session, + nil, client.target, preQueries, query, bindvars, client.reservedID, + options, func(res *sqltypes.Result) error { if result.Fields == nil { result.Fields = res.Fields @@ -293,8 +293,7 @@ func (client *QueryClient) StreamBeginExecuteWithOptions(query string, preQuerie // Stream streams the results of a query. func (client *QueryClient) Stream(query string, bindvars map[string]*querypb.BindVariable, sendFunc func(*sqltypes.Result) error) error { - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}} - return client.server.StreamExecute(client.ctx, session, client.target, query, bindvars, 0, 0, sendFunc) + return client.server.StreamExecute(client.ctx, nil, client.target, query, bindvars, 0, 0, &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}, sendFunc) } // MessageStream streams messages from the message table. @@ -321,8 +320,7 @@ func (client *QueryClient) ReserveExecute(query string, preQueries []string, bin if client.reservedID != 0 { return nil, errors.New("already reserved a connection") } - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}} - state, qr, err := client.server.ReserveExecute(client.ctx, session, client.target, preQueries, query, bindvars, client.transactionID) + state, qr, err := client.server.ReserveExecute(client.ctx, nil, client.target, preQueries, query, bindvars, client.transactionID, &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}) client.reservedID = state.ReservedID if err != nil { return nil, err @@ -336,8 +334,7 @@ func (client *QueryClient) ReserveStreamExecute(query string, preQueries []strin return nil, errors.New("already reserved a connection") } result := &sqltypes.Result{} - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}} - state, err := client.server.ReserveStreamExecute(client.ctx, session, client.target, preQueries, query, bindvars, client.transactionID, + state, err := client.server.ReserveStreamExecute(client.ctx, nil, client.target, preQueries, query, bindvars, client.transactionID, &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}, func(res *sqltypes.Result) error { if result.Fields == nil { result.Fields = res.Fields @@ -360,8 +357,7 @@ func (client *QueryClient) ReserveBeginExecute(query string, preQueries []string if client.transactionID != 0 { return nil, errors.New("already in transaction") } - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}} - state, qr, err := client.server.ReserveBeginExecute(client.ctx, session, client.target, preQueries, postBeginQueries, query, bindvars) + state, qr, err := client.server.ReserveBeginExecute(client.ctx, nil, client.target, preQueries, postBeginQueries, query, bindvars, &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}) client.transactionID = state.TransactionID client.reservedID = state.ReservedID client.sessionStateChanges = state.SessionStateChanges @@ -380,8 +376,7 @@ func (client *QueryClient) ReserveBeginStreamExecute(query string, preQueries [] return nil, errors.New("already in transaction") } result := &sqltypes.Result{} - session := &vtgatepb.Session{Options: &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}} - state, err := client.server.ReserveBeginStreamExecute(client.ctx, session, client.target, preQueries, postBeginQueries, query, bindvars, + state, err := client.server.ReserveBeginStreamExecute(client.ctx, nil, client.target, preQueries, postBeginQueries, query, bindvars, &querypb.ExecuteOptions{IncludedFields: querypb.ExecuteOptions_ALL}, func(res *sqltypes.Result) error { if result.Fields == nil { result.Fields = res.Fields diff --git a/go/vt/vttablet/grpcqueryservice/server.go b/go/vt/vttablet/grpcqueryservice/server.go index ced6dcea0bd..44bef54523c 100644 --- a/go/vt/vttablet/grpcqueryservice/server.go +++ b/go/vt/vttablet/grpcqueryservice/server.go @@ -25,13 +25,11 @@ import ( "vitess.io/vitess/go/vt/callerid" "vitess.io/vitess/go/vt/callinfo" "vitess.io/vitess/go/vt/vterrors" - "vitess.io/vitess/go/vt/vtgate/executorcontext" "vitess.io/vitess/go/vt/vttablet/queryservice" binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" querypb "vitess.io/vitess/go/vt/proto/query" queryservicepb "vitess.io/vitess/go/vt/proto/queryservice" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" ) // query is the gRPC query service implementation. @@ -50,10 +48,7 @@ func (q *query) Execute(ctx context.Context, request *querypb.ExecuteRequest) (r request.EffectiveCallerId, request.ImmediateCallerId, ) - - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - result, err := q.server.Execute(ctx, session, request.Target, request.Query.Sql, request.Query.BindVariables, request.TransactionId, request.ReservedId) + result, err := q.server.Execute(ctx, nil, request.Target, request.Query.Sql, request.Query.BindVariables, request.TransactionId, request.ReservedId, request.Options) if err != nil { return nil, vterrors.ToGRPC(err) } @@ -69,10 +64,7 @@ func (q *query) StreamExecute(request *querypb.StreamExecuteRequest, stream quer request.EffectiveCallerId, request.ImmediateCallerId, ) - - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - err = q.server.StreamExecute(ctx, session, request.Target, request.Query.Sql, request.Query.BindVariables, request.TransactionId, request.ReservedId, func(reply *sqltypes.Result) error { + err = q.server.StreamExecute(ctx, nil, request.Target, request.Query.Sql, request.Query.BindVariables, request.TransactionId, request.ReservedId, request.Options, func(reply *sqltypes.Result) error { return stream.Send(&querypb.StreamExecuteResponse{ Result: sqltypes.ResultToProto3(reply), }) @@ -87,10 +79,7 @@ func (q *query) Begin(ctx context.Context, request *querypb.BeginRequest) (respo request.EffectiveCallerId, request.ImmediateCallerId, ) - - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, err := q.server.Begin(ctx, session, request.Target) + state, err := q.server.Begin(ctx, nil, request.Target, request.Options) if err != nil { return nil, vterrors.ToGRPC(err) } @@ -263,10 +252,7 @@ func (q *query) BeginExecute(ctx context.Context, request *querypb.BeginExecuteR request.EffectiveCallerId, request.ImmediateCallerId, ) - - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, result, err := q.server.BeginExecute(ctx, session, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.ReservedId) + state, result, err := q.server.BeginExecute(ctx, nil, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.ReservedId, request.Options) if err != nil { // if we have a valid transactionID, return the error in-band if state.TransactionID != 0 { @@ -293,10 +279,7 @@ func (q *query) BeginStreamExecute(request *querypb.BeginStreamExecuteRequest, s request.EffectiveCallerId, request.ImmediateCallerId, ) - - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, err := q.server.BeginStreamExecute(ctx, session, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.ReservedId, func(reply *sqltypes.Result) error { + state, err := q.server.BeginStreamExecute(ctx, nil, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.ReservedId, request.Options, func(reply *sqltypes.Result) error { return stream.Send(&querypb.BeginStreamExecuteResponse{ Result: sqltypes.ResultToProto3(reply), }) @@ -409,10 +392,7 @@ func (q *query) ReserveExecute(ctx context.Context, request *querypb.ReserveExec request.EffectiveCallerId, request.ImmediateCallerId, ) - - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, result, err := q.server.ReserveExecute(ctx, session, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.TransactionId) + state, result, err := q.server.ReserveExecute(ctx, nil, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.TransactionId, request.Options) if err != nil { // if we have a valid reservedID, return the error in-band if state.ReservedID != 0 { @@ -439,9 +419,7 @@ func (q *query) ReserveStreamExecute(request *querypb.ReserveStreamExecuteReques request.ImmediateCallerId, ) - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, err := q.server.ReserveStreamExecute(ctx, session, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.TransactionId, func(reply *sqltypes.Result) error { + state, err := q.server.ReserveStreamExecute(ctx, nil, request.Target, request.PreQueries, request.Query.Sql, request.Query.BindVariables, request.TransactionId, request.Options, func(reply *sqltypes.Result) error { return stream.Send(&querypb.ReserveStreamExecuteResponse{ Result: sqltypes.ResultToProto3(reply), }) @@ -466,9 +444,7 @@ func (q *query) ReserveBeginExecute(ctx context.Context, request *querypb.Reserv request.ImmediateCallerId, ) - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, result, err := q.server.ReserveBeginExecute(ctx, session, request.Target, request.PreQueries, request.PostBeginQueries, request.Query.Sql, request.Query.BindVariables) + state, result, err := q.server.ReserveBeginExecute(ctx, nil, request.Target, request.PreQueries, request.PostBeginQueries, request.Query.Sql, request.Query.BindVariables, request.Options) if err != nil { // if we have a valid reservedID or transactionID, return the error in-band if state.TransactionID != 0 || state.ReservedID != 0 { @@ -499,9 +475,7 @@ func (q *query) ReserveBeginStreamExecute(request *querypb.ReserveBeginStreamExe request.ImmediateCallerId, ) - session := executorcontext.NewSafeSession(&vtgatepb.Session{Options: request.Options}) - - state, err := q.server.ReserveBeginStreamExecute(ctx, session, request.Target, request.PreQueries, request.PostBeginQueries, request.Query.Sql, request.Query.BindVariables, func(reply *sqltypes.Result) error { + state, err := q.server.ReserveBeginStreamExecute(ctx, nil, request.Target, request.PreQueries, request.PostBeginQueries, request.Query.Sql, request.Query.BindVariables, request.Options, func(reply *sqltypes.Result) error { return stream.Send(&querypb.ReserveBeginStreamExecuteResponse{ Result: sqltypes.ResultToProto3(reply), }) diff --git a/go/vt/vttablet/grpctabletconn/conn.go b/go/vt/vttablet/grpctabletconn/conn.go index 3e6bb3eb083..156b4ceae10 100644 --- a/go/vt/vttablet/grpctabletconn/conn.go +++ b/go/vt/vttablet/grpctabletconn/conn.go @@ -112,7 +112,7 @@ func DialTablet(ctx context.Context, tablet *topodatapb.Tablet, failFast grpccli } // Execute sends the query to VTTablet. -func (conn *gRPCQueryClient) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) { +func (conn *gRPCQueryClient) Execute(ctx context.Context, _ queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -128,7 +128,7 @@ func (conn *gRPCQueryClient) Execute(ctx context.Context, session queryservice.S BindVariables: bindVars, }, TransactionId: transactionID, - Options: getOptions(session), + Options: options, ReservedId: reservedID, } er, err := conn.c.Execute(ctx, req) @@ -139,7 +139,7 @@ func (conn *gRPCQueryClient) Execute(ctx context.Context, session queryservice.S } // StreamExecute executes the query and streams results back through callback. -func (conn *gRPCQueryClient) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) error { +func (conn *gRPCQueryClient) StreamExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error { // All streaming clients should follow the code pattern below. // The first part of the function starts the stream while holding // a lock on conn.mu. The second part receives the data and calls @@ -166,7 +166,7 @@ func (conn *gRPCQueryClient) StreamExecute(ctx context.Context, session queryser Sql: query, BindVariables: bindVars, }, - Options: getOptions(session), + Options: options, TransactionId: transactionID, ReservedId: reservedID, } @@ -198,7 +198,7 @@ func (conn *gRPCQueryClient) StreamExecute(ctx context.Context, session queryser } // Begin starts a transaction. -func (conn *gRPCQueryClient) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (state queryservice.TransactionState, err error) { +func (conn *gRPCQueryClient) Begin(ctx context.Context, _ queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (state queryservice.TransactionState, err error) { conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -209,7 +209,7 @@ func (conn *gRPCQueryClient) Begin(ctx context.Context, session queryservice.Ses Target: target, EffectiveCallerId: callerid.EffectiveCallerIDFromContext(ctx), ImmediateCallerId: callerid.ImmediateCallerIDFromContext(ctx), - Options: getOptions(session), + Options: options, } br, err := conn.c.Begin(ctx, req) if err != nil { @@ -463,7 +463,7 @@ func (conn *gRPCQueryClient) UnresolvedTransactions(ctx context.Context, target } // BeginExecute starts a transaction and runs an Execute. -func (conn *gRPCQueryClient) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64) (state queryservice.TransactionState, result *sqltypes.Result, err error) { +func (conn *gRPCQueryClient) BeginExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (state queryservice.TransactionState, result *sqltypes.Result, err error) { conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -480,7 +480,7 @@ func (conn *gRPCQueryClient) BeginExecute(ctx context.Context, session queryserv BindVariables: bindVars, }, ReservedId: reservedID, - Options: getOptions(session), + Options: options, } reply, err := conn.c.BeginExecute(ctx, req) if err != nil { @@ -496,7 +496,7 @@ func (conn *gRPCQueryClient) BeginExecute(ctx context.Context, session queryserv } // BeginStreamExecute starts a transaction and runs an Execute. -func (conn *gRPCQueryClient) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, callback func(*sqltypes.Result) error) (state queryservice.TransactionState, err error) { +func (conn *gRPCQueryClient) BeginStreamExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state queryservice.TransactionState, err error) { // Please see comments in StreamExecute to see how this works. ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -524,7 +524,7 @@ func (conn *gRPCQueryClient) BeginStreamExecute(ctx context.Context, session que BindVariables: bindVars, }, ReservedId: reservedID, - Options: getOptions(session), + Options: options, } stream, err := conn.c.BeginStreamExecute(ctx, req) if err != nil { @@ -862,7 +862,7 @@ func (conn *gRPCQueryClient) HandlePanic(err *error) { } // ReserveBeginExecute implements the queryservice interface -func (conn *gRPCQueryClient) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (state queryservice.ReservedTransactionState, result *sqltypes.Result, err error) { +func (conn *gRPCQueryClient) ReserveBeginExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (state queryservice.ReservedTransactionState, result *sqltypes.Result, err error) { conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -873,7 +873,7 @@ func (conn *gRPCQueryClient) ReserveBeginExecute(ctx context.Context, session qu Target: target, EffectiveCallerId: callerid.EffectiveCallerIDFromContext(ctx), ImmediateCallerId: callerid.ImmediateCallerIDFromContext(ctx), - Options: getOptions(session), + Options: options, PreQueries: preQueries, PostBeginQueries: postBeginQueries, Query: &querypb.BoundQuery{ @@ -897,7 +897,7 @@ func (conn *gRPCQueryClient) ReserveBeginExecute(ctx context.Context, session qu } // ReserveBeginStreamExecute implements the queryservice interface -func (conn *gRPCQueryClient) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, callback func(*sqltypes.Result) error) (state queryservice.ReservedTransactionState, err error) { +func (conn *gRPCQueryClient) ReserveBeginStreamExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state queryservice.ReservedTransactionState, err error) { // Please see comments in StreamExecute to see how this works. ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -918,7 +918,7 @@ func (conn *gRPCQueryClient) ReserveBeginStreamExecute(ctx context.Context, sess Target: target, EffectiveCallerId: callerid.EffectiveCallerIDFromContext(ctx), ImmediateCallerId: callerid.ImmediateCallerIDFromContext(ctx), - Options: getOptions(session), + Options: options, PreQueries: preQueries, PostBeginQueries: postBeginQueries, Query: &querypb.BoundQuery{ @@ -978,7 +978,7 @@ func (conn *gRPCQueryClient) ReserveBeginStreamExecute(ctx context.Context, sess } // ReserveExecute implements the queryservice interface -func (conn *gRPCQueryClient) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (state queryservice.ReservedState, result *sqltypes.Result, err error) { +func (conn *gRPCQueryClient) ReserveExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (state queryservice.ReservedState, result *sqltypes.Result, err error) { conn.mu.RLock() defer conn.mu.RUnlock() if conn.cc == nil { @@ -994,7 +994,7 @@ func (conn *gRPCQueryClient) ReserveExecute(ctx context.Context, session queryse BindVariables: bindVariables, }, TransactionId: transactionID, - Options: getOptions(session), + Options: options, PreQueries: preQueries, } reply, err := conn.c.ReserveExecute(ctx, req) @@ -1011,7 +1011,7 @@ func (conn *gRPCQueryClient) ReserveExecute(ctx context.Context, session queryse } // ReserveStreamExecute implements the queryservice interface -func (conn *gRPCQueryClient) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, callback func(*sqltypes.Result) error) (state queryservice.ReservedState, err error) { +func (conn *gRPCQueryClient) ReserveStreamExecute(ctx context.Context, _ queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state queryservice.ReservedState, err error) { // Please see comments in StreamExecute to see how this works. ctx, cancel := context.WithCancel(ctx) defer cancel() @@ -1032,7 +1032,7 @@ func (conn *gRPCQueryClient) ReserveStreamExecute(ctx context.Context, session q Target: target, EffectiveCallerId: callerid.EffectiveCallerIDFromContext(ctx), ImmediateCallerId: callerid.ImmediateCallerIDFromContext(ctx), - Options: getOptions(session), + Options: options, PreQueries: preQueries, Query: &querypb.BoundQuery{ Sql: sql, @@ -1168,12 +1168,3 @@ func (conn *gRPCQueryClient) Close(ctx context.Context) error { func (conn *gRPCQueryClient) Tablet() *topodatapb.Tablet { return conn.tablet } - -// getOptions safely extracts ExecuteOptions from a session, returning nil if session is nil. -func getOptions(session queryservice.Session) *querypb.ExecuteOptions { - if session == nil { - return nil - } - - return session.GetOptions() -} diff --git a/go/vt/vttablet/grpctabletconn/conn_test.go b/go/vt/vttablet/grpctabletconn/conn_test.go index a7da2194d11..6f501e0ad90 100644 --- a/go/vt/vttablet/grpctabletconn/conn_test.go +++ b/go/vt/vttablet/grpctabletconn/conn_test.go @@ -191,22 +191,22 @@ func TestGoRoutineLeakPrevention(t *testing.T) { cc: &grpc.ClientConn{}, c: mqc, } - _ = qc.StreamExecute(context.Background(), nil, nil, "", nil, 0, 0, func(result *sqltypes.Result) error { + _ = qc.StreamExecute(context.Background(), nil, nil, "", nil, 0, 0, nil, func(result *sqltypes.Result) error { return nil }) require.Error(t, mqc.lastCallCtx.Err()) - _, _ = qc.BeginStreamExecute(context.Background(), nil, nil, nil, "", nil, 0, func(result *sqltypes.Result) error { + _, _ = qc.BeginStreamExecute(context.Background(), nil, nil, nil, "", nil, 0, nil, func(result *sqltypes.Result) error { return nil }) require.Error(t, mqc.lastCallCtx.Err()) - _, _ = qc.ReserveBeginStreamExecute(context.Background(), nil, nil, nil, nil, "", nil, func(result *sqltypes.Result) error { + _, _ = qc.ReserveBeginStreamExecute(context.Background(), nil, nil, nil, nil, "", nil, nil, func(result *sqltypes.Result) error { return nil }) require.Error(t, mqc.lastCallCtx.Err()) - _, _ = qc.ReserveStreamExecute(context.Background(), nil, nil, nil, "", nil, 0, func(result *sqltypes.Result) error { + _, _ = qc.ReserveStreamExecute(context.Background(), nil, nil, nil, "", nil, 0, nil, func(result *sqltypes.Result) error { return nil }) require.Error(t, mqc.lastCallCtx.Err()) diff --git a/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go b/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go index 7d259503eee..f8b23c90310 100644 --- a/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go +++ b/go/vt/vttablet/queryservice/fakes/stream_health_query_service.go @@ -56,12 +56,12 @@ func NewStreamHealthQueryService(target *querypb.Target) *StreamHealthQueryServi } // Begin implemented as a no op -func (q *StreamHealthQueryService) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (queryservice.TransactionState, error) { +func (q *StreamHealthQueryService) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (queryservice.TransactionState, error) { return queryservice.TransactionState{}, nil } // Execute implemented as a no op -func (q *StreamHealthQueryService) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) { +func (q *StreamHealthQueryService) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { return &sqltypes.Result{}, nil } diff --git a/go/vt/vttablet/queryservice/queryservice.go b/go/vt/vttablet/queryservice/queryservice.go index 75d09b1c05f..2faf70226c4 100644 --- a/go/vt/vttablet/queryservice/queryservice.go +++ b/go/vt/vttablet/queryservice/queryservice.go @@ -33,9 +33,6 @@ import ( type Session interface { // GetSessionUUID returns the session's UUID. GetSessionUUID() string - - // GetOptions returns the current execute options. - GetOptions() *querypb.ExecuteOptions } // QueryService is the interface implemented by the tablet's query service. @@ -50,7 +47,7 @@ type QueryService interface { // Transaction management // Begin returns the transaction id to use for further operations - Begin(ctx context.Context, session Session, target *querypb.Target) (TransactionState, error) + Begin(ctx context.Context, session Session, target *querypb.Target, options *querypb.ExecuteOptions) (TransactionState, error) // Commit commits the current transaction Commit(ctx context.Context, target *querypb.Target, transactionID int64) (int64, error) @@ -89,16 +86,16 @@ type QueryService interface { UnresolvedTransactions(ctx context.Context, target *querypb.Target, abandonAgeSeconds int64) ([]*querypb.TransactionMetadata, error) // Execute for query execution - Execute(ctx context.Context, session Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) + Execute(ctx context.Context, session Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) // StreamExecute for query execution with streaming - StreamExecute(ctx context.Context, session Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) error + StreamExecute(ctx context.Context, session Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error // Combo methods, they also return the transactionID from the // Begin part. If err != nil, the transactionID may still be // non-zero, and needs to be propagated back (like for a DB // Integrity Error) - BeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64) (TransactionState, *sqltypes.Result, error) - BeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, callback func(*sqltypes.Result) error) (TransactionState, error) + BeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (TransactionState, *sqltypes.Result, error) + BeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (TransactionState, error) // Messaging methods. MessageStream(ctx context.Context, target *querypb.Target, name string, callback func(*sqltypes.Result) error) error @@ -123,13 +120,13 @@ type QueryService interface { // HandlePanic will be called if any of the functions panic. HandlePanic(err *error) - ReserveBeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (ReservedTransactionState, *sqltypes.Result, error) + ReserveBeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (ReservedTransactionState, *sqltypes.Result, error) - ReserveBeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, callback func(*sqltypes.Result) error) (ReservedTransactionState, error) + ReserveBeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (ReservedTransactionState, error) - ReserveExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (ReservedState, *sqltypes.Result, error) + ReserveExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (ReservedState, *sqltypes.Result, error) - ReserveStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, callback func(*sqltypes.Result) error) (ReservedState, error) + ReserveStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (ReservedState, error) Release(ctx context.Context, target *querypb.Target, transactionID, reservedID int64) error diff --git a/go/vt/vttablet/queryservice/wrapped.go b/go/vt/vttablet/queryservice/wrapped.go index 4534170d399..4964b7b5b91 100644 --- a/go/vt/vttablet/queryservice/wrapped.go +++ b/go/vt/vttablet/queryservice/wrapped.go @@ -116,11 +116,11 @@ type wrappedService struct { wrapper WrapperFunc } -func (ws *wrappedService) Begin(ctx context.Context, session Session, target *querypb.Target) (state TransactionState, err error) { +func (ws *wrappedService) Begin(ctx context.Context, session Session, target *querypb.Target, options *querypb.ExecuteOptions) (state TransactionState, err error) { opts := WrapOpts{InTransaction: false, Session: session} err = ws.wrapper(ctx, target, ws.impl, "Begin", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var innerErr error - state, innerErr = conn.Begin(ctx, session, target) + state, innerErr = conn.Begin(ctx, session, target, options) return canRetry(ctx, innerErr), innerErr }) return state, wrapFatalTxErrorInVTError(err, true, vterrors.VT15001) @@ -238,12 +238,12 @@ func (ws *wrappedService) UnresolvedTransactions(ctx context.Context, target *qu return transactions, err } -func (ws *wrappedService) Execute(ctx context.Context, session Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64) (qr *sqltypes.Result, err error) { +func (ws *wrappedService) Execute(ctx context.Context, session Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (qr *sqltypes.Result, err error) { inDedicatedConn := transactionID != 0 || reservedID != 0 opts := WrapOpts{InTransaction: inDedicatedConn, Session: session} err = ws.wrapper(ctx, target, ws.impl, "Execute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var innerErr error - qr, innerErr = conn.Execute(ctx, session, target, query, bindVars, transactionID, reservedID) + qr, innerErr = conn.Execute(ctx, session, target, query, bindVars, transactionID, reservedID, options) // You cannot retry if you're in a transaction. retryable := canRetry(ctx, innerErr) && (!inDedicatedConn) return retryable, innerErr @@ -252,12 +252,12 @@ func (ws *wrappedService) Execute(ctx context.Context, session Session, target * } // StreamExecute implements the QueryService interface -func (ws *wrappedService) StreamExecute(ctx context.Context, session Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) error { +func (ws *wrappedService) StreamExecute(ctx context.Context, session Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error { inDedicatedConn := transactionID != 0 || reservedID != 0 opts := WrapOpts{InTransaction: inDedicatedConn, Session: session} err := ws.wrapper(ctx, target, ws.impl, "StreamExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { streamingStarted := false - innerErr := conn.StreamExecute(ctx, session, target, query, bindVars, transactionID, reservedID, func(qr *sqltypes.Result) error { + innerErr := conn.StreamExecute(ctx, session, target, query, bindVars, transactionID, reservedID, options, func(qr *sqltypes.Result) error { streamingStarted = true return callback(qr) }) @@ -268,24 +268,24 @@ func (ws *wrappedService) StreamExecute(ctx context.Context, session Session, ta return wrapFatalTxErrorInVTError(err, transactionID != 0, vterrors.VT15001) } -func (ws *wrappedService) BeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64) (state TransactionState, qr *sqltypes.Result, err error) { +func (ws *wrappedService) BeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (state TransactionState, qr *sqltypes.Result, err error) { inDedicatedConn := reservedID != 0 opts := WrapOpts{InTransaction: inDedicatedConn, Session: session} err = ws.wrapper(ctx, target, ws.impl, "BeginExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var innerErr error - state, qr, innerErr = conn.BeginExecute(ctx, session, target, preQueries, query, bindVars, reservedID) + state, qr, innerErr = conn.BeginExecute(ctx, session, target, preQueries, query, bindVars, reservedID, options) return canRetry(ctx, innerErr) && !inDedicatedConn, innerErr }) return state, qr, wrapFatalTxErrorInVTError(err, true, vterrors.VT15001) } // BeginStreamExecute implements the QueryService interface -func (ws *wrappedService) BeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, callback func(*sqltypes.Result) error) (state TransactionState, err error) { +func (ws *wrappedService) BeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state TransactionState, err error) { inDedicatedConn := reservedID != 0 opts := WrapOpts{InTransaction: inDedicatedConn, Session: session} err = ws.wrapper(ctx, target, ws.impl, "BeginStreamExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var innerErr error - state, innerErr = conn.BeginStreamExecute(ctx, session, target, preQueries, query, bindVars, reservedID, callback) + state, innerErr = conn.BeginStreamExecute(ctx, session, target, preQueries, query, bindVars, reservedID, options, callback) return canRetry(ctx, innerErr) && !inDedicatedConn, innerErr }) return state, wrapFatalTxErrorInVTError(err, true, vterrors.VT15001) @@ -354,11 +354,11 @@ func (ws *wrappedService) HandlePanic(err *error) { } // ReserveBeginExecute implements the QueryService interface -func (ws *wrappedService) ReserveBeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (state ReservedTransactionState, res *sqltypes.Result, err error) { +func (ws *wrappedService) ReserveBeginExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (state ReservedTransactionState, res *sqltypes.Result, err error) { opts := WrapOpts{InTransaction: false, Session: session} err = ws.wrapper(ctx, target, ws.impl, "ReserveBeginExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var err error - state, res, err = conn.ReserveBeginExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables) + state, res, err = conn.ReserveBeginExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables, options) return canRetry(ctx, err), err }) @@ -366,23 +366,23 @@ func (ws *wrappedService) ReserveBeginExecute(ctx context.Context, session Sessi } // ReserveBeginStreamExecute implements the QueryService interface -func (ws *wrappedService) ReserveBeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, callback func(*sqltypes.Result) error) (state ReservedTransactionState, err error) { +func (ws *wrappedService) ReserveBeginStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state ReservedTransactionState, err error) { opts := WrapOpts{InTransaction: false, Session: session} err = ws.wrapper(ctx, target, ws.impl, "ReserveBeginStreamExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var innerErr error - state, innerErr = conn.ReserveBeginStreamExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables, callback) + state, innerErr = conn.ReserveBeginStreamExecute(ctx, session, target, preQueries, postBeginQueries, sql, bindVariables, options, callback) return canRetry(ctx, innerErr), innerErr }) return state, err } // ReserveExecute implements the QueryService interface -func (ws *wrappedService) ReserveExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (state ReservedState, res *sqltypes.Result, err error) { +func (ws *wrappedService) ReserveExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (state ReservedState, res *sqltypes.Result, err error) { inDedicatedConn := transactionID != 0 opts := WrapOpts{InTransaction: inDedicatedConn, Session: session} err = ws.wrapper(ctx, target, ws.impl, "ReserveExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var err error - state, res, err = conn.ReserveExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID) + state, res, err = conn.ReserveExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID, options) return canRetry(ctx, err) && !inDedicatedConn, err }) @@ -390,12 +390,12 @@ func (ws *wrappedService) ReserveExecute(ctx context.Context, session Session, t } // ReserveStreamExecute implements the QueryService interface -func (ws *wrappedService) ReserveStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, callback func(*sqltypes.Result) error) (state ReservedState, err error) { +func (ws *wrappedService) ReserveStreamExecute(ctx context.Context, session Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (state ReservedState, err error) { inDedicatedConn := transactionID != 0 opts := WrapOpts{InTransaction: inDedicatedConn, Session: session} err = ws.wrapper(ctx, target, ws.impl, "ReserveStreamExecute", opts, func(ctx context.Context, target *querypb.Target, conn QueryService) (bool, error) { var innerErr error - state, innerErr = conn.ReserveStreamExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID, callback) + state, innerErr = conn.ReserveStreamExecute(ctx, session, target, preQueries, sql, bindVariables, transactionID, options, callback) return canRetry(ctx, innerErr) && !inDedicatedConn, innerErr }) return state, err diff --git a/go/vt/vttablet/sandboxconn/sandboxconn.go b/go/vt/vttablet/sandboxconn/sandboxconn.go index 92f96f114de..49e057fff07 100644 --- a/go/vt/vttablet/sandboxconn/sandboxconn.go +++ b/go/vt/vttablet/sandboxconn/sandboxconn.go @@ -264,7 +264,7 @@ func (sbc *SandboxConn) SetSchemaResult(r []SchemaResult) { } // Execute is part of the QueryService interface. -func (sbc *SandboxConn) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) { +func (sbc *SandboxConn) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { sbc.panicIfNeeded() sbc.execMu.Lock() defer sbc.execMu.Unlock() @@ -283,7 +283,7 @@ func (sbc *SandboxConn) Execute(ctx context.Context, session queryservice.Sessio Sql: query, BindVariables: bv, }) - sbc.Options = append(sbc.Options, getOptions(session)) + sbc.Options = append(sbc.Options, options) if err := sbc.getError(); err != nil { return nil, err } @@ -297,7 +297,7 @@ func (sbc *SandboxConn) Execute(ctx context.Context, session queryservice.Sessio } // StreamExecute is part of the QueryService interface. -func (sbc *SandboxConn) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) error { +func (sbc *SandboxConn) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, query string, bindVars map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error { sbc.panicIfNeeded() sbc.sExecMu.Lock() sbc.ExecCount.Add(1) @@ -309,7 +309,7 @@ func (sbc *SandboxConn) StreamExecute(ctx context.Context, session queryservice. Sql: query, BindVariables: bv, }) - sbc.Options = append(sbc.Options, getOptions(session)) + sbc.Options = append(sbc.Options, options) err := sbc.getError() if err != nil { sbc.sExecMu.Unlock() @@ -338,12 +338,12 @@ func (sbc *SandboxConn) StreamExecute(ctx context.Context, session queryservice. } // Begin is part of the QueryService interface. -func (sbc *SandboxConn) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (queryservice.TransactionState, error) { +func (sbc *SandboxConn) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (queryservice.TransactionState, error) { sbc.panicIfNeeded() - return sbc.begin(ctx, session, target, nil, 0) + return sbc.begin(ctx, session, target, nil, 0, options) } -func (sbc *SandboxConn) begin(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, reservedID int64) (queryservice.TransactionState, error) { +func (sbc *SandboxConn) begin(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, reservedID int64, options *querypb.ExecuteOptions) (queryservice.TransactionState, error) { sbc.BeginCount.Add(1) err := sbc.getError() if err != nil { @@ -355,7 +355,7 @@ func (sbc *SandboxConn) begin(ctx context.Context, session queryservice.Session, transactionID = sbc.TransactionID.Add(1) } for _, preQuery := range preQueries { - _, err := sbc.Execute(ctx, session, target, preQuery, nil, transactionID, reservedID) + _, err := sbc.Execute(ctx, session, target, preQuery, nil, transactionID, reservedID, options) if err != nil { return queryservice.TransactionState{}, err } @@ -494,30 +494,30 @@ func (sbc *SandboxConn) UnresolvedTransactions(context.Context, *querypb.Target, } // BeginExecute is part of the QueryService interface. -func (sbc *SandboxConn) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64) (queryservice.TransactionState, *sqltypes.Result, error) { +func (sbc *SandboxConn) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, query string, bindVars map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (queryservice.TransactionState, *sqltypes.Result, error) { sbc.panicIfNeeded() - state, err := sbc.begin(ctx, session, target, preQueries, reservedID) + state, err := sbc.begin(ctx, session, target, preQueries, reservedID, options) if state.TransactionID != 0 { sbc.setTxReservedID(state.TransactionID, reservedID) } if err != nil { return queryservice.TransactionState{}, nil, err } - result, err := sbc.Execute(ctx, session, target, query, bindVars, state.TransactionID, reservedID) + result, err := sbc.Execute(ctx, session, target, query, bindVars, state.TransactionID, reservedID, options) return state, result, err } // BeginStreamExecute is part of the QueryService interface. -func (sbc *SandboxConn) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, callback func(*sqltypes.Result) error) (queryservice.TransactionState, error) { +func (sbc *SandboxConn) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.TransactionState, error) { sbc.panicIfNeeded() - state, err := sbc.begin(ctx, session, target, preQueries, reservedID) + state, err := sbc.begin(ctx, session, target, preQueries, reservedID, options) if state.TransactionID != 0 { sbc.setTxReservedID(state.TransactionID, reservedID) } if err != nil { return queryservice.TransactionState{}, err } - err = sbc.StreamExecute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, callback) + err = sbc.StreamExecute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, options, callback) return state, err } @@ -669,10 +669,10 @@ func (sbc *SandboxConn) HandlePanic(err *error) { } // ReserveBeginExecute implements the QueryService interface -func (sbc *SandboxConn) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { +func (sbc *SandboxConn) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { sbc.panicIfNeeded() - reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, 0) - state, result, err := sbc.BeginExecute(ctx, session, target, postBeginQueries, sql, bindVariables, reservedID) + reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, 0, options) + state, result, err := sbc.BeginExecute(ctx, session, target, postBeginQueries, sql, bindVariables, reservedID, options) if state.TransactionID != 0 { sbc.setTxReservedID(state.TransactionID, reservedID) } @@ -684,10 +684,10 @@ func (sbc *SandboxConn) ReserveBeginExecute(ctx context.Context, session queryse } // ReserveBeginStreamExecute is part of the QueryService interface. -func (sbc *SandboxConn) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, callback func(*sqltypes.Result) error) (queryservice.ReservedTransactionState, error) { +func (sbc *SandboxConn) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.ReservedTransactionState, error) { sbc.panicIfNeeded() - reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, 0) - state, err := sbc.BeginStreamExecute(ctx, session, target, postBeginQueries, sql, bindVariables, reservedID, callback) + reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, 0, options) + state, err := sbc.BeginStreamExecute(ctx, session, target, postBeginQueries, sql, bindVariables, reservedID, options, callback) if state.TransactionID != 0 { sbc.setTxReservedID(state.TransactionID, reservedID) } @@ -699,10 +699,10 @@ func (sbc *SandboxConn) ReserveBeginStreamExecute(ctx context.Context, session q } // ReserveExecute implements the QueryService interface -func (sbc *SandboxConn) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (queryservice.ReservedState, *sqltypes.Result, error) { +func (sbc *SandboxConn) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (queryservice.ReservedState, *sqltypes.Result, error) { sbc.panicIfNeeded() - reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, transactionID) - result, err := sbc.Execute(ctx, session, target, sql, bindVariables, transactionID, reservedID) + reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, transactionID, options) + result, err := sbc.Execute(ctx, session, target, sql, bindVariables, transactionID, reservedID, options) if transactionID != 0 { sbc.setTxReservedID(transactionID, reservedID) } @@ -713,10 +713,10 @@ func (sbc *SandboxConn) ReserveExecute(ctx context.Context, session queryservice } // ReserveStreamExecute is part of the QueryService interface. -func (sbc *SandboxConn) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, callback func(*sqltypes.Result) error) (queryservice.ReservedState, error) { +func (sbc *SandboxConn) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.ReservedState, error) { sbc.panicIfNeeded() - reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, transactionID) - err := sbc.StreamExecute(ctx, session, target, sql, bindVariables, transactionID, reservedID, callback) + reservedID := sbc.reserve(ctx, session, target, preQueries, bindVariables, transactionID, options) + err := sbc.StreamExecute(ctx, session, target, sql, bindVariables, transactionID, reservedID, options, callback) if transactionID != 0 { sbc.setTxReservedID(transactionID, reservedID) } @@ -726,10 +726,10 @@ func (sbc *SandboxConn) ReserveStreamExecute(ctx context.Context, session querys }, err } -func (sbc *SandboxConn) reserve(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, bindVariables map[string]*querypb.BindVariable, transactionID int64) int64 { +func (sbc *SandboxConn) reserve(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) int64 { sbc.ReserveCount.Add(1) for _, query := range preQueries { - sbc.Execute(ctx, session, target, query, bindVariables, transactionID, 0) + sbc.Execute(ctx, session, target, query, bindVariables, transactionID, 0, options) } if transactionID != 0 { return transactionID @@ -894,12 +894,3 @@ func (sbc *SandboxConn) panicIfNeeded() { panic(sbc.panicThis) } } - -// getOptions safely extracts ExecuteOptions from a session, returning nil if session is nil. -func getOptions(session queryservice.Session) *querypb.ExecuteOptions { - if session == nil { - return nil - } - - return session.GetOptions() -} diff --git a/go/vt/vttablet/tabletconntest/fakequeryservice.go b/go/vt/vttablet/tabletconntest/fakequeryservice.go index 6ba49809b6a..eb22d655e88 100644 --- a/go/vt/vttablet/tabletconntest/fakequeryservice.go +++ b/go/vt/vttablet/tabletconntest/fakequeryservice.go @@ -33,7 +33,6 @@ import ( binlogdatapb "vitess.io/vitess/go/vt/proto/binlogdata" querypb "vitess.io/vitess/go/vt/proto/query" topodatapb "vitess.io/vitess/go/vt/proto/topodata" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) @@ -105,12 +104,10 @@ var TestVTGateCallerID = &querypb.VTGateCallerID{ Username: "test_username", } -// TestSession is a test execute options. -var TestSession = &vtgatepb.Session{ - Options: &querypb.ExecuteOptions{ - IncludedFields: querypb.ExecuteOptions_TYPE_ONLY, - ClientFoundRows: true, - }, +// TestExecuteOptions is a test execute options. +var TestExecuteOptions = &querypb.ExecuteOptions{ + IncludedFields: querypb.ExecuteOptions_TYPE_ONLY, + ClientFoundRows: true, } // TestAsTransaction is a test 'asTransaction' flag. @@ -144,7 +141,7 @@ func (f *FakeQueryService) checkTargetCallerID(ctx context.Context, name string, const beginTransactionID int64 = 9990 // Begin is part of the queryservice.QueryService interface -func (f *FakeQueryService) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (queryservice.TransactionState, error) { +func (f *FakeQueryService) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (queryservice.TransactionState, error) { if f.HasBeginError { return queryservice.TransactionState{}, f.TabletError } @@ -152,8 +149,8 @@ func (f *FakeQueryService) Begin(ctx context.Context, session queryservice.Sessi panic(errors.New("test-triggered panic")) } f.checkTargetCallerID(ctx, "Begin", target) - if !proto.Equal(getOptions(session), TestSession.GetOptions()) { - f.t.Errorf("invalid Execute.ExecuteOptions: got %v expected %v", getOptions(session), TestSession.GetOptions()) + if !proto.Equal(options, TestExecuteOptions) { + f.t.Errorf("invalid Execute.ExecuteOptions: got %v expected %v", options, TestExecuteOptions) } return queryservice.TransactionState{TransactionID: beginTransactionID, TabletAlias: TestAlias}, nil } @@ -415,7 +412,7 @@ var ExecuteQueryResult = sqltypes.Result{ } // Execute is part of the queryservice.QueryService interface -func (f *FakeQueryService) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) { +func (f *FakeQueryService) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { if f.HasError { return nil, f.TabletError } @@ -428,8 +425,8 @@ func (f *FakeQueryService) Execute(ctx context.Context, session queryservice.Ses if !sqltypes.BindVariablesEqual(bindVariables, ExecuteBindVars) { f.t.Errorf("invalid Execute.BindVariables: got %v expected %v", bindVariables, ExecuteBindVars) } - if !proto.Equal(getOptions(session), TestSession.GetOptions()) { - f.t.Errorf("invalid Execute.ExecuteOptions: got %v expected %v", getOptions(session), TestSession.GetOptions()) + if !proto.Equal(options, TestExecuteOptions) { + f.t.Errorf("invalid Execute.ExecuteOptions: got %v expected %v", options, TestExecuteOptions) } f.checkTargetCallerID(ctx, "Execute", target) if transactionID != f.ExpectedTransactionID { @@ -475,7 +472,7 @@ var StreamExecuteQueryResult2 = sqltypes.Result{ } // StreamExecute is part of the queryservice.QueryService interface -func (f *FakeQueryService) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) error { +func (f *FakeQueryService) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error { if f.Panics && f.StreamExecutePanicsEarly { panic(errors.New("test-triggered panic early")) } @@ -485,8 +482,8 @@ func (f *FakeQueryService) StreamExecute(ctx context.Context, session queryservi if !sqltypes.BindVariablesEqual(bindVariables, StreamExecuteBindVars) { f.t.Errorf("invalid StreamExecute.BindVariables: got %v expected %v", bindVariables, StreamExecuteBindVars) } - if !proto.Equal(getOptions(session), TestSession.GetOptions()) { - f.t.Errorf("invalid StreamExecute.ExecuteOptions: got %v expected %v", getOptions(session), TestSession.GetOptions()) + if !proto.Equal(options, TestExecuteOptions) { + f.t.Errorf("invalid StreamExecute.ExecuteOptions: got %v expected %v", options, TestExecuteOptions) } f.checkTargetCallerID(ctx, "StreamExecute", target) if err := callback(&StreamExecuteQueryResult1); err != nil { @@ -570,32 +567,32 @@ var ExecuteBatchQueryResultList = []sqltypes.Result{ } // BeginExecute combines Begin and Execute. -func (f *FakeQueryService) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, _ []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64) (queryservice.TransactionState, *sqltypes.Result, error) { - state, err := f.Begin(ctx, session, target) +func (f *FakeQueryService) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, _ []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (queryservice.TransactionState, *sqltypes.Result, error) { + state, err := f.Begin(ctx, session, target, options) if err != nil { return state, nil, err } // TODO(deepthi): what alias should we actually return here? - result, err := f.Execute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID) + result, err := f.Execute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, options) return state, result, err } // BeginStreamExecute combines Begin and StreamExecute. -func (f *FakeQueryService) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, callback func(*sqltypes.Result) error) (queryservice.TransactionState, error) { - state, err := f.Begin(ctx, session, target) +func (f *FakeQueryService) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.TransactionState, error) { + state, err := f.Begin(ctx, session, target, options) if err != nil { return state, err } for _, preQuery := range preQueries { - _, err := f.Execute(ctx, session, target, preQuery, nil, state.TransactionID, reservedID) + _, err := f.Execute(ctx, session, target, preQuery, nil, state.TransactionID, reservedID, options) if err != nil { return state, err } } - err = f.StreamExecute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, callback) + err = f.StreamExecute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, options, callback) return state, err } @@ -735,27 +732,27 @@ func (f *FakeQueryService) GetServingKeyspaces() []string { } // ReserveBeginExecute satisfies the Gateway interface -func (f *FakeQueryService) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { +func (f *FakeQueryService) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { panic("implement me") } // ReserveBeginStreamExecute satisfies the Gateway interface -func (f *FakeQueryService) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, callback func(*sqltypes.Result) error) (queryservice.ReservedTransactionState, error) { +func (f *FakeQueryService) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.ReservedTransactionState, error) { panic("implement me") } // ReserveExecute implements the QueryService interface -func (f *FakeQueryService) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (queryservice.ReservedState, *sqltypes.Result, error) { +func (f *FakeQueryService) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (queryservice.ReservedState, *sqltypes.Result, error) { panic("implement me") } // ReserveStreamExecute satisfies the Gateway interface -func (f *FakeQueryService) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, callback func(*sqltypes.Result) error) (queryservice.ReservedState, error) { +func (f *FakeQueryService) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.ReservedState, error) { state, err := f.reserve(transactionID) if err != nil { return state, err } - err = f.StreamExecute(ctx, session, target, sql, bindVariables, transactionID, state.ReservedID, callback) + err = f.StreamExecute(ctx, session, target, sql, bindVariables, transactionID, state.ReservedID, options, callback) return state, err } @@ -787,12 +784,3 @@ func CreateFakeServer(t testing.TB) *FakeQueryService { t: t, } } - -// getOptions safely extracts ExecuteOptions from a session, returning nil if session is nil. -func getOptions(session queryservice.Session) *querypb.ExecuteOptions { - if session == nil { - return nil - } - - return session.GetOptions() -} diff --git a/go/vt/vttablet/tabletconntest/tabletconntest.go b/go/vt/vttablet/tabletconntest/tabletconntest.go index a10b2b42bff..1dd200329c9 100644 --- a/go/vt/vttablet/tabletconntest/tabletconntest.go +++ b/go/vt/vttablet/tabletconntest/tabletconntest.go @@ -102,7 +102,7 @@ func testBegin(t *testing.T, conn queryservice.QueryService, f *FakeQueryService t.Log("testBegin") ctx := context.Background() ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - state, err := conn.Begin(ctx, TestSession, TestTarget) + state, err := conn.Begin(ctx, nil, TestTarget, TestExecuteOptions) if err != nil { t.Fatalf("Begin failed: %v", err) } @@ -116,7 +116,7 @@ func testBeginError(t *testing.T, conn queryservice.QueryService, f *FakeQuerySe t.Log("testBeginError") f.HasBeginError = true testErrorHelper(t, f, "Begin", func(ctx context.Context) error { - _, err := conn.Begin(ctx, nil, TestTarget) + _, err := conn.Begin(ctx, nil, TestTarget, nil) return err }) f.HasBeginError = false @@ -125,7 +125,7 @@ func testBeginError(t *testing.T, conn queryservice.QueryService, f *FakeQuerySe func testBeginPanics(t *testing.T, conn queryservice.QueryService, f *FakeQueryService) { t.Log("testBeginPanics") testPanicHelper(t, f, "Begin", func(ctx context.Context) error { - _, err := conn.Begin(ctx, nil, TestTarget) + _, err := conn.Begin(ctx, nil, TestTarget, nil) return err }) } @@ -436,7 +436,7 @@ func testExecute(t *testing.T, conn queryservice.QueryService, f *FakeQueryServi f.ExpectedTransactionID = ExecuteTransactionID ctx := context.Background() ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - qr, err := conn.Execute(ctx, TestSession, TestTarget, ExecuteQuery, ExecuteBindVars, ExecuteTransactionID, ReserveConnectionID) + qr, err := conn.Execute(ctx, nil, TestTarget, ExecuteQuery, ExecuteBindVars, ExecuteTransactionID, ReserveConnectionID, TestExecuteOptions) if err != nil { t.Fatalf("Execute failed: %v", err) } @@ -449,7 +449,7 @@ func testExecuteError(t *testing.T, conn queryservice.QueryService, f *FakeQuery t.Log("testExecuteError") f.HasError = true testErrorHelper(t, f, "Execute", func(ctx context.Context) error { - _, err := conn.Execute(ctx, TestSession, TestTarget, ExecuteQuery, ExecuteBindVars, ExecuteTransactionID, ReserveConnectionID) + _, err := conn.Execute(ctx, nil, TestTarget, ExecuteQuery, ExecuteBindVars, ExecuteTransactionID, ReserveConnectionID, TestExecuteOptions) return err }) f.HasError = false @@ -458,7 +458,7 @@ func testExecuteError(t *testing.T, conn queryservice.QueryService, f *FakeQuery func testExecutePanics(t *testing.T, conn queryservice.QueryService, f *FakeQueryService) { t.Log("testExecutePanics") testPanicHelper(t, f, "Execute", func(ctx context.Context) error { - _, err := conn.Execute(ctx, TestSession, TestTarget, ExecuteQuery, ExecuteBindVars, ExecuteTransactionID, ReserveConnectionID) + _, err := conn.Execute(ctx, nil, TestTarget, ExecuteQuery, ExecuteBindVars, ExecuteTransactionID, ReserveConnectionID, TestExecuteOptions) return err }) } @@ -468,7 +468,7 @@ func testBeginExecute(t *testing.T, conn queryservice.QueryService, f *FakeQuery f.ExpectedTransactionID = beginTransactionID ctx := context.Background() ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - state, qr, err := conn.BeginExecute(ctx, TestSession, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID) + state, qr, err := conn.BeginExecute(ctx, nil, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID, TestExecuteOptions) if err != nil { t.Fatalf("BeginExecute failed: %v", err) } @@ -485,7 +485,7 @@ func testBeginExecuteErrorInBegin(t *testing.T, conn queryservice.QueryService, t.Log("testBeginExecuteErrorInBegin") f.HasBeginError = true testErrorHelper(t, f, "BeginExecute.Begin", func(ctx context.Context) error { - state, _, err := conn.BeginExecute(ctx, TestSession, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID) + state, _, err := conn.BeginExecute(ctx, nil, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID, TestExecuteOptions) if state.TransactionID != 0 { t.Errorf("Unexpected transactionID from BeginExecute: got %v wanted 0", state.TransactionID) } @@ -499,7 +499,7 @@ func testBeginExecuteErrorInExecute(t *testing.T, conn queryservice.QueryService f.HasError = true testErrorHelper(t, f, "BeginExecute.Execute", func(ctx context.Context) error { ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - state, _, err := conn.BeginExecute(ctx, TestSession, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID) + state, _, err := conn.BeginExecute(ctx, nil, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID, TestExecuteOptions) if state.TransactionID != beginTransactionID { t.Errorf("Unexpected transactionID from BeginExecute: got %v wanted %v", state.TransactionID, beginTransactionID) } @@ -511,7 +511,7 @@ func testBeginExecuteErrorInExecute(t *testing.T, conn queryservice.QueryService func testBeginExecutePanics(t *testing.T, conn queryservice.QueryService, f *FakeQueryService) { t.Log("testBeginExecutePanics") testPanicHelper(t, f, "BeginExecute", func(ctx context.Context) error { - _, _, err := conn.BeginExecute(ctx, TestSession, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID) + _, _, err := conn.BeginExecute(ctx, nil, TestTarget, nil, ExecuteQuery, ExecuteBindVars, ReserveConnectionID, TestExecuteOptions) return err }) } @@ -521,7 +521,7 @@ func testStreamExecute(t *testing.T, conn queryservice.QueryService, f *FakeQuer ctx := context.Background() ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) i := 0 - err := conn.StreamExecute(ctx, TestSession, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, func(qr *sqltypes.Result) error { + err := conn.StreamExecute(ctx, nil, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { switch i { case 0: if len(qr.Rows) == 0 { @@ -557,7 +557,7 @@ func testStreamExecuteError(t *testing.T, conn queryservice.QueryService, f *Fak testErrorHelper(t, f, "StreamExecute", func(ctx context.Context) error { f.ErrorWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - return conn.StreamExecute(ctx, TestSession, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, func(qr *sqltypes.Result) error { + return conn.StreamExecute(ctx, nil, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.ErrorWait: @@ -586,7 +586,7 @@ func testStreamExecutePanics(t *testing.T, conn queryservice.QueryService, f *Fa f.StreamExecutePanicsEarly = true testPanicHelper(t, f, "StreamExecute.Early", func(ctx context.Context) error { ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - return conn.StreamExecute(ctx, TestSession, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, func(qr *sqltypes.Result) error { + return conn.StreamExecute(ctx, nil, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { return nil }) }) @@ -596,7 +596,7 @@ func testStreamExecutePanics(t *testing.T, conn queryservice.QueryService, f *Fa testPanicHelper(t, f, "StreamExecute.Late", func(ctx context.Context) error { f.PanicWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - return conn.StreamExecute(ctx, TestSession, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, func(qr *sqltypes.Result) error { + return conn.StreamExecute(ctx, nil, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.PanicWait: @@ -621,7 +621,7 @@ func testBeginStreamExecute(t *testing.T, conn queryservice.QueryService, f *Fak ctx := context.Background() ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) i := 0 - _, err := conn.BeginStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + _, err := conn.BeginStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { switch i { case 0: if len(qr.Rows) == 0 { @@ -656,7 +656,7 @@ func testReserveStreamExecute(t *testing.T, conn queryservice.QueryService, f *F ctx := context.Background() ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) i := 0 - _, err := conn.ReserveStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + _, err := conn.ReserveStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { switch i { case 0: if len(qr.Rows) == 0 { @@ -692,7 +692,7 @@ func testBeginStreamExecuteErrorInBegin(t *testing.T, conn queryservice.QuerySer testErrorHelper(t, f, "StreamExecute", func(ctx context.Context) error { f.ErrorWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - _, err := conn.BeginStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + _, err := conn.BeginStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.ErrorWait: @@ -720,7 +720,7 @@ func testBeginStreamExecuteErrorInExecute(t *testing.T, conn queryservice.QueryS testErrorHelper(t, f, "StreamExecute", func(ctx context.Context) error { f.ErrorWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - state, err := conn.BeginStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + state, err := conn.BeginStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.ErrorWait: @@ -749,7 +749,7 @@ func testReserveStreamExecuteErrorInReserve(t *testing.T, conn queryservice.Quer testErrorHelper(t, f, "ReserveStreamExecute", func(ctx context.Context) error { f.ErrorWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - _, err := conn.ReserveStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + _, err := conn.ReserveStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.ErrorWait: @@ -777,7 +777,7 @@ func testReserveStreamExecuteErrorInExecute(t *testing.T, conn queryservice.Quer testErrorHelper(t, f, "ReserveStreamExecute", func(ctx context.Context) error { f.ErrorWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - state, err := conn.ReserveStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + state, err := conn.ReserveStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.ErrorWait: @@ -808,7 +808,7 @@ func testBeginStreamExecutePanics(t *testing.T, conn queryservice.QueryService, f.StreamExecutePanicsEarly = true testPanicHelper(t, f, "StreamExecute.Early", func(ctx context.Context) error { ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - return conn.StreamExecute(ctx, TestSession, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, func(qr *sqltypes.Result) error { + return conn.StreamExecute(ctx, nil, TestTarget, StreamExecuteQuery, StreamExecuteBindVars, 0, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { return nil }) }) @@ -818,7 +818,7 @@ func testBeginStreamExecutePanics(t *testing.T, conn queryservice.QueryService, testPanicHelper(t, f, "StreamExecute.Late", func(ctx context.Context) error { f.PanicWait = make(chan struct{}) ctx = callerid.NewContext(ctx, TestCallerID, TestVTGateCallerID) - _, err := conn.BeginStreamExecute(ctx, TestSession, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, func(qr *sqltypes.Result) error { + _, err := conn.BeginStreamExecute(ctx, nil, TestTarget, nil, StreamExecuteQuery, StreamExecuteBindVars, 0, TestExecuteOptions, func(qr *sqltypes.Result) error { // For some errors, the call can be retried. select { case <-f.PanicWait: diff --git a/go/vt/vttablet/tabletmanager/framework_test.go b/go/vt/vttablet/tabletmanager/framework_test.go index 8f4cc38b59b..ddae50c8cee 100644 --- a/go/vt/vttablet/tabletmanager/framework_test.go +++ b/go/vt/vttablet/tabletmanager/framework_test.go @@ -217,7 +217,7 @@ type fakeTabletConn struct { } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (queryservice.TransactionState, error) { +func (ftc *fakeTabletConn) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (queryservice.TransactionState, error) { return queryservice.TransactionState{ TransactionID: 1, }, nil @@ -274,24 +274,24 @@ func (ftc *fakeTabletConn) ReadTransaction(ctx context.Context, target *querypb. } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64) (*sqltypes.Result, error) { +func (ftc *fakeTabletConn) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (*sqltypes.Result, error) { return nil, nil } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) error { +func (ftc *fakeTabletConn) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error { return nil } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64) (queryservice.TransactionState, *sqltypes.Result, error) { +func (ftc *fakeTabletConn) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (queryservice.TransactionState, *sqltypes.Result, error) { return queryservice.TransactionState{ TransactionID: 1, }, nil, nil } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, callback func(*sqltypes.Result) error) (queryservice.TransactionState, error) { +func (ftc *fakeTabletConn) BeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.TransactionState, error) { return queryservice.TransactionState{ TransactionID: 1, }, nil @@ -327,28 +327,28 @@ func (ftc *fakeTabletConn) HandlePanic(err *error) { } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { +func (ftc *fakeTabletConn) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (queryservice.ReservedTransactionState, *sqltypes.Result, error) { return queryservice.ReservedTransactionState{ ReservedID: 1, }, nil, nil } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, callback func(*sqltypes.Result) error) (queryservice.ReservedTransactionState, error) { +func (ftc *fakeTabletConn) ReserveBeginStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.ReservedTransactionState, error) { return queryservice.ReservedTransactionState{ ReservedID: 1, }, nil } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (queryservice.ReservedState, *sqltypes.Result, error) { +func (ftc *fakeTabletConn) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (queryservice.ReservedState, *sqltypes.Result, error) { return queryservice.ReservedState{ ReservedID: 1, }, nil, nil } // fakeTabletConn implements the QueryService interface. -func (ftc *fakeTabletConn) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, callback func(*sqltypes.Result) error) (queryservice.ReservedState, error) { +func (ftc *fakeTabletConn) ReserveStreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, preQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (queryservice.ReservedState, error) { return queryservice.ReservedState{ ReservedID: 1, }, nil diff --git a/go/vt/vttablet/tabletmanager/rpc_query.go b/go/vt/vttablet/tabletmanager/rpc_query.go index 3a3fdc39b2b..bb3075175db 100644 --- a/go/vt/vttablet/tabletmanager/rpc_query.go +++ b/go/vt/vttablet/tabletmanager/rpc_query.go @@ -293,6 +293,6 @@ func (tm *TabletManager) ExecuteQuery(ctx context.Context, req *tabletmanagerdat if err != nil { return nil, err } - result, err := tm.QueryServiceControl.QueryService().Execute(ctx, nil, target, uq, nil, 0, 0) + result, err := tm.QueryServiceControl.QueryService().Execute(ctx, nil, target, uq, nil, 0, 0, nil) return sqltypes.ResultToProto3(result), err } diff --git a/go/vt/vttablet/tabletserver/bench_test.go b/go/vt/vttablet/tabletserver/bench_test.go index d2cd12c853f..3290f4cbb1f 100644 --- a/go/vt/vttablet/tabletserver/bench_test.go +++ b/go/vt/vttablet/tabletserver/bench_test.go @@ -73,7 +73,7 @@ func BenchmarkExecuteVarBinary(b *testing.B) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} db.SetAllowAll(true) for b.Loop() { - if _, err := tsv.Execute(ctx, nil, &target, benchQuery, bv, 0, 0); err != nil { + if _, err := tsv.Execute(ctx, nil, &target, benchQuery, bv, 0, 0, nil); err != nil { panic(err) } } @@ -100,7 +100,7 @@ func BenchmarkExecuteExpression(b *testing.B) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} db.SetAllowAll(true) for b.Loop() { - if _, err := tsv.Execute(ctx, nil, &target, benchQuery, bv, 0, 0); err != nil { + if _, err := tsv.Execute(ctx, nil, &target, benchQuery, bv, 0, 0, nil); err != nil { panic(err) } } diff --git a/go/vt/vttablet/tabletserver/dt_executor_test.go b/go/vt/vttablet/tabletserver/dt_executor_test.go index 5f24ef2a0f4..bdcb70e430b 100644 --- a/go/vt/vttablet/tabletserver/dt_executor_test.go +++ b/go/vt/vttablet/tabletserver/dt_executor_test.go @@ -771,7 +771,7 @@ func newNoTwopcExecutor(t *testing.T, ctx context.Context) (txe *DTExecutor, tsv func newTxForPrep(ctx context.Context, tsv *TabletServer) int64 { txid := newTransaction(tsv, nil) target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - _, err := tsv.Execute(ctx, nil, &target, "update test_table set name = 2 where pk = 1", nil, txid, 0) + _, err := tsv.Execute(ctx, nil, &target, "update test_table set name = 2 where pk = 1", nil, txid, 0, nil) if err != nil { panic(err) } diff --git a/go/vt/vttablet/tabletserver/query_executor_test.go b/go/vt/vttablet/tabletserver/query_executor_test.go index 2e94f0eaa33..7678df3fb6b 100644 --- a/go/vt/vttablet/tabletserver/query_executor_test.go +++ b/go/vt/vttablet/tabletserver/query_executor_test.go @@ -55,7 +55,6 @@ import ( querypb "vitess.io/vitess/go/vt/proto/query" tableaclpb "vitess.io/vitess/go/vt/proto/tableacl" topodatapb "vitess.io/vitess/go/vt/proto/topodata" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) @@ -354,7 +353,7 @@ func TestQueryExecutorPlans(t *testing.T) { // Test inside a transaction. target := tsv.sm.Target() - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) if !tcase.outsideTxErr && tcase.errorWant != "" && !tcase.onlyInTxErr { require.EqualError(t, err, tcase.errorWant) return @@ -451,7 +450,7 @@ func TestQueryExecutorQueryAnnotation(t *testing.T) { // Test inside a transaction. target := tsv.sm.Target() - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) require.NoError(t, err) require.NotNil(t, state.TabletAlias, "alias should not be nil") assert.Equal(t, tsv.alias, state.TabletAlias, "Wrong alias returned by Begin") @@ -518,7 +517,7 @@ func TestQueryExecutorSelectImpossible(t *testing.T) { assert.Equal(t, tcase.planWant, qre.logStats.PlanType, tcase.input) assert.Equal(t, tcase.logWant, qre.logStats.RewrittenSQL(), tcase.input) target := tsv.sm.Target() - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) require.NoError(t, err) require.NotNil(t, state.TabletAlias, "alias should not be nil") assert.Equal(t, tsv.alias, state.TabletAlias, "Wrong tablet alias from Begin") @@ -649,7 +648,7 @@ func TestQueryExecutorLimitFailure(t *testing.T) { // Test inside a transaction. target := tsv.sm.Target() - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) require.NoError(t, err) require.NotNil(t, state.TabletAlias, "alias should not be nil") assert.Equal(t, tsv.alias, state.TabletAlias, "Wrong tablet alias from Begin") @@ -1640,7 +1639,7 @@ func newTestTabletServer(ctx context.Context, flags executorFlags, db *fakesqldb func newTransaction(tsv *TabletServer, options *querypb.ExecuteOptions) int64 { target := tsv.sm.Target() - state, err := tsv.Begin(context.Background(), &vtgatepb.Session{Options: options}, target) + state, err := tsv.Begin(context.Background(), nil, target, options) if err != nil { panic(vterrors.Wrap(err, "failed to start a transaction")) } diff --git a/go/vt/vttablet/tabletserver/tabletserver.go b/go/vt/vttablet/tabletserver/tabletserver.go index 60f5ab2d436..8f2341ac178 100644 --- a/go/vt/vttablet/tabletserver/tabletserver.go +++ b/go/vt/vttablet/tabletserver/tabletserver.go @@ -469,6 +469,7 @@ func (tsv *TabletServer) IsHealthy() error { nil, 0, 0, + nil, ) return err } @@ -535,8 +536,8 @@ func (tsv *TabletServer) SchemaEngine() *schema.Engine { } // Begin starts a new transaction. This is allowed only if the state is StateServing. -func (tsv *TabletServer) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target) (state queryservice.TransactionState, err error) { - return tsv.begin(ctx, target, nil, 0, nil, getOptions(session)) +func (tsv *TabletServer) Begin(ctx context.Context, session queryservice.Session, target *querypb.Target, options *querypb.ExecuteOptions) (state queryservice.TransactionState, err error) { + return tsv.begin(ctx, target, nil, 0, nil, options) } func (tsv *TabletServer) begin( @@ -903,7 +904,7 @@ func (tsv *TabletServer) UnresolvedTransactions(ctx context.Context, target *que } // Execute executes the query and returns the result as response. -func (tsv *TabletServer) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64) (result *sqltypes.Result, err error) { +func (tsv *TabletServer) Execute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID, reservedID int64, options *querypb.ExecuteOptions) (result *sqltypes.Result, err error) { span, ctx := trace.NewSpan(ctx, "TabletServer.Execute") trace.AnnotateSQL(span, sqlparser.Preview(sql)) defer span.Finish() @@ -912,7 +913,7 @@ func (tsv *TabletServer) Execute(ctx context.Context, session queryservice.Sessi return nil, vterrors.New(vtrpcpb.Code_INTERNAL, "[BUG] transactionID and reserveID must match if both are non-zero") } - return tsv.execute(ctx, target, sql, bindVariables, transactionID, reservedID, nil, getOptions(session)) + return tsv.execute(ctx, target, sql, bindVariables, transactionID, reservedID, nil, options) } func (tsv *TabletServer) execute(ctx context.Context, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, settings []string, options *querypb.ExecuteOptions) (result *sqltypes.Result, err error) { @@ -1009,12 +1010,12 @@ func smallerTimeout(t1, t2 time.Duration) time.Duration { // StreamExecute executes the query and streams the result. // The first QueryResult will have Fields set (and Rows nil). // The subsequent QueryResult will have Rows set (and Fields nil). -func (tsv *TabletServer) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, callback func(*sqltypes.Result) error) (err error) { +func (tsv *TabletServer) StreamExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) (err error) { if transactionID != 0 && reservedID != 0 && transactionID != reservedID { return vterrors.New(vtrpcpb.Code_INTERNAL, "[BUG] transactionID and reserveID must match if both are non-zero") } - return tsv.streamExecute(ctx, target, sql, bindVariables, transactionID, reservedID, nil, getOptions(session), callback) + return tsv.streamExecute(ctx, target, sql, bindVariables, transactionID, reservedID, nil, options, callback) } func (tsv *TabletServer) streamExecute(ctx context.Context, target *querypb.Target, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, reservedID int64, settings []string, options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error) error { @@ -1077,9 +1078,7 @@ func (tsv *TabletServer) streamExecute(ctx context.Context, target *querypb.Targ } // BeginExecute combines Begin and Execute. -func (tsv *TabletServer) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64) (queryservice.TransactionState, *sqltypes.Result, error) { - options := getOptions(session) - +func (tsv *TabletServer) BeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, options *querypb.ExecuteOptions) (queryservice.TransactionState, *sqltypes.Result, error) { // Disable hot row protection in case of reserve connection. if tsv.enableHotRowProtection && reservedID == 0 { txDone, err := tsv.beginWaitForSameRangeTransactions(ctx, target, options, sql, bindVariables) @@ -1096,7 +1095,7 @@ func (tsv *TabletServer) BeginExecute(ctx context.Context, session queryservice. return state, nil, err } - result, err := tsv.Execute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID) + result, err := tsv.Execute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, options) return state, result, err } @@ -1109,14 +1108,15 @@ func (tsv *TabletServer) BeginStreamExecute( sql string, bindVariables map[string]*querypb.BindVariable, reservedID int64, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) (queryservice.TransactionState, error) { - state, err := tsv.begin(ctx, target, postBeginQueries, reservedID, nil, getOptions(session)) + state, err := tsv.begin(ctx, target, postBeginQueries, reservedID, nil, options) if err != nil { return state, err } - err = tsv.StreamExecute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, callback) + err = tsv.StreamExecute(ctx, session, target, sql, bindVariables, state.TransactionID, reservedID, options, callback) return state, err } @@ -1273,7 +1273,7 @@ func (tsv *TabletServer) execDML(ctx context.Context, target *querypb.Target, qu return 0, err } - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) if err != nil { return 0, err } @@ -1284,7 +1284,7 @@ func (tsv *TabletServer) execDML(ctx context.Context, target *querypb.Target, qu tsv.Rollback(ctx, target, state.TransactionID) } }() - qr, err := tsv.Execute(ctx, nil, target, query, bv, state.TransactionID, 0) + qr, err := tsv.Execute(ctx, nil, target, query, bv, state.TransactionID, 0, nil) if err != nil { return 0, err } @@ -1337,9 +1337,7 @@ func (tsv *TabletServer) VStreamResults(ctx context.Context, target *querypb.Tar } // ReserveBeginExecute implements the QueryService interface -func (tsv *TabletServer) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, settings []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable) (state queryservice.ReservedTransactionState, result *sqltypes.Result, err error) { - options := getOptions(session) - +func (tsv *TabletServer) ReserveBeginExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, settings []string, postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, options *querypb.ExecuteOptions) (state queryservice.ReservedTransactionState, result *sqltypes.Result, err error) { state, result, err = tsv.beginExecuteWithSettings(ctx, target, settings, postBeginQueries, sql, bindVariables, options) // If there is an error and the error message is about allowing query in reserved connection only, // then we do not return an error from here and continue to use the reserved connection path. @@ -1420,10 +1418,9 @@ func (tsv *TabletServer) ReserveBeginStreamExecute( postBeginQueries []string, sql string, bindVariables map[string]*querypb.BindVariable, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) (state queryservice.ReservedTransactionState, err error) { - options := getOptions(session) - txState, err := tsv.begin(ctx, target, postBeginQueries, 0, settings, options) if err != nil { return txToReserveState(txState), err @@ -1434,9 +1431,7 @@ func (tsv *TabletServer) ReserveBeginStreamExecute( } // ReserveExecute implements the QueryService interface -func (tsv *TabletServer) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, settings []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64) (state queryservice.ReservedState, result *sqltypes.Result, err error) { - options := getOptions(session) - +func (tsv *TabletServer) ReserveExecute(ctx context.Context, session queryservice.Session, target *querypb.Target, settings []string, sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, options *querypb.ExecuteOptions) (state queryservice.ReservedState, result *sqltypes.Result, err error) { result, err = tsv.executeWithSettings(ctx, target, settings, sql, bindVariables, transactionID, options) // If there is an error and the error message is about allowing query in reserved connection only, // then we do not return an error from here and continue to use the reserved connection path. @@ -1488,9 +1483,10 @@ func (tsv *TabletServer) ReserveStreamExecute( sql string, bindVariables map[string]*querypb.BindVariable, transactionID int64, + options *querypb.ExecuteOptions, callback func(*sqltypes.Result) error, ) (state queryservice.ReservedState, err error) { - return state, tsv.streamExecute(ctx, target, sql, bindVariables, transactionID, 0, settings, getOptions(session), callback) + return state, tsv.streamExecute(ctx, target, sql, bindVariables, transactionID, 0, settings, options, callback) } // Release implements the QueryService interface @@ -2120,12 +2116,3 @@ func skipQueryPlanCache(options *querypb.ExecuteOptions) bool { func (tsv *TabletServer) getShard() string { return tsv.sm.Target().Shard } - -// getOptions safely extracts ExecuteOptions from a session, returning nil if session is nil. -func getOptions(session queryservice.Session) *querypb.ExecuteOptions { - if session == nil { - return nil - } - - return session.GetOptions() -} diff --git a/go/vt/vttablet/tabletserver/tabletserver_test.go b/go/vt/vttablet/tabletserver/tabletserver_test.go index a98c691af00..bd98229c649 100644 --- a/go/vt/vttablet/tabletserver/tabletserver_test.go +++ b/go/vt/vttablet/tabletserver/tabletserver_test.go @@ -59,7 +59,6 @@ import ( querypb "vitess.io/vitess/go/vt/proto/query" topodatapb "vitess.io/vitess/go/vt/proto/topodata" - vtgatepb "vitess.io/vitess/go/vt/proto/vtgate" vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc" ) @@ -138,7 +137,7 @@ func TestBeginOnReplica(t *testing.T) { options := querypb.ExecuteOptions{ TransactionIsolation: querypb.ExecuteOptions_CONSISTENT_SNAPSHOT_READ_ONLY, } - state, err := tsv.Begin(ctx, &vtgatepb.Session{Options: &options}, &target) + state, err := tsv.Begin(ctx, nil, &target, &options) require.NoError(t, err, "failed to create read only tx on replica") assert.Equal(t, tsv.alias, state.TabletAlias, "Wrong tablet alias from Begin") _, err = tsv.Rollback(ctx, &target, state.TransactionID) @@ -146,7 +145,7 @@ func TestBeginOnReplica(t *testing.T) { // test that we can still create transactions even in read-only mode options = querypb.ExecuteOptions{} - state, err = tsv.Begin(ctx, &vtgatepb.Session{Options: &options}, &target) + state, err = tsv.Begin(ctx, nil, &target, &options) require.NoError(t, err, "expected write tx to be allowed") _, err = tsv.Rollback(ctx, &target, state.TransactionID) require.NoError(t, err) @@ -164,14 +163,14 @@ func TestTabletServerPrimaryToReplica(t *testing.T) { tsv.te.shutdownGracePeriod = 1 tsv.sm.shutdownGracePeriod = 1 target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state1, err := tsv.Begin(ctx, nil, &target) + state1, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) - _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state1.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state1.TransactionID, 0, nil) require.NoError(t, err) err = tsv.Prepare(ctx, &target, state1.TransactionID, "aa") require.NoError(t, err) - state2, err := tsv.Begin(ctx, nil, &target) + state2, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) // This makes txid2 busy @@ -477,8 +476,8 @@ func TestTabletServerBeginFail(t *testing.T) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} ctx, cancel = context.WithTimeout(context.Background(), 1*time.Nanosecond) defer cancel() - tsv.Begin(ctx, nil, &target) - _, err := tsv.Begin(ctx, nil, &target) + tsv.Begin(ctx, nil, &target, nil) + _, err := tsv.Begin(ctx, nil, &target, nil) require.EqualError(t, err, "transaction pool aborting request due to already expired context", "Begin err") } @@ -501,9 +500,9 @@ func TestTabletServerCommitTransaction(t *testing.T) { db.AddQuery(executeSQL, executeSQLResult) target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state, err := tsv.Begin(ctx, nil, &target) + state, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) - _, err = tsv.Execute(ctx, nil, &target, executeSQL, nil, state.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, &target, executeSQL, nil, state.TransactionID, 0, nil) require.NoError(t, err) _, err = tsv.Commit(ctx, &target, state.TransactionID) require.NoError(t, err) @@ -543,12 +542,12 @@ func TestTabletServerRollback(t *testing.T) { db.AddQuery(executeSQL, executeSQLResult) target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state, err := tsv.Begin(ctx, nil, &target) + state, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) if err != nil { t.Fatalf("call TabletServer.Begin failed: %v", err) } - _, err = tsv.Execute(ctx, nil, &target, executeSQL, nil, state.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, &target, executeSQL, nil, state.TransactionID, 0, nil) require.NoError(t, err) _, err = tsv.Rollback(ctx, &target, state.TransactionID) require.NoError(t, err) @@ -561,9 +560,9 @@ func TestTabletServerPrepare(t *testing.T) { _, tsv, _, closer := newTestTxExecutor(t, ctx) defer closer() target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state, err := tsv.Begin(ctx, nil, &target) + state, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) - _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state.TransactionID, 0, nil) require.NoError(t, err) defer tsv.RollbackPrepared(ctx, &target, "aa", 0) err = tsv.Prepare(ctx, &target, state.TransactionID, "aa") @@ -577,9 +576,9 @@ func TestTabletServerCommitPrepared(t *testing.T) { _, tsv, _, closer := newTestTxExecutor(t, ctx) defer closer() target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state, err := tsv.Begin(ctx, nil, &target) + state, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) - _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state.TransactionID, 0, nil) require.NoError(t, err) err = tsv.Prepare(ctx, &target, state.TransactionID, "aa") require.NoError(t, err) @@ -626,12 +625,12 @@ func TestTabletServerWithNilTarget(t *testing.T) { expectedCount := tsv.stats.QueryTimingsByTabletType.Counts()[fullKey] - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) require.NoError(t, err) expectedCount++ require.Equal(t, expectedCount, tsv.stats.QueryTimingsByTabletType.Counts()[fullKey]) - _, err = tsv.Execute(ctx, nil, target, executeSQL, nil, state.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, target, executeSQL, nil, state.TransactionID, 0, nil) require.NoError(t, err) expectedCount++ require.Equal(t, expectedCount, tsv.stats.QueryTimingsByTabletType.Counts()[fullKey]) @@ -641,7 +640,7 @@ func TestTabletServerWithNilTarget(t *testing.T) { expectedCount++ require.Equal(t, expectedCount, tsv.stats.QueryTimingsByTabletType.Counts()[fullKey]) - state, err = tsv.Begin(ctx, nil, target) + state, err = tsv.Begin(ctx, nil, target, nil) require.NoError(t, err) expectedCount++ require.Equal(t, expectedCount, tsv.stats.QueryTimingsByTabletType.Counts()[fullKey]) @@ -654,7 +653,7 @@ func TestTabletServerWithNilTarget(t *testing.T) { // Finally be sure that we return an error now as expected when NOT // using a local context but passing a nil target. nonLocalCtx := context.Background() - _, err = tsv.Begin(nonLocalCtx, nil, target) + _, err = tsv.Begin(nonLocalCtx, nil, target, nil) require.True(t, errors.Is(err, ErrNoTarget)) _, err = tsv.resolveTargetType(nonLocalCtx, target) require.True(t, errors.Is(err, ErrNoTarget)) @@ -776,11 +775,11 @@ func TestTabletServerReserveConnection(t *testing.T) { options := &querypb.ExecuteOptions{} // reserve a connection - state, _, err := tsv.ReserveExecute(ctx, &vtgatepb.Session{Options: options}, &target, nil, "set sql_mode = ''", nil, 0) + state, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0, options) require.NoError(t, err) // run a query in it - _, err = tsv.Execute(ctx, &vtgatepb.Session{Options: options}, &target, "select 42", nil, 0, state.ReservedID) + _, err = tsv.Execute(ctx, nil, &target, "select 42", nil, 0, state.ReservedID, options) require.NoError(t, err) // release the connection @@ -800,7 +799,7 @@ func TestTabletServerExecNonExistentConnection(t *testing.T) { options := &querypb.ExecuteOptions{} // run a query with a non-existent reserved id - _, err := tsv.Execute(ctx, &vtgatepb.Session{Options: options}, &target, "select 42", nil, 0, 123456) + _, err := tsv.Execute(ctx, nil, &target, "select 42", nil, 0, 123456, options) require.Error(t, err) } @@ -831,7 +830,7 @@ func TestMakeSureToCloseDbConnWhenBeginQueryFails(t *testing.T) { options := &querypb.ExecuteOptions{} // run a query with a non-existent reserved id - _, _, err := tsv.ReserveBeginExecute(ctx, &vtgatepb.Session{Options: options}, &target, []string{}, nil, "select 42", nil) + _, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, []string{}, nil, "select 42", nil, options) require.Error(t, err) } @@ -847,7 +846,7 @@ func TestTabletServerReserveAndBeginCommit(t *testing.T) { options := &querypb.ExecuteOptions{} // reserve a connection and a transaction - state, _, err := tsv.ReserveBeginExecute(ctx, &vtgatepb.Session{Options: options}, &target, nil, nil, "set sql_mode = ''", nil) + state, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set sql_mode = ''", nil, options) require.NoError(t, err) defer func() { // fallback so the test finishes quickly @@ -855,13 +854,13 @@ func TestTabletServerReserveAndBeginCommit(t *testing.T) { }() // run a query in it - _, err = tsv.Execute(ctx, &vtgatepb.Session{Options: options}, &target, "select 42", nil, state.TransactionID, state.ReservedID) + _, err = tsv.Execute(ctx, nil, &target, "select 42", nil, state.TransactionID, state.ReservedID, options) require.NoError(t, err) // run a query in a non-existent connection - _, err = tsv.Execute(ctx, &vtgatepb.Session{Options: options}, &target, "select 42", nil, state.TransactionID, state.ReservedID+100) + _, err = tsv.Execute(ctx, nil, &target, "select 42", nil, state.TransactionID, state.ReservedID+100, options) require.Error(t, err) - _, err = tsv.Execute(ctx, &vtgatepb.Session{Options: options}, &target, "select 42", nil, state.TransactionID+100, state.ReservedID) + _, err = tsv.Execute(ctx, nil, &target, "select 42", nil, state.TransactionID+100, state.ReservedID, options) require.Error(t, err) // commit @@ -871,7 +870,7 @@ func TestTabletServerReserveAndBeginCommit(t *testing.T) { rID := newRID // begin and rollback - beginState, _, err := tsv.BeginExecute(ctx, &vtgatepb.Session{Options: options}, &target, nil, "select 42", nil, rID) + beginState, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, rID, options) require.NoError(t, err) assert.Equal(t, newRID, beginState.TransactionID) rID = newRID @@ -897,9 +896,9 @@ func TestTabletServerRollbackPrepared(t *testing.T) { _, tsv, _, closer := newTestTxExecutor(t, ctx) defer closer() target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state, err := tsv.Begin(ctx, nil, &target) + state, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) - _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state.TransactionID, 0) + _, err = tsv.Execute(ctx, nil, &target, "update test_table set `name` = 2 where pk = 1", nil, state.TransactionID, 0, nil) require.NoError(t, err) err = tsv.Prepare(ctx, &target, state.TransactionID, "aa") require.NoError(t, err) @@ -927,7 +926,7 @@ func TestTabletServerStreamExecute(t *testing.T) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} callback := func(*sqltypes.Result) error { return nil } - if err := tsv.StreamExecute(ctx, nil, &target, executeSQL, nil, 0, 0, callback); err != nil { + if err := tsv.StreamExecute(ctx, nil, &target, executeSQL, nil, 0, 0, nil, callback); err != nil { t.Fatalf("TabletServer.StreamExecute should success: %s, but get error: %v", executeSQL, err) } @@ -957,7 +956,7 @@ func TestTabletServerStreamExecuteComments(t *testing.T) { ch := tabletenv.StatsLogger.Subscribe("test stats logging") defer tabletenv.StatsLogger.Unsubscribe(ch) - if err := tsv.StreamExecute(ctx, nil, &target, executeSQL, nil, 0, 0, callback); err != nil { + if err := tsv.StreamExecute(ctx, nil, &target, executeSQL, nil, 0, 0, nil, callback); err != nil { t.Fatalf("TabletServer.StreamExecute should success: %s, but get error: %v", executeSQL, err) } @@ -993,7 +992,7 @@ func TestTabletServerBeginStreamExecute(t *testing.T) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} callback := func(*sqltypes.Result) error { return nil } - state, err := tsv.BeginStreamExecute(ctx, nil, &target, nil, executeSQL, nil, 0, callback) + state, err := tsv.BeginStreamExecute(ctx, nil, &target, nil, executeSQL, nil, 0, nil, callback) if err != nil { t.Fatalf("TabletServer.BeginStreamExecute should success: %s, but get error: %v", executeSQL, err) @@ -1026,7 +1025,7 @@ func TestTabletServerBeginStreamExecuteWithError(t *testing.T) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} callback := func(*sqltypes.Result) error { return nil } - state, err := tsv.BeginStreamExecute(ctx, nil, &target, nil, executeSQL, nil, 0, callback) + state, err := tsv.BeginStreamExecute(ctx, nil, &target, nil, executeSQL, nil, 0, nil, callback) require.Error(t, err) err = tsv.Release(ctx, &target, state.TransactionID, 0) require.NoError(t, err) @@ -1093,7 +1092,7 @@ func TestSerializeTransactionsSameRow(t *testing.T) { go func() { defer wg.Done() - state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0) + state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q1, err) } @@ -1108,7 +1107,7 @@ func TestSerializeTransactionsSameRow(t *testing.T) { defer wg.Done() <-tx1Started - state2, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q2, bvTx2, 0) + state2, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q2, bvTx2, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q2, err) } @@ -1128,7 +1127,7 @@ func TestSerializeTransactionsSameRow(t *testing.T) { defer wg.Done() <-tx1Started - state3, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q3, bvTx3, 0) + state3, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q3, bvTx3, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q3, err) } @@ -1163,7 +1162,7 @@ func TestDMLQueryWithoutWhereClause(t *testing.T) { db.AddQuery(q+" limit 10001", &sqltypes.Result{}) - state, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q, nil, 0) + state, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q, nil, 0, nil) require.NoError(t, err) _, err = tsv.Commit(ctx, &target, state.TransactionID) require.NoError(t, err) @@ -1237,7 +1236,7 @@ func TestSerializeTransactionsSameRow_ConcurrentTransactions(t *testing.T) { go func() { defer wg.Done() - state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0) + state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q1, err) } @@ -1256,7 +1255,7 @@ func TestSerializeTransactionsSameRow_ConcurrentTransactions(t *testing.T) { // In that case, we would see less than 3 pending transactions. <-tx1Started - state2, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q2, bvTx2, 0) + state2, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q2, bvTx2, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q2, err) } @@ -1275,7 +1274,7 @@ func TestSerializeTransactionsSameRow_ConcurrentTransactions(t *testing.T) { // In that case, we would see less than 3 pending transactions. <-tx1Started - state3, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q3, bvTx3, 0) + state3, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q3, bvTx3, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q3, err) } @@ -1373,7 +1372,7 @@ func TestSerializeTransactionsSameRow_TooManyPendingRequests(t *testing.T) { go func() { defer wg.Done() - state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0) + state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q1, err) } @@ -1389,7 +1388,7 @@ func TestSerializeTransactionsSameRow_TooManyPendingRequests(t *testing.T) { defer close(tx2Failed) <-tx1Started - _, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q2, bvTx2, 0) + _, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q2, bvTx2, 0, nil) if err == nil || vterrors.Code(err) != vtrpcpb.Code_RESOURCE_EXHAUSTED || err.Error() != "hot row protection: too many queued transactions (1 >= 1) for the same row (table + WHERE clause: 'test_table where pk = 1 and `name` = 1')" { t.Errorf("tx2 should have failed because there are too many pending requests: %v", err) } @@ -1462,7 +1461,7 @@ func TestSerializeTransactionsSameRow_RequestCanceled(t *testing.T) { go func() { defer wg.Done() - state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0) + state1, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q1, bvTx1, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q1, err) } @@ -1482,7 +1481,7 @@ func TestSerializeTransactionsSameRow_RequestCanceled(t *testing.T) { // Wait until tx1 has started to make the test deterministic. <-tx1Started - _, _, err := tsv.BeginExecute(ctxTx2, nil, &target, nil, q2, bvTx2, 0) + _, _, err := tsv.BeginExecute(ctxTx2, nil, &target, nil, q2, bvTx2, 0, nil) if err == nil || vterrors.Code(err) != vtrpcpb.Code_CANCELED || err.Error() != "context canceled" { t.Errorf("tx2 should have failed because the context was canceled: %v", err) } @@ -1499,7 +1498,7 @@ func TestSerializeTransactionsSameRow_RequestCanceled(t *testing.T) { t.Error(err) } - state3, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q3, bvTx3, 0) + state3, _, err := tsv.BeginExecute(ctx, nil, &target, nil, q3, bvTx3, 0, nil) if err != nil { t.Errorf("failed to execute query: %s: %s", q3, err) } @@ -2321,7 +2320,7 @@ func TestReserveBeginExecute(t *testing.T) { target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} db.AddQueryPattern("set @@sql_mode = ''", &sqltypes.Result{}) - state, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set @@sql_mode = ''", nil) + state, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set @@sql_mode = ''", nil, nil) require.NoError(t, err) assert.Greater(t, state.TransactionID, int64(0), "transactionID") @@ -2348,7 +2347,7 @@ func TestReserveExecute_WithoutTx(t *testing.T) { db.AddQueryPattern("set sql_mode = ''", &sqltypes.Result{}) target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - state, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0) + state, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0, nil) require.NoError(t, err) assert.NotEqual(t, int64(0), state.ReservedID, "reservedID should not be zero") expected := []string{ @@ -2372,12 +2371,12 @@ func TestReserveExecute_WithTx(t *testing.T) { db.AddQueryPattern("set sql_mode = ''", &sqltypes.Result{}) target := querypb.Target{TabletType: topodatapb.TabletType_PRIMARY} - beginState, err := tsv.Begin(ctx, nil, &target) + beginState, err := tsv.Begin(ctx, nil, &target, nil) require.NoError(t, err) require.NotEqual(t, int64(0), beginState.TransactionID) db.ResetQueryLog() - reserveState, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, beginState.TransactionID) + reserveState, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, beginState.TransactionID, nil) require.NoError(t, err) defer tsv.Release(ctx, &target, beginState.TransactionID, reserveState.ReservedID) assert.Equal(t, beginState.TransactionID, reserveState.ReservedID, "reservedID should be equal to transactionID") @@ -2436,19 +2435,19 @@ func TestRelease(t *testing.T) { switch { case test.begin && test.reserve: - state, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set sql_mode = ''", nil) + state, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set sql_mode = ''", nil, nil) require.NoError(t, err) transactionID = state.TransactionID reservedID = state.ReservedID require.NotEqual(t, int64(0), transactionID) require.NotEqual(t, int64(0), reservedID) case test.begin: - state, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, 0) + state, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, 0, nil) require.NoError(t, err) transactionID = state.TransactionID require.NotEqual(t, int64(0), transactionID) case test.reserve: - state, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0) + state, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0, nil) require.NoError(t, err) reservedID = state.ReservedID require.NotEqual(t, int64(0), reservedID) @@ -2483,27 +2482,27 @@ func TestReserveStats(t *testing.T) { ctx = callerid.NewContext(ctx, nil, callerID) // Starts reserved connection and transaction - rbeState, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set sql_mode = ''", nil) + rbeState, _, err := tsv.ReserveBeginExecute(ctx, nil, &target, nil, nil, "set sql_mode = ''", nil, nil) require.NoError(t, err) assert.EqualValues(t, 1, tsv.te.txPool.env.Stats().UserActiveReservedCount.Counts()["test"]) // Starts reserved connection - reState, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0) + reState, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, 0, nil) require.NoError(t, err) assert.EqualValues(t, 2, tsv.te.txPool.env.Stats().UserActiveReservedCount.Counts()["test"]) // Use previous reserved connection to start transaction - reBeState, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, reState.ReservedID) + reBeState, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, reState.ReservedID, nil) require.NoError(t, err) assert.EqualValues(t, 2, tsv.te.txPool.env.Stats().UserActiveReservedCount.Counts()["test"]) // Starts transaction. - beState, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, 0) + beState, _, err := tsv.BeginExecute(ctx, nil, &target, nil, "select 42", nil, 0, nil) require.NoError(t, err) assert.EqualValues(t, 2, tsv.te.txPool.env.Stats().UserActiveReservedCount.Counts()["test"]) // Reserved the connection on previous transaction - beReState, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, beState.TransactionID) + beReState, _, err := tsv.ReserveExecute(ctx, nil, &target, nil, "set sql_mode = ''", nil, beState.TransactionID, nil) require.NoError(t, err) assert.EqualValues(t, 3, tsv.te.txPool.env.Stats().UserActiveReservedCount.Counts()["test"]) @@ -2549,11 +2548,11 @@ func TestDatabaseNameReplaceByKeyspaceNameExecuteMethod(t *testing.T) { target := tsv.sm.target // Testing Execute Method - state, err := tsv.Begin(ctx, nil, target) + state, err := tsv.Begin(ctx, nil, target, nil) require.NoError(t, err) - res, err := tsv.Execute(ctx, &vtgatepb.Session{Options: &querypb.ExecuteOptions{ + res, err := tsv.Execute(ctx, nil, target, executeSQL, nil, state.TransactionID, 0, &querypb.ExecuteOptions{ IncludedFields: querypb.ExecuteOptions_ALL, - }}, target, executeSQL, nil, state.TransactionID, 0) + }) require.NoError(t, err) for _, field := range res.Fields { require.Equal(t, "keyspaceName", field.Database) @@ -2595,9 +2594,9 @@ func TestDatabaseNameReplaceByKeyspaceNameStreamExecuteMethod(t *testing.T) { } return nil } - err := tsv.StreamExecute(ctx, &vtgatepb.Session{Options: &querypb.ExecuteOptions{ + err := tsv.StreamExecute(ctx, nil, target, executeSQL, nil, 0, 0, &querypb.ExecuteOptions{ IncludedFields: querypb.ExecuteOptions_ALL, - }}, target, executeSQL, nil, 0, 0, callback) + }, callback) require.NoError(t, err) } @@ -2626,9 +2625,9 @@ func TestDatabaseNameReplaceByKeyspaceNameBeginExecuteMethod(t *testing.T) { target := tsv.sm.target // Test BeginExecute Method - state, res, err := tsv.BeginExecute(ctx, &vtgatepb.Session{Options: &querypb.ExecuteOptions{ + state, res, err := tsv.BeginExecute(ctx, nil, target, nil, executeSQL, nil, 0, &querypb.ExecuteOptions{ IncludedFields: querypb.ExecuteOptions_ALL, - }}, target, nil, executeSQL, nil, 0) + }) require.NoError(t, err) for _, field := range res.Fields { require.Equal(t, "keyspaceName", field.Database) @@ -2666,9 +2665,9 @@ func TestDatabaseNameReplaceByKeyspaceNameReserveExecuteMethod(t *testing.T) { target := tsv.sm.target // Test ReserveExecute - _, res, err := tsv.ReserveExecute(ctx, &vtgatepb.Session{Options: &querypb.ExecuteOptions{ + _, res, err := tsv.ReserveExecute(ctx, nil, target, nil, executeSQL, nil, 0, &querypb.ExecuteOptions{ IncludedFields: querypb.ExecuteOptions_ALL, - }}, target, nil, executeSQL, nil, 0) + }) require.NoError(t, err) for _, field := range res.Fields { require.Equal(t, "keyspaceName", field.Database) @@ -2700,9 +2699,9 @@ func TestDatabaseNameReplaceByKeyspaceNameReserveBeginExecuteMethod(t *testing.T target := tsv.sm.target // Test for ReserveBeginExecute - state, res, err := tsv.ReserveBeginExecute(ctx, &vtgatepb.Session{Options: &querypb.ExecuteOptions{ + state, res, err := tsv.ReserveBeginExecute(ctx, nil, target, nil, nil, executeSQL, nil, &querypb.ExecuteOptions{ IncludedFields: querypb.ExecuteOptions_ALL, - }}, target, nil, nil, executeSQL, nil) + }) require.NoError(t, err) for _, field := range res.Fields { require.Equal(t, "keyspaceName", field.Database) diff --git a/go/vtbench/client.go b/go/vtbench/client.go index e141dba605d..727453f555d 100644 --- a/go/vtbench/client.go +++ b/go/vtbench/client.go @@ -161,5 +161,5 @@ func (c *grpcVttabletConn) connect(ctx context.Context, cp ConnParams) error { } func (c *grpcVttabletConn) execute(ctx context.Context, query string, bindVars map[string]*querypb.BindVariable) (*sqltypes.Result, error) { - return c.qs.Execute(ctx, nil, &c.target, query, bindVars, 0, 0) + return c.qs.Execute(ctx, nil, &c.target, query, bindVars, 0, 0, nil) }