Removal of master-slave vocabulary

config/config.go

@@ -24,11 +24,11 @@ type DatabaseConfig struct {
 	// login password to database server
 	Password string `yaml:"password"`
 
-	// master server's dsn list ( currently support single master only )
-	Masters []string `yaml:"master"`
+	// main server's dsn list ( currently support single main only )
+	Mains []string `yaml:"main"`
 
-	// slave server's dsn list ( currently not support )
-	Slaves []string `yaml:"slave"`
+	// subordinate server's dsn list ( currently not support )
+	Subordinates []string `yaml:"subordinate"`
 
 	// backup server's dsn list ( currently not support )
 	Backups []string `yaml:"backup"`

connection/adapter/plugin/mysql.go

@@ -63,12 +63,12 @@ func (adapter *MySQLAdapter) NextSequenceID(conn *sql.DB, tableName string) (int
 
 // ExecDDL create database if not exists by database configuration file.
 func (adapter *MySQLAdapter) ExecDDL(config *config.DatabaseConfig) error {
-	if len(config.Masters) > 1 {
-		return errors.New("Sorry, currently supports single master database only")
+	if len(config.Mains) > 1 {
+		return errors.New("Sorry, currently supports single main database only")
 	}
 	dbname := config.NameOrPath
-	for _, master := range config.Masters {
-		serverDsn := fmt.Sprintf("%s:%s@tcp(%s)/", config.Username, config.Password, master)
+	for _, main := range config.Mains {
+		serverDsn := fmt.Sprintf("%s:%s@tcp(%s)/", config.Username, config.Password, main)
 		serverConn, err := sql.Open(config.Adapter, serverDsn)
 		defer serverConn.Close()
 		if err != nil {
@@ -79,35 +79,35 @@ func (adapter *MySQLAdapter) ExecDDL(config *config.DatabaseConfig) error {
 		}
 		return nil
 	}
-	return errors.New("must define 'master' server")
+	return errors.New("must define 'main' server")
 }
 
 // OpenConnection open connection by database configuration file
 func (adapter *MySQLAdapter) OpenConnection(config *config.DatabaseConfig, queryString string) (*sql.DB, error) {
-	if len(config.Masters) > 1 {
-		return nil, errors.New("Sorry, currently supports single master database only")
+	if len(config.Mains) > 1 {
+		return nil, errors.New("Sorry, currently supports single main database only")
 	}
 	dbname := config.NameOrPath
-	for _, master := range config.Masters {
-		dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?%s", config.Username, config.Password, master, dbname, queryString)
+	for _, main := range config.Mains {
+		dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?%s", config.Username, config.Password, main, dbname, queryString)
 		debug.Printf("dsn = %s", strings.Replace(dsn, "%", "%%", -1))
 		conn, err := sql.Open(config.Adapter, dsn)
 		if err != nil {
 			return nil, errors.WithStack(err)
 		}
 		return conn, nil
 	}
-	for _, slave := range config.Slaves {
-		dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?%s", config.Username, config.Password, slave, dbname, queryString)
-		debug.Printf("TODO: not support slave. dsn = %s", dsn)
+	for _, subordinate := range config.Subordinates {
+		dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?%s", config.Username, config.Password, subordinate, dbname, queryString)
+		debug.Printf("TODO: not support subordinate. dsn = %s", dsn)
 		break
 	}
 
 	for _, backup := range config.Backups {
 		dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?%s", config.Username, config.Password, backup, dbname, queryString)
 		debug.Printf("TODO: not support backup. dsn = %s", dsn)
 	}
-	return nil, errors.New("must define 'master' server")
+	return nil, errors.New("must define 'main' server")
 }
 
 // CreateSequencerTableIfNotExists create table for sequencer if not exists

connection/connection.go

@@ -36,8 +36,8 @@ type Connection interface {
 type DBShardConnection struct {
 	ShardName  string
 	Connection *sql.DB
-	Masters    []*sql.DB
-	Slaves     []*sql.DB
+	Mains    []*sql.DB
+	Subordinates     []*sql.DB
 	dsn        string
 }
 
@@ -105,7 +105,7 @@ func (c *DBShardConnections) AllShard() []*DBShardConnection {
 	return c.connList
 }
 
-// DBConnection has connection to sequencer or master server or all shards
+// DBConnection has connection to sequencer or main server or all shards
 type DBConnection struct {
 	Config             *config.TableConfig
 	Algorithm          algorithm.ShardingAlgorithm
@@ -354,8 +354,8 @@ func (c *TxConnection) Rollback() error {
 // DSN returns DSN for not sharded database
 func (c *DBConnection) DSN() string {
 	cfg := c.Config
-	if len(cfg.Masters) > 0 {
-		return fmt.Sprintf("%s/%s", cfg.Masters[0], cfg.NameOrPath)
+	if len(cfg.Mains) > 0 {
+		return fmt.Sprintf("%s/%s", cfg.Mains[0], cfg.NameOrPath)
 	}
 	return fmt.Sprintf("%s", cfg.NameOrPath)
 }
@@ -418,7 +418,7 @@ func (c *DBConnection) EqualDSN(conn *DBConnection) bool {
 	if c.Config.NameOrPath != conn.Config.NameOrPath {
 		return false
 	}
-	if len(c.Config.Masters) != len(conn.Config.Masters) {
+	if len(c.Config.Mains) != len(conn.Config.Mains) {
 		return false
 	}
 	if c.Config.IsShard != conn.Config.IsShard {
@@ -431,19 +431,19 @@ func (c *DBConnection) EqualDSN(conn *DBConnection) bool {
 				if shard.NameOrPath != shardConn.NameOrPath {
 					return false
 				}
-				if len(shard.Masters) != len(shardConn.Masters) {
+				if len(shard.Mains) != len(shardConn.Mains) {
 					return false
 				}
-				for idx, master := range shard.Masters {
-					if master != shardConn.Masters[idx] {
+				for idx, main := range shard.Mains {
+					if main != shardConn.Mains[idx] {
 						return false
 					}
 				}
 			}
 		}
 	} else {
-		for idx, master := range c.Config.Masters {
-			if master != conn.Config.Masters[idx] {
+		for idx, main := range c.Config.Mains {
+			if main != conn.Config.Mains[idx] {
 				return false
 			}
 		}
@@ -734,8 +734,8 @@ func (cm *DBConnectionManager) openShardConnection(tableName string, table *conf
 			cm.setConnectionSettings(shardConn)
 			conns = append(conns, shardConn)
 			var dsn string
-			if len(shardValue.Masters) > 0 {
-				dsn = fmt.Sprintf("%s/%s", shardValue.Masters[0], shardValue.NameOrPath)
+			if len(shardValue.Mains) > 0 {
+				dsn = fmt.Sprintf("%s/%s", shardValue.Mains[0], shardValue.NameOrPath)
 			} else {
 				dsn = shardValue.NameOrPath
 			}

sqlparser/sqlparser_test.go

@@ -976,7 +976,7 @@ func TestERROR(t *testing.T) {
 		log.Println(err)
 	})
 	t.Run("unsupport query", func(t *testing.T) {
-		query, err := parser.Parse("show slave status")
+		query, err := parser.Parse("show subordinate status")
 		if query != nil {
 			t.Fatal("invalid query value")
 		}