// CopySchemaShard copies the schema from a source tablet to the // specified shard. The schema is applied directly on the master of // the destination shard, and is propogated to the replicas through // binlogs. func (wr *Wrangler) CopySchemaShard(ctx context.Context, sourceTabletAlias *topodatapb.TabletAlias, tables, excludeTables []string, includeViews bool, destKeyspace, destShard string) error { destShardInfo, err := wr.ts.GetShard(ctx, destKeyspace, destShard) if err != nil { return err } sourceSd, err := wr.GetSchema(ctx, sourceTabletAlias, tables, excludeTables, includeViews) if err != nil { return err } destSd, err := wr.GetSchema(ctx, destShardInfo.MasterAlias, tables, excludeTables, includeViews) if err != nil { destSd = nil } if destSd != nil { diffs := tmutils.DiffSchemaToArray("source", sourceSd, "dest", destSd) if diffs == nil { // Return early because dest has already the same schema as source. return nil } } createSQL := tmutils.SchemaDefinitionToSQLStrings(sourceSd) destTabletInfo, err := wr.ts.GetTablet(ctx, destShardInfo.MasterAlias) if err != nil { return err } for i, sqlLine := range createSQL { err = wr.applySQLShard(ctx, destTabletInfo, sqlLine, i == len(createSQL)-1) if err != nil { return err } } return nil }
func (exec *TabletExecutor) preflightSchemaChanges(ctx context.Context, sqls []string) error { schemaDiffs, err := exec.wr.TabletManagerClient().PreflightSchema(ctx, exec.tablets[0], sqls) if err != nil { return err } parsedDDLs, err := parseDDLs(sqls) if err != nil { return err } for i, schemaDiff := range schemaDiffs { diffs := tmutils.DiffSchemaToArray( "BeforeSchema", schemaDiff.BeforeSchema, "AfterSchema", schemaDiff.AfterSchema) if len(diffs) == 0 { if parsedDDLs[i].Action == sqlparser.DropStr && parsedDDLs[i].IfExists { // DROP IF EXISTS on a nonexistent table does not change the schema. It's safe to ignore. continue } return fmt.Errorf("Schema change: '%s' does not introduce any table definition change.", sqls[i]) } } exec.schemaDiffs = schemaDiffs return nil }
// compareSchemas returns nil if the schema of the two tablets referenced by // "sourceAlias" and "destAlias" are identical. Otherwise, the difference is // returned as []string. func (wr *Wrangler) compareSchemas(ctx context.Context, sourceAlias, destAlias *topodatapb.TabletAlias, tables, excludeTables []string, includeViews bool) ([]string, error) { sourceSd, err := wr.GetSchema(ctx, sourceAlias, tables, excludeTables, includeViews) if err != nil { return nil, fmt.Errorf("failed to get schema from tablet %v. err: %v", sourceAlias, err) } destSd, err := wr.GetSchema(ctx, destAlias, tables, excludeTables, includeViews) if err != nil { return nil, fmt.Errorf("failed to get schema from tablet %v. err: %v", destAlias, err) } return tmutils.DiffSchemaToArray("source", sourceSd, "dest", destSd), nil }
func (exec *TabletExecutor) preflightSchemaChanges(ctx context.Context, sqls []string) error { exec.schemaDiffs = make([]*tmutils.SchemaChangeResult, len(sqls)) for i := range sqls { schemaDiff, err := exec.tmClient.PreflightSchema( ctx, exec.tabletInfos[0], sqls[i]) if err != nil { return err } exec.schemaDiffs[i] = schemaDiff diffs := tmutils.DiffSchemaToArray( "BeforeSchema", exec.schemaDiffs[i].BeforeSchema, "AfterSchema", exec.schemaDiffs[i].AfterSchema) if len(diffs) == 0 { return fmt.Errorf("Schema change: '%s' does not introduce any table definition change.", sqls[i]) } } return nil }
func (wr *Wrangler) applySchemaShard(ctx context.Context, shardInfo *topo.ShardInfo, preflight *tmutils.SchemaChangeResult, masterTabletAlias *topodatapb.TabletAlias, change string, newParentTabletAlias *topodatapb.TabletAlias, force bool, waitSlaveTimeout time.Duration) (*tmutils.SchemaChangeResult, error) { // find all the shards we need to handle aliases, err := wr.ts.FindAllTabletAliasesInShard(ctx, shardInfo.Keyspace(), shardInfo.ShardName()) if err != nil { return nil, err } // build the array of tabletStatus we're going to use statusArray := make([]*tabletStatus, 0, len(aliases)-1) for _, alias := range aliases { if alias == masterTabletAlias { // we skip the master continue } ti, err := wr.ts.GetTablet(ctx, alias) if err != nil { return nil, err } statusArray = append(statusArray, &tabletStatus{ti: ti}) } // get schema on all tablets. log.Infof("Getting schema on all tablets for shard %v/%v", shardInfo.Keyspace(), shardInfo.ShardName()) wg := &sync.WaitGroup{} for _, status := range statusArray { wg.Add(1) go func(status *tabletStatus) { status.beforeSchema, status.lastError = wr.tmc.GetSchema(ctx, status.ti, nil, nil, false) wg.Done() }(status) } wg.Wait() // quick check for errors for _, status := range statusArray { if status.lastError != nil { return nil, fmt.Errorf("Error getting schema on tablet %v: %v", status.ti.AliasString(), status.lastError) } } // check all tablets have the same schema as the master's // BeforeSchema. If not, we shouldn't proceed log.Infof("Checking schema on all tablets") for _, status := range statusArray { diffs := tmutils.DiffSchemaToArray("master", preflight.BeforeSchema, topoproto.TabletAliasString(status.ti.Alias), status.beforeSchema) if len(diffs) > 0 { if force { log.Warningf("Tablet %v has inconsistent schema, ignoring: %v", status.ti.AliasString(), strings.Join(diffs, "\n")) } else { return nil, fmt.Errorf("Tablet %v has inconsistent schema: %v", status.ti.AliasString(), strings.Join(diffs, "\n")) } } } // we're good, just send to the master log.Infof("Applying schema change to master") sc := &tmutils.SchemaChange{ SQL: change, Force: force, AllowReplication: true, BeforeSchema: preflight.BeforeSchema, AfterSchema: preflight.AfterSchema, } return wr.ApplySchema(ctx, masterTabletAlias, sc) }
// ApplySchemaChange will apply the schema change to the given database. func (mysqld *Mysqld) ApplySchemaChange(dbName string, change *tmutils.SchemaChange) (*tmutils.SchemaChangeResult, error) { // check current schema matches beforeSchema, err := mysqld.GetSchema(dbName, nil, nil, true) if err != nil { return nil, err } if change.BeforeSchema != nil { schemaDiffs := tmutils.DiffSchemaToArray("actual", beforeSchema, "expected", change.BeforeSchema) if len(schemaDiffs) > 0 { for _, msg := range schemaDiffs { log.Warningf("BeforeSchema differs: %v", msg) } // let's see if the schema was already applied if change.AfterSchema != nil { schemaDiffs = tmutils.DiffSchemaToArray("actual", beforeSchema, "expected", change.AfterSchema) if len(schemaDiffs) == 0 { // no diff between the schema we expect // after the change and the current // schema, we already applied it return &tmutils.SchemaChangeResult{ BeforeSchema: beforeSchema, AfterSchema: beforeSchema}, nil } } if change.Force { log.Warningf("BeforeSchema differs, applying anyway") } else { return nil, fmt.Errorf("BeforeSchema differs") } } } sql := change.SQL if !change.AllowReplication { sql = "SET sql_log_bin = 0;\n" + sql } // add a 'use XXX' in front of the SQL sql = "USE " + dbName + ";\n" + sql // execute the schema change using an external mysql process // (to benefit from the extra commands in mysql cli) if err = mysqld.executeMysqlCommands(mysqld.dba.Uname, sql); err != nil { return nil, err } // get AfterSchema afterSchema, err := mysqld.GetSchema(dbName, nil, nil, true) if err != nil { return nil, err } // compare to the provided AfterSchema if change.AfterSchema != nil { schemaDiffs := tmutils.DiffSchemaToArray("actual", afterSchema, "expected", change.AfterSchema) if len(schemaDiffs) > 0 { for _, msg := range schemaDiffs { log.Warningf("AfterSchema differs: %v", msg) } if change.Force { log.Warningf("AfterSchema differs, not reporting error") } else { return nil, fmt.Errorf("AfterSchema differs") } } } return &tmutils.SchemaChangeResult{BeforeSchema: beforeSchema, AfterSchema: afterSchema}, nil }