refactor base.ShowCreateTable

Author: ffffwh

drivers/mysql/mysql/base/utils.go

@@ -76,10 +76,10 @@ func ParseBinlogCoordinatesFromRow(row *sql.Row) (r *common.BinlogCoordinatesX,
 
 // GetTableColumns reads column list from given table
 func GetTableColumns(db usql.QueryAble, databaseName, tableName string) (*common.ColumnList, error) {
-	query := fmt.Sprintf(`show columns from %s.%s`,
-		umconf.EscapeName(databaseName),
-		umconf.EscapeName(tableName),
-	)
+	databaseNameEscaped := umconf.EscapeName(databaseName)
+	tableNameEscaped := umconf.EscapeName(tableName)
+
+	query := fmt.Sprintf(`show columns from %s.%s`, databaseNameEscaped, tableNameEscaped)
 	columns := []umconf.Column{}
 	err := usql.QueryRowsMap(db, query, func(rowMap usql.RowMap) error {
 		aColumn := umconf.Column{
@@ -97,11 +97,9 @@ func GetTableColumns(db usql.QueryAble, databaseName, tableName string) (*common
 		return nil, err
 	}
 	if len(columns) == 0 {
-		return nil, fmt.Errorf("Found 0 columns on %s.%s. Bailing out",
-			umconf.EscapeName(databaseName),
-			umconf.EscapeName(tableName),
-		)
+		return nil, fmt.Errorf("found 0 columns on %s.%s", databaseName, tableName, )
 	}
+
 	return common.NewColumnList(columns), nil
 }
 
@@ -129,18 +127,11 @@ func GetSomeSysVars(db usql.QueryAble, logger g.LoggerType) (r struct {
 	return r
 }
 
-func ShowCreateTable(db *gosql.DB, databaseName, tableName string, dropTableIfExists bool, addUse bool) (statement []string, err error) {
+func ShowCreateTable(db usql.QueryAble, databaseName, tableName string) (statement string, err error) {
 	var dummy, createTableStatement string
 	query := fmt.Sprintf(`show create table %s.%s`, umconf.EscapeName(databaseName), umconf.EscapeName(tableName))
 	err = db.QueryRow(query).Scan(&dummy, &createTableStatement)
-	if addUse {
-		statement = append(statement, fmt.Sprintf("USE %s", umconf.EscapeName(databaseName)))
-	}
-	if dropTableIfExists {
-		statement = append(statement, fmt.Sprintf("DROP TABLE IF EXISTS %s", umconf.EscapeName(tableName)))
-	}
-	statement = append(statement, createTableStatement)
-	return statement, err
+	return createTableStatement, err
 }
 
 func ShowCreateView(db *gosql.DB, databaseName, tableName string, dropTableIfExists bool) (createTableStatement string, err error) {

drivers/mysql/mysql/base/utils_test.go

@@ -204,42 +204,6 @@ func TestApplyColumnTypes(t *testing.T) {
 	}
 }
 
-func TestShowCreateTable(t *testing.T) {
-	type args struct {
-		db                *gosql.DB
-		databaseName      string
-		tableName         string
-		dropTableIfExists bool
-		addUse            bool
-	}
-	tests := []struct {
-		name                     string
-		args                     args
-		wantCreateTableStatement string
-		wantErr                  bool
-	}{
-		// TODO: Add test cases.
-	}
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			gotCreateTableStatement, err := ShowCreateTable(tt.args.db, tt.args.databaseName, tt.args.tableName, tt.args.dropTableIfExists, tt.args.addUse)
-			if (err != nil) != tt.wantErr {
-				t.Errorf("ShowCreateTable() error = %v, wantErr %v", err, tt.wantErr)
-				return
-			}
-			exist := false
-			for _, createTableStatement := range gotCreateTableStatement {
-				if createTableStatement == tt.wantCreateTableStatement {
-					exist = true
-				}
-			}
-			if !exist {
-				t.Errorf("ShowCreateTable() = %v, want %v", gotCreateTableStatement, tt.wantCreateTableStatement)
-			}
-		})
-	}
-}
-
 func Test_stringInterval(t *testing.T) {
 	type args struct {
 		intervals gomysql.IntervalSlice

drivers/mysql/mysql/extractor.go

@@ -764,12 +764,11 @@ func (e *Extractor) getSchemaTablesAndMeta() error {
 				continue
 			}
 
-			stmts, err := base.ShowCreateTable(e.db, db.TableSchema, tb.TableName, false, false)
+			stmt, err := base.ShowCreateTable(e.db, db.TableSchema, tb.TableName)
 			if err != nil {
 				e.logger.Error("error at ShowCreateTable.", "err", err)
 				return err
 			}
-			stmt := stmts[0]
 			ast, err := sqle.ParseCreateTableStmt("mysql", stmt)
 			if err != nil {
 				e.logger.Error("error at ParseCreateTableStmt.", "err", err)
@@ -1354,18 +1353,19 @@ func (e *Extractor) mysqlDump() error {
 						return err
 					}*/
 				} else if strings.ToLower(tb.TableSchema) != "mysql" {
-					tbSQL, err = base.ShowCreateTable(e.singletonDB, tb.TableSchema, tb.TableName, e.mysqlContext.DropTableIfExists, true)
-					for num, sql := range tbSQL {
-						if db.TableSchemaRename != "" && strings.Contains(sql, fmt.Sprintf("USE %s", mysqlconfig.EscapeName(tb.TableSchema))) {
-							tbSQL[num] = strings.Replace(sql, tb.TableSchema, db.TableSchemaRename, 1)
-						}
-						if tb.TableRename != "" && (strings.Contains(sql, fmt.Sprintf("DROP TABLE IF EXISTS %s", mysqlconfig.EscapeName(tb.TableName))) || strings.Contains(sql, "CREATE TABLE")) {
-							tbSQL[num] = strings.Replace(sql, mysqlconfig.EscapeName(tb.TableName), tb.TableRename, 1)
-						}
+					targetSchemaEscaped := mysqlconfig.EscapeName(g.StringElse(db.TableSchemaRename, tb.TableSchema))
+					targetTableEscaped  := mysqlconfig.EscapeName(g.StringElse(tb.TableRename, tb.TableName))
+					tbSQL = append(tbSQL, fmt.Sprintf("USE %s", targetSchemaEscaped))
+					if e.mysqlContext.DropTableIfExists {
+						tbSQL = append(tbSQL, fmt.Sprintf("DROP TABLE IF EXISTS %s", targetTableEscaped))
 					}
+					ctStmt, err := base.ShowCreateTable(e.singletonDB, tb.TableSchema, tb.TableName)
 					if err != nil {
 						return err
 					}
+					// TODO do not use string replace
+					ctStmt = strings.Replace(ctStmt, mysqlconfig.EscapeName(tb.TableName), targetTableEscaped, 1)
+					tbSQL = append(tbSQL, ctStmt)
 				}
 				entry := &common.DumpEntry{
 					TbSQL:      tbSQL,