fix in-memory implementation of RenameTable to read from session

enginetest/evaluation.go

@@ -252,6 +252,11 @@ func TestTransactionScript(t *testing.T, harness Harness, script queries.Transac
 func TestTransactionScriptWithEngine(t *testing.T, e QueryEngine, harness Harness, script queries.TransactionTest) {
 	setupSession := NewSession(harness)
 	for _, statement := range script.SetUpScript {
+		if sh, ok := harness.(SkippingHarness); ok {
+			if sh.SkipQueryTest(statement) {
+				t.Skip()
+			}
+		}
 		RunQueryWithContext(t, e, harness, setupSession, statement)
 	}
 
@@ -268,6 +273,10 @@ func TestTransactionScriptWithEngine(t *testing.T, e QueryEngine, harness Harnes
 		}
 
 		t.Run(assertion.Query, func(t *testing.T) {
+			if sh, ok := harness.(SkippingHarness); ok && sh.SkipQueryTest(assertion.Query) {
+				t.Skip()
+			}
+
 			if assertion.ExpectedErr != nil {
 				AssertErrWithCtx(t, e, harness, clientSession, assertion.Query, assertion.ExpectedErr)
 			} else if assertion.ExpectedErrStr != "" {

enginetest/memory_engine_test.go

@@ -918,6 +918,10 @@ func TestTypesOverWire(t *testing.T) {
 	enginetest.TestTypesOverWire(t, harness, harness.SessionBuilder())
 }
 
+func TestTransactions(t *testing.T) {
+	enginetest.TestTransactionScripts(t, enginetest.NewSkippingMemoryHarness())
+}
+
 func mergableIndexDriver(dbs []sql.Database) sql.IndexDriver {
 	return memory.NewIndexDriver("mydb", map[string][]sql.DriverIndex{
 		"mytable": {

enginetest/queries/alter_table_queries.go

@@ -915,6 +915,34 @@ var AlterTableScripts = []ScriptTest{
 			},
 		},
 	},
+	{
+		Name: "alter column and rename table work within same transaction",
+		SetUpScript: []string{
+			"create table t (i int)",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				SkipResultsCheck: true,
+				Query:            "start transaction;",
+			},
+			{
+				SkipResultsCheck: true,
+				Query:            "alter table t change i j int",
+			},
+			{
+				SkipResultsCheck: true,
+				Query:            "rename table t to tt",
+			},
+			{
+				SkipResultsCheck: true,
+				Query:            "commit;",
+			},
+			{
+				Query:    "select j from tt;",
+				Expected: []sql.Row{},
+			},
+		},
+	},
 }
 
 var RenameTableScripts = []ScriptTest{

memory/database.go

@@ -308,6 +308,9 @@ func (d *BaseDatabase) RenameTable(ctx *sql.Context, oldName, newName string) er
 	}
 
 	sess := SessionFromContext(ctx)
+
+	// retrieve table data from session
+	tbl.(*Table).data = sess.tableData(tbl.(*Table))
 	sess.dropTable(tbl.(*Table).data)
 
 	memTbl := tbl.(*Table).copy()

sql/plan/alter_table.go

@@ -833,9 +833,10 @@ func (m *ModifyColumn) IsReadOnly() bool {
 	return false
 }
 
-func (m ModifyColumn) WithTargetSchema(schema sql.Schema) (sql.Node, error) {
-	m.targetSchema = schema
-	return &m, nil
+func (m *ModifyColumn) WithTargetSchema(schema sql.Schema) (sql.Node, error) {
+	nm := *m
+	nm.targetSchema = schema
+	return &nm, nil
 }
 
 func (m *ModifyColumn) TargetSchema() sql.Schema {
@@ -846,12 +847,13 @@ func (m *ModifyColumn) Children() []sql.Node {
 	return []sql.Node{m.Table}
 }
 
-func (m ModifyColumn) WithChildren(children ...sql.Node) (sql.Node, error) {
+func (m *ModifyColumn) WithChildren(children ...sql.Node) (sql.Node, error) {
 	if len(children) != 1 {
 		return nil, sql.ErrInvalidChildrenNumber.New(m, len(children), 1)
 	}
-	m.Table = children[0]
-	return &m, nil
+	nm := *m
+	nm.Table = children[0]
+	return &nm, nil
 }
 
 // CheckPrivileges implements the interface sql.Node.
@@ -873,24 +875,25 @@ func (m *ModifyColumn) Expressions() []sql.Expression {
 	return append(transform.WrappedColumnDefaults(m.targetSchema), expression.WrapExpressions(m.column.Default)...)
 }
 
-func (m ModifyColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error) {
+func (m *ModifyColumn) WithExpressions(exprs ...sql.Expression) (sql.Node, error) {
 	if len(exprs) != 1+len(m.targetSchema) {
 		return nil, sql.ErrInvalidChildrenNumber.New(m, len(exprs), 1+len(m.targetSchema))
 	}
 
-	sch, err := transform.SchemaWithDefaults(m.targetSchema, exprs[:len(m.targetSchema)])
+	nm := *m
+	sch, err := transform.SchemaWithDefaults(nm.targetSchema, exprs[:len(nm.targetSchema)])
 	if err != nil {
 		return nil, err
 	}
-	m.targetSchema = sch
+	nm.targetSchema = sch
 
 	unwrappedColDefVal, ok := exprs[len(exprs)-1].(*expression.Wrapper).Unwrap().(*sql.ColumnDefaultValue)
 	if ok {
-		m.column.Default = unwrappedColDefVal
+		nm.column.Default = unwrappedColDefVal
 	} else { // nil fails type check
-		m.column.Default = nil
+		nm.column.Default = nil
 	}
-	return &m, nil
+	return &nm, nil
 }
 
 // Resolved implements the Resolvable interface.