Mysql 节点、续集、同步模型、混合力：真/假

我（又）糊涂了

在使用Sequelize定义数据库（MySQL）表时，我想做一个 同步（强制：true），以删除/创建表。到目前为止还不错

现在，我对我的

user

表很满意，不想在每次运行时都删除它，而继续定义其他表

因此，我想在

user

options，

sync:{forced:false}

module.exports = (sequelize, DataTypes) => {
  let Schema = sequelize.define(
    "user",
    {
      id: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
      },
      BlaBla:{}
    },
    { // options
      sync: {force: false},
      freezeTableName: true,
      timestamps: true
    });
  return Schema;
};

这是行不通的。每次运行时都会删除/创建表

继续定义我的

公司

表

module.exports = (sequelize, DataTypes) => {
  let Schema = sequelize.define(
    "company",
    {
      id: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
      },
      BlaBla:{}
    },
    { // options
      sync: {force: true},
      freezeTableName: true,
      timestamps: false
    });
  return Schema;
};

问题

• 如何根据每个

  sequelize.define

  选项有选择地同步表

---

不支持在

sequelize.define（）中选择性同步。有关详细信息，请参阅。在项目的其他地方，您必须调用正在同步所有模型的
sequelize.sync（{force:true}）
。您应该首先纠正这一点，因为这是批量强制所有模型同步

修复该问题后，您将有几个选择：

1：继续使用迁移。对模式的每个添加或更改都会在迁移中捕获，因此您可以在不重新同步其他更改的情况下推出每个更改。
看

2：根据您的建议分别同步每个表。您需要分别为每个模型调用
sync（）
方法，例如：

const user = require('./user');
const company = require('./company');
company.sync();
compant.sync({force:true});

这对于早期开发可能是可行的，但随着项目的进展并开始发布，迁移应该是您推出架构更改的首选方法

看
好吧，睡个好觉之后，我的大脑又开始工作了


首先。我不明白为什么所有加载模型的示例都在创建一个
db对象

容纳所有模型<代码>数据库[model.name]=型号

对Sequelize包的引用

db.Sequelize=Sequelize

对连接的引用

db.sequelize=sequelize

当实例

const sequelize=new sequelize（）

是您所需要的全部时

• 连接对象将保存对所有导入模型的引用。

给定

模型定义

，如OP.
文件：

app/models/user.js

module.exports = (sequelize, DataTypes) => {
  let Schema = sequelize.define(
    "user",
    {
      id: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
      },
      BlaBla:{}
    },
    { // options
      sync: {force: false},
      freezeTableName: true,
      timestamps: true
    });
  return Schema;
};

const Sequelize = require("sequelize");

const sequelize = new Sequelize(config.dbname, config.dbuser, config.dbpass, {
    dialect: "mysql",
    host: config.dbhost,
    port:    3306,
    define: {
        engine: 'MYISAM',
        timestamps: true,
      }
  });

fs
  .readdirSync(path.join(config.models))
  .filter(file => ~file.indexOf('.js'))
  .forEach((file) => {
    let model = sequelize["import"](path.join(config.models, file));
    model.sync(model.options.sync);
  });

module.exports = sequelize;

和这样的引导：
文件：

config/sequelize.js

module.exports = (sequelize, DataTypes) => {
  let Schema = sequelize.define(
    "user",
    {
      id: {
        type: DataTypes.INTEGER,
        autoIncrement: true,
        primaryKey: true
      },
      BlaBla:{}
    },
    { // options
      sync: {force: false},
      freezeTableName: true,
      timestamps: true
    });
  return Schema;
};

const Sequelize = require("sequelize");

const sequelize = new Sequelize(config.dbname, config.dbuser, config.dbpass, {
    dialect: "mysql",
    host: config.dbhost,
    port:    3306,
    define: {
        engine: 'MYISAM',
        timestamps: true,
      }
  });

fs
  .readdirSync(path.join(config.models))
  .filter(file => ~file.indexOf('.js'))
  .forEach((file) => {
    let model = sequelize["import"](path.join(config.models, file));
    model.sync(model.options.sync);
  });

module.exports = sequelize;

然后您可以进行每型号同步。

然后在

server.js

中：

const sequelize = require(join(__dirname,"config/sequelize"));
/* debug */
Object.keys(sequelize.models).forEach(function(name) {
    console.log('sequelize model:',name);
});

console.log('Checking DB connection...');
sequelize
  .authenticate()
  .then(() => {
    console.log('Successfully connected to:', config.dbname);
  })
  .catch(err => {
    console.error('Unable to connect to the database:', err);
    process.exit;
  });

const User = sequelize.model('user');

这导致

用户

不会被删除，但

公司

会被删除

以下是运行的控制台输出：

> node server.js

config/index.js { dbhost: '192.168.1.70',
  dbport: 3306,
  dbname: 'dbdev',
  dbuser: 'dbdev',
  dbpass: '********',
  mode: 'development',
  root: 'C:\\Workspace\\Github\\******',
  models: 'C:\\Workspace\\Github\\******\\app\\models',
  sync: false }

Creating DB connection...
Loading Schema: company
company sync { force: true }
Loading Schema: user
user sync { force: false }
sequelize model: company
sequelize model: user
Checking DB connection...
Server fetching: user
Executing (default): SELECT 1+1 AS result
Executing (default): DROP TABLE IF EXISTS `company`;
Executing (default): CREATE TABLE IF NOT EXISTS `user` (`id` INTEGER UNSIGNED auto_increment , `login` VARCHAR(45) UNIQUE, `password` VARCHAR(255), `fname` VARCHAR(45), `lname` VARCHAR(45), `email` VARCHAR(128), `phone` VARCHAR(20), `company` INTEGER UNSIGNED, `createdby` INTEGER UNSIGNED, `access` INTEGER, `createdAt` DATETIME NOT NULL, `updatedAt` DATETIME NOT NULL, PRIMARY KEY (`id`)) ENGINE=MYISAM;
Successfully connected to: dbdev
Executing (default): SHOW INDEX FROM `user`
Executing (default): CREATE TABLE IF NOT EXISTS `company` (`id` INTEGER auto_increment , `name` VARCHAR(255), `type` INTEGER, `createdby` INTEGER, `access` INTEGER, PRIMARY KEY (`id`)) ENGINE=MYISAM;
Executing (default): SHOW INDEX FROM `company`

我可能会看看

迁移

，但现在，我更愿意根据需要在定义文件中进行初始建模

---

我是否遗漏了一些要点，或者此解决方案是否“飞起来”？

1。我无法在“定义”中找到将同步用作选项的文档。你确定这是允许的吗？2.如果您单独同步（）表（而不是对所有表使用sequelize.sync（）），您可以对每个表进行不同的“强制”。是的，这似乎是一种通过模型定义来驱动同步的创造性和明智的方法。