Sequelize.js: माइग्रेशन और सिंक का उपयोग कैसे करें

137

मैं अपने प्रोजेक्ट को लॉन्च करने के लिए तैयार हूं। लॉन्च के बाद मेरे पास बड़ी योजनाएं हैं और डेटाबेस संरचना बदलने जा रही है - मौजूदा तालिकाओं में नए कॉलम के साथ-साथ नए टेबल और मौजूदा और नए मॉडल के लिए नए संघ।

मैंने अभी तक Sequelize में माइग्रेशन को नहीं छुआ है, क्योंकि मेरे पास केवल डेटा का परीक्षण है जो कि हर बार डेटाबेस में परिवर्तन होने पर मुझे बुरा नहीं लगता।

उस समय तक, sync force: trueजब मैं अपना ऐप शुरू कर रहा हूं, अगर मैं मॉडल की परिभाषा बदल चुका हूं, तो मैं चल रहा हूं । यह सभी तालिकाओं को हटाता है और उन्हें खरोंच से बनाता है। मैं इस forceविकल्प को छोड़ सकता था कि इसमें केवल नई तालिकाएँ हों। लेकिन अगर मौजूदा वाले बदल गए हैं तो यह उपयोगी नहीं है।

इसलिए एक बार जब मैं माइग्रेशन में शामिल होता हूं तो चीजें कैसे काम करती हैं? जाहिर है मैं नहीं चाहता कि मौजूदा तालिकाओं (उनमें डेटा के साथ) को मिटा दिया जाए, इसलिए sync force: trueयह सवाल से बाहर है। अन्य एप्लिकेशन पर मैंने ऐप की तैनाती प्रक्रिया के भाग के रूप में (लारवेल और अन्य फ्रेमवर्क) विकसित करने में मदद की है हम किसी भी लंबित माइग्रेशन को चलाने के लिए माइग्रेट कमांड चलाते हैं। लेकिन इन ऐप्स में पहले ही माइग्रेशन में एक कंकाल डेटाबेस होता है, राज्य में डेटाबेस के साथ जहां यह विकास में कुछ समय पहले था - पहला अल्फा रिलीज या जो भी हो। इसलिए पार्टी में देर से आने वाले ऐप का एक उदाहरण क्रम में सभी माइग्रेशन चलाकर, एक बार में गति प्राप्त कर सकता है।

मैं Sequelize में ऐसा "पहला माइग्रेशन" कैसे उत्पन्न करूं? यदि मेरे पास एक नहीं है, तो एप्लिकेशन का एक नया उदाहरण किसी तरह से लाइन के नीचे माइग्रेशन को चलाने के लिए कोई कंकाल डेटाबेस नहीं होगा, या यह शुरू में सिंक चलाएगा और सभी के साथ नए राज्य में डेटाबेस बना देगा नए टेबल आदि, लेकिन तब जब वे उन माइग्रेशन को चलाने की कोशिश करते हैं, जिनसे उन्हें कोई मतलब नहीं होगा, क्योंकि वे मूल डेटाबेस और प्रत्येक क्रमिक पुनरावृत्ति को ध्यान में रखते हुए लिखे गए थे।

मेरी विचार प्रक्रिया: प्रत्येक चरण में, प्रारंभिक डेटाबेस और अनुक्रम में प्रत्येक माइग्रेशन तब उत्पन्न होने वाले डेटाबेस (प्लस या माइनस डेटा) के बराबर होना चाहिए sync force: trueदौड़ हैं। ऐसा इसलिए है क्योंकि कोड में मॉडल विवरण डेटाबेस संरचना का वर्णन करते हैं। इसलिए हो सकता है कि अगर कोई माइग्रेशन टेबल नहीं है तो हम सिर्फ सिंक को चलाते हैं और सभी माइग्रेशन को चिन्हित करते हैं, भले ही वे रन नहीं हुए हों। क्या मुझे ऐसा करने की आवश्यकता है (कैसे?), या सीक्वेलाइज़ को स्वयं ऐसा करने के लिए माना जाता है, या क्या मैं गलत पेड़ को काट रहा हूं? और अगर मैं सही क्षेत्र में हूं, तो निश्चित रूप से पुराने मॉडल (कमिट हैश द्वारा दिए गए) को ऑटो में सबसे अच्छा माइग्रेशन उत्पन्न करने का एक अच्छा तरीका होना चाहिए? या यहां तक कि प्रत्येक माइग्रेशन को एक प्रतिबद्धता से जोड़ा जा सकता है? गैर-पोर्टेबल गिट-केंद्रित ब्रह्मांड में) और नए मॉडल। यह संरचना को अलग कर सकता है और डेटाबेस को पुराने से नए और फिर से बदलने के लिए आवश्यक कमांड उत्पन्न कर सकता है, और फिर डेवलपर अंदर जा सकता है और किसी भी आवश्यक मोड़ (विशेष डेटा आदि को हटाने / परिवर्तित) कर सकता है।

जब मैं सिक्वल बाइनरी को --initकमांड के साथ चलाता हूं तो यह मुझे एक खाली माइग्रेशन डायरेक्टरी देता है। जब मैं sequelize --migrateइसे चलाता हूं तो यह मुझे एक SequelizeMeta तालिका बनाता है जिसमें कुछ भी नहीं है, कोई अन्य तालिका नहीं है। जाहिर है, क्योंकि बाइनरी मेरे ऐप को बूटस्ट्रैप और मॉडल लोड करने का तरीका नहीं जानता है।

मेरा कुछ छूट रहा है।

TLDR: मैं अपने ऐप और इसके माइग्रेशन को कैसे सेट कर सकता हूं ताकि लाइव ऐप के विभिन्न उदाहरणों को अद्यतित किया जा सके, साथ ही साथ कोई नया डेटाबेस शुरू न होने वाला डेटाबेस भी हो?

— tremby
स्रोत

2

मैंने आपके वर्कफ़्लो से संबंधित उत्तर दिया है, लेकिन आदर्श रूप से सभी तालिकाएँ माइग्रेशन का उपयोग करके सेटअप की जानी चाहिए। यहां तक कि अगर आप syncअभी के लिए उपयोग कर रहे हैं, तो यह विचार है कि माइग्रेशन पूरे डेटाबेस को "उत्पन्न" करता है, इसलिए एक कंकाल पर निर्भर होना अपने आप में एक समस्या है। उदाहरण के लिए, रेल वर्कफ़्लो पर रूबी, सब कुछ के लिए माइग्रेशन का उपयोग करता है, और जब आप इसकी आदत डाल लेते हैं, तो यह बहुत बढ़िया होता है। संपादित करें: और हाँ, मैंने देखा कि यह प्रश्न बहुत पुराना है, लेकिन यह देखते हुए कि कभी कोई संतोषजनक उत्तर नहीं मिला है और लोग मार्गदर्शन की तलाश में यहाँ आ सकते हैं, मुझे लगा कि मुझे योगदान देना चाहिए।

— फर्नांडो कोर्डेइरो

88

"पहला प्रवास" बनाना

आपके मामले में, सबसे विश्वसनीय तरीका यह लगभग मैन्युअल रूप से करना है। मैं सीक्वल-क्लाई टूल का उपयोग करने का सुझाव दूंगा । वाक्यविन्यास सादा है:

sequelize init
...
sequelize model:create --name User --attributes first_name:string,last_name:string,bio:text

यह मॉडल और माइग्रेशन दोनों बनाएगा। फिर, मैन्युअल रूप से अपने मौजूदा मॉडलों को सीक्वेलिज़-क्ली के साथ उत्पन्न करते हैं, और माइग्रेशन के साथ ऐसा ही करते हैं। ऐसा करने के बाद, डेटाबेस मिटाएं (यदि संभव हो), और चलाएं

sequelize db:migrate

इससे स्कीमा का पलायन होगा। स्कीमा घटनाक्रम की उचित प्रक्रिया (सिंक के बिना: बल, लेकिन आधिकारिक पलायन के साथ) पर स्विच करने के लिए आपको केवल एक बार ऐसा करना चाहिए।

बाद में, जब आपको स्कीमा बदलने की आवश्यकता होती है:

एक माइग्रेशन बनाएं: sequelize migration:create
अपनी माइग्रेशन फ़ाइल में अप और डाउन फ़ंक्शन लिखें
माइग्रेशन फ़ाइल में आपके परिवर्तनों के अनुसार, अपने मॉडल को मैन्युअल रूप से बदलें
Daud sequelize db:migrate

उत्पादन पर पलायन चल रहा है

जाहिर है आप उत्पादन सर्वर पर नहीं जा सकते और हाथों से पलायन चला सकते हैं। एप्लिकेशन शुरू होने से पहले लंबित माइग्रेशन करने के लिए Node.JS के लिए umzug , फ्रेमवर्क एग्नोस्टिक माइग्रेशन टूल का उपयोग करें ।

आप इस तरह से लंबित / अभी तक निष्पादित पलायन की सूची प्राप्त नहीं कर सकते हैं:

umzug.pending().then(function (migrations) {
  // "migrations" will be an Array with the names of
  // pending migrations.
});

फिर माइग्रेशन निष्पादित करें ( कॉलबैक के अंदर )। निष्पादन विधि एक सामान्य उद्देश्य फ़ंक्शन है जो संबंधित फ़ंक्शन के प्रत्येक निर्दिष्ट माइग्रेशन के लिए चलता है:

umzug.execute({
  migrations: ['some-id', 'some-other-id'],
  method: 'up'
}).then(function (migrations) {
  // "migrations" will be an Array of all executed/reverted migrations.
});

और मेरा सुझाव यह है कि ऐप शुरू होने से पहले इसे करें और हर बार मार्गों की सेवा करने का प्रयास करें। कुछ इस तरह:

umzug.pending().then(function(migrations) {
    // "migrations" will be an Array with the names of
    // pending migrations.
    umzug.execute({
        migrations: migrations,
        method: 'up'
    }).then(function(migrations) {
        // "migrations" will be an Array of all executed/reverted migrations.
        // start the server
        app.listen(3000);
        // do your stuff
    });
});

मैं अभी यह कोशिश नहीं कर सकता, लेकिन पहली नजर में यह काम करना चाहिए।

यूपीडी अप्रैल 2016

एक साल बाद, अभी भी उपयोगी है, इसलिए मेरे वर्तमान सुझावों को साझा करना। अभी के लिए, मैं sequelize-cliआवश्यक लाइव निर्भरता के रूप में पैकेज स्थापित कर रहा हूं , और फिर package.jsonइस तरह एनपीएम स्टार्टअप स्क्रिप्ट को संशोधित कर सकता हूं :

...
"scripts": {
  "dev": "grunt && sequelize db:migrate && sequelize db:seed:all && node bin/www",
  "start": "sequelize db:migrate && sequelize db:seed:all && node bin/www"
},
...

केवल एक चीज जो मुझे उत्पादन सर्वर पर करने की आवश्यकता है, वह है npm start। यह कमांड सभी माइग्रेशन चलाएगा, सभी सीडर्स लागू करेगा और ऐप सर्वर शुरू करेगा। Umzug को मैन्युअल रूप से कॉल करने की आवश्यकता नहीं है।

— f1nn
स्रोत

3

ऐसा लगता है कि मैं क्या देख रहा हूँ। ऐसा लगता नहीं है कि जादू और स्वचालित रूप से यह "होना चाहिए", लेकिन शायद यह सबसे अच्छा है जिसकी उम्मीद की जा सकती है। हालाँकि, मैं अभी Sequelize के साथ काम नहीं कर रहा हूँ और जल्द ही किसी भी समय इसका परीक्षण नहीं कर पाऊँगा। लेकिन अगर कोई और इससे सहमत है कि यह समाधान अच्छा है, तो मैं इस उत्तर को स्वीकार करूंगा। मुझे अभी भी यह थोड़ा दुखद लगता है कि मॉडल संस्करणों के बीच के अंतर से इन पलायनों को स्वचालित रूप से करने का कोई तरीका प्रतीत नहीं होता है।

— कांप

4

@tremby एकमात्र फ्रेमवर्क जो मैंने उपयोग किया है जो वास्तव में समझता है कि मॉडल Django था। यह मॉडल का विश्लेषण करता है और पूछता है "ठीक है, ऐसा लगता है कि आपने मॉडल उपयोगकर्ता में first_name के लिए फ़ील्ड का नाम बदला है। क्या आप इसके लिए माइग्रेशन बनाना चाहेंगे?" Django में यह लगभग जादुई रूप से काम करता है, मैंने जिन अन्य साधनों का उपयोग किया है, वे उसी माइग्रेशन दृष्टिकोण को मानते हैं जिसका मैंने ऊपर उल्लेख किया है: आप अपने आप को माइग्रेशन लिखने के लिए ज़िम्मेदार हैं, गहराई से समझें कि आपके वर्तमान मॉडल राज्यों में वास्तविक होने के लिए किस प्रकार का ऐड जोड़ना है

— f1nn

2

आप pendingऔर फिर से छुटकारा पा सकते हैं executeऔर बस करो umzug.up().then(function (migrations) { app.listen(3000); })। Umzug प्रलेखन के अनुसार, यह सभी लंबित पलायन को अंजाम देगा।

— विनय

जब आप माइग्रेशन पूरा करते हैं, तो क्या मूल मॉडल फ़ाइल में स्कीमा में फ़ील्ड जोड़ना आम है?

— theptrk

@ f1nn मेरे पास आपके सेट अप के बारे में एक सवाल है, आप ऐप क्लस्टरिंग और उपलब्धता को कैसे संभालते हैं? मैं अपने वर्कफ़्लो में pm2 को एकीकृत करूँगा और शायद यह npm स्क्रिप्ट के साथ सीधा काम नहीं करेगा।

— डायोसनी

17

बस यह स्वयं सीखना, लेकिन मुझे लगता है कि मैं अब माइग्रेशन का उपयोग करने की सिफारिश करूंगा ताकि आप उनकी आदत डाल लें। मैंने यह पता लगाने के लिए सबसे अच्छी चीज़ ढूंढ ली है कि माइग्रेशन में क्या जाता है द्वारा बनाई गई तालिकाओं पर sql को देखें sequelize.sync()और फिर वहाँ से माइग्रेशन बनाएं।

migrations -c [migration name]

एक माइग्रेशन निर्देशिका में टेम्पलेट माइग्रेशन फ़ाइल बनाएगा। फिर आप इसे उन फ़ील्ड्स के साथ पॉप्युलेट कर सकते हैं जिनकी आपको ज़रूरत है। इस फ़ाइल को शामिल करना होगा createdAt/ updatedAt, संघों के लिए आवश्यक फ़ील्ड इत्यादि।

प्रारंभिक तालिका निर्माण के लिए नीचे होना चाहिए:

migration.dropTable('MyTable');

लेकिन तालिका संरचना के बाद के अपडेट इसे छोड़ सकते हैं और केवल परिवर्तन तालिका का उपयोग कर सकते हैं।

./node_modules/.bin/sequelize --migrate

एक उदाहरण बनाएँ जैसा लगेगा:

module.exports = {
  up: function(migration, DataTypes, done) {
    migration.createTable(
        'MyTable',
        {
          id: {
            type: DataTypes.INTEGER,
            primaryKey: true,
            autoIncrement: true
          },
          bigString: {type: DataTypes.TEXT, allowNull: false},
          MyOtherTableId: DataTypes.INTEGER,
          createdAt: {
            type: DataTypes.DATE
          },
          updatedAt: {
            type: DataTypes.DATE
          }
        });
    done();
  },
  down: function(migration, DataTypes, done) {
    migration.dropTable('MyTable');
    done();
  }

शुरू से फिर से करने के लिए:

./node_modules/.bin/sequelize --migrate --undo
./node_modules/.bin/sequelize --migrate

टेबल्स को पॉप्युलेट करने के लिए सीड फाइल चलाने के लिए मैं कॉफी का उपयोग कर रहा हूं:

coffee server/seed.coffee

इसमें बस एक फंक्शन है जिसमें कुछ ऐसा दिखता है:

user = db.User.create
  username: 'bob'
  password: 'suruncle'
  email: 'bob@bob.com'
.success (user) ->
  console.log 'added user'
  user_id = user.id
  myTable = [
    field1: 'womp'
    field2: 'rat'

    subModel: [
      field1: 'womp'
     ,
      field1: 'rat'
    ]
  ]

sync()अपने मॉडलों में अपने सूचकांक को बाहर निकालना याद रखें या यह अधिलेखित कर देगा कि पलायन और बीज क्या करते हैं।

दस्तावेज़ पर हैं http://sequelize.readthedocs.org/en/latest/docs/migrations/ निश्चित रूप से। लेकिन मूल उत्तर आपको उन क्षेत्रों को निर्दिष्ट करने के लिए है जो आपको चाहिए। यह आपके लिए नहीं है।

— user1916988
स्रोत

5

मैं यह नहीं पूछ रहा था कि माइग्रेशन कैसे बनाएं और चलाएं - जैसा कि आपने बताया, यह सब प्रलेखन में उपलब्ध है। मैं क्या पूछ रहा था कि कैसे उन्हें एक पुन: प्रयोज्य अनुप्रयोग के संदर्भ में उपयोग किया जाए जहां मौजूदा उदाहरणों को एक नए डेटाबेस संस्करण में अद्यतन करने की आवश्यकता है और नए उदाहरणों को खरोंच से बने डेटाबेस की आवश्यकता है। या शायद आप इसका उत्तर दे रहे हैं , और कह रहे हैं कि मुझे सिंक () का उपयोग बिल्कुल नहीं करना चाहिए, और प्रारंभिक डेटाबेस और सभी परिवर्तन इसे माइग्रेशन में करना चाहिए। क्या आप यही कह रहे हैं?

— '19:

1

@ मुझे लगता है कि वह क्या कह रहा है। आप या तो सिंक का उपयोग कर सकते हैं और परिणामों से निपट सकते हैं, या आप सभी मैन्युअल रूप से माइग्रेशन बना सकते हैं। रेल-एस्के फैशन में हमारे ढांचे, स्कीमा के आधार पर माइग्रेशन फ़ाइलों को उत्पन्न करते हैं, अगर सीक्लाइज़ मेरे लिए ऐसा करेगा तो मैं प्यार करूंगा। मैन्युअल रूप से माइग्रेशन करने के लिए बहुत अधिक दर्द ...

— 21

यह एक शर्म की बात है कि आपके sequelize.sync()पास तब उत्पन्न स्क्रिप्ट नहीं हो सकती है जो आपके पहले माइग्रेशन (रेल के समान schema.rb) के रूप में सभी बेस टेबल और सूचकांकों का निर्माण करती है । इसके माध्यम से पढ़ने के बाद, ऐसा लगता है कि आपका सबसे अच्छा दांव आपके प्रारंभिक स्कीमा को निर्यात करना हो सकता है। sql के रूप में, फिर इसे execअपने पहले ही माइग्रेशन में एक बड़े स्टेटमेंट में डाल दें । फिर वहां से आप एक ज्ञात "संस्करण 1.0" शुरुआती बिंदु के खिलाफ वृद्धिशील परिवर्तन चला रहे हैं।

— 15 मई को thom_nic

11

के लिए विकास , वहाँ अब उनकी संरचना को बदलकर वर्तमान टेबल सिंक करने के लिए एक विकल्प है। सीक्लाइज़ गीथब रेपो से नवीनतम संस्करण का उपयोग करके , आप अब alterपैरामीटर के साथ सिंक चला सकते हैं ।

Table.sync({alter: true})

डॉक्स से एक चेतावनी:

फिट मॉडल के लिए तालिकाओं। उत्पादन उपयोग के लिए अनुशंसित नहीं है। स्तंभों में डेटा हटा दिए गए थे या मॉडल में उनके प्रकार बदल दिए गए थे।

— meyer9
स्रोत

3

अब नए सीक्वेल के साथ माइग्रेशन बहुत सरल है।

यह एक उदाहरण है कि आप क्या कर सकते हैं।

    'use strict';

    var Promise = require('bluebird'),
        fs = require('fs');

    module.exports = {
        up: function (queryInterface, Sequelize) {

            return Promise
                .resolve()
                .then(function() {
                    return fs.readFileSync(__dirname + '/../initial-db.sql', 'utf-8');
                })
                .then(function (initialSchema) {
                    return queryInterface.sequelize.query(initialSchema);
                })
        },

        down: function (queryInterface, Sequelize) {
            return Promise
                .resolve()
                .then(function() {
                    return fs.readFileSync(__dirname + '/../drop-initial-db.sql', 'utf-8');
                })
                .then(function (dropSql) {
                    return queryInterface.sequelize.query(dropSql);
                });
        }
    };

याद रखें आपको सेट करना होगा:

"dialectOptions": { "multipleStatements": true }

डेटाबेस कॉन्फ़िगरेशन पर।

— नेस्टर मगलहेस
स्रोत

क्या यह सिर्फ ड्रॉप और डेटाबेस को फिर से नहीं बनाता है?

— ट्वीली

मुझे लगता है कि एक प्रारंभिक बड़ी sql फ़ाइल का उपयोग करने का अनुशंसित तरीका नहीं है, क्योंकि यह एडेप्टर और डेटाबेस को टाई करेगा, जो अन्यथा डेटाबेस अज्ञेयवादी होगा, क्योंकि आप विकास sqlite और उत्पादन mariadb या अन्य के लिए उपयोग कर सकते हैं।

— 16-12 को डायोसनी जूल

2

संस्करण का उपयोग करें। एप्लिकेशन का संस्करण डेटाबेस के संस्करण पर निर्भर करता है। यदि नए संस्करण के लिए डेटाबेस के अपडेट की आवश्यकता है, तो इसके लिए माइग्रेशन बनाएं।

अद्यतन: मैं माइग्रेशन (त्याग देने का फैसला KISS ) और स्क्रिप्ट update_db चलाने (सिंक forse: गलत) जब यह आवश्यक है।

— सर्गेई कारसेव
स्रोत

User1916988 के उत्तर के लिए मेरी प्रतिक्रिया के समान, क्या आप कह रहे हैं कि मुझे बिल्कुल भी उपयोग नहीं करना चाहिए sync(), और मुझे पुराने संस्करण के मॉडल के स्कीमा से मैन्युअल रूप से नए संस्करण के मॉडल में माइग्रेशन लिखने की आवश्यकता है?

— 23

आपके अपडेट के कारण मैंने +1 किया। Im वास्तव में ऐसा ही करने की सोच रहा है। सभी माइग्रेशन को मैन्युअल रूप से लिखना जब ऐप ऐसा कर सकता है जो थोड़ा बेवकूफ है, तो इम करें बस एक मैनुअल स्क्रिप्ट बनाएं जो ऐप को एक बार चलाता है और सिंक फ़ंक्शन चलाता है।

— सालार

2

थोड़ी देर, और प्रलेखन पढ़ने के बाद, आपको उस पहले प्रवास की आवश्यकता नहीं है जिसके बारे में आप बात कर रहे हैं। syncतालिकाओं को बनाने के लिए आपको बस इतना करना है ।

sequelize.sync()

आप कुछ ऐसा करके एक साधारण मॉडल तुल्यकालन भी चला सकते हैं:

Project.sync()लेकिन मुझे लगता है कि sequelize.sync()यह आपकी परियोजना के लिए एक अधिक उपयोगी सामान्य मामला है (जब तक आप प्रारंभ समय में अच्छे मॉडल आयात करते हैं)।

(से लिया http://sequelizejs.com/docs/latest/models#database-synchronization )

यह सभी प्रारंभिक संरचनाओं का निर्माण करेगा । बाद में, आपको अपने स्कीमा को विकसित करने के लिए केवल माइग्रेशन बनाना होगा।

आशा करता हूँ की ये काम करेगा।

— kiddouk
स्रोत

7

मुझे नहीं लगता कि आपने मूल पोस्ट को बहुत अच्छी तरह से पढ़ा है, या शायद मैं पर्याप्त स्पष्ट नहीं था। मैं इसके बारे में अधिक जानकारी sequelize.sync()रखता हूँ और यह क्या करता है।

— कांपना

2

अनुक्रमिक रूप से एसिंक्रोनस रूप से एसक्यूएल चला सकते हैं ।

मैं क्या करूंगा:

एक माइग्रेशन उत्पन्न करें (पहले माइग्रेशन के रूप में उपयोग करने के लिए);
अपना डेटाबेस डंप करें, जैसे कुछ: mysql_dump -uUSER -pPASS DBNAME > FILE.SQL
या तो पूर्ण डंप को टेक्स्ट (खतरनाक) के रूप में पेस्ट करें या फ़ाइल को नोड में पूर्ण डंप के साथ लोड करें:
- var baseSQL = "LOTS OF SQL and it's EVIL because you gotta put \ backslashes before line breakes and \"quotes\" and/or sum" + " one string for each line, or everything will break";
- var baseSQL = fs.readFileSync('../seed/baseDump.sql');
इस डंप को Sequelize माइग्रेशन पर चलाएँ:

module.exports = {
  up: function (migration, DataTypes) {
    var baseSQL = "whatever" // I recommend loading a file
    migration.migrator.sequelize.query(baseSQL);
  }
}

डेटाबेस स्थापित करने का ध्यान रखना चाहिए, इसके बावजूद कि async बात एक समस्या बन सकती है। यदि ऐसा होता है, तो मैं upसीक्वल फ़ंक्शन को वापस करने का एक तरीका देखूंगा जब तक कि async queryफ़ंक्शन समाप्त नहीं हो जाता।

: Mysql_dump के बारे में अधिक http://dev.mysql.com/doc/refman/5.1/en/mysqldump.html
Sequelize माइग्रेशन के बारे में अधिक: http://sequelize.readthedocs.org/en/latest/docs/migrations/
के बारे में अधिक Sequelize प्रवासन के भीतर से SQL चलाना: https://github.com/fterelize/fterelize/issues/313

— फर्नांडो कोर्डेइरो
स्रोत

1

यहाँ मेरा वर्तमान वर्कफ़्लो है। मैं सुझाव के लिए खुला हूँ।

तालिकाओं को बनाने के लिए अगली कड़ी सेट करें जो मौजूद नहीं हैं
_Blank नामक रिक्त डेटाबेस में सभी तालिकाओं को छोड़ने और फिर से बनाने के लिए अगली कड़ी सेट करें
_Blank की तुलना करने के लिए एक mysql टूल का उपयोग करें और उस टूल का उपयोग करके परिवर्तनों को सिंक करें। फिर भी एक किफायती टूल की तलाश में जो मैक पर ऐसा कर सके। MySql कार्यक्षेत्र ऐसा लगता है कि आप किसी मौजूदा स्कीमा से मॉडल आयात कर सकते हैं, और फिर स्कीमा सिंक कर सकते हैं। इसे आसान बनाने के लिए कमांड लाइन के माध्यम से यह पता लगाने की कोशिश की जा रही है।

इस तरह आपको माइग्रेशन टेबल को मैन्युअल रूप से अपडेट नहीं करना है और वसा वाली उंगलियों के बारे में चिंता करना है, लेकिन आपको अभी भी एक ओआरएम प्राप्त होता है।

— TWilly
स्रोत

1

मित्र मेरे पास एक ही सवाल था और यह समझने में कामयाब रहा कि उनका उपयोग कैसे किया जाए।

मैंने ORM सीक्वल के बिना शुरुआत की इसलिए मेरे पास पहले से ही एक डेटा मॉडल था।
मुझे सीक्वलिज़-ऑटो के साथ मॉडल स्वचालित रूप से उत्पन्न करने और इस फ़ाइल के साथ उनके माइग्रेशन उत्पन्न करने के लिए था कि आप https://gist.github.com/ahelord/a7a7d293695b71aadf04157f0ffdd6464 बनाएं और सिंक में डालें ( {Force: false})
यह dev में है। मॉडल और माइग्रेशन और कोड निष्पादित करने पर हर बार उन्हें निष्पादित करें।

उत्पादन में सर्वर केवल ऊपर की ओर होता है, इसलिए आपको केवल माइग्रेशन चलाना होता है और प्रत्येक कमिट में मैनेज करना होता है क्योंकि आप बैकएंड को रोके बिना मॉडल को वर्जन करेंगे।

— लियोनार्डो रोड्रिग्ज
स्रोत

1

मैं इस पोस्ट और इसी तरह के सवालों से गुजरा, यह वास्तव में मेरे लिए इसका जवाब नहीं था। माइग्रेशन स्थानीय डेटाबेस को कताई करने और उत्पादन में डेटा अपडेट करने के लिए उपयोगी होते हैं

मैंने यहाँ सवाल पूछा और इसका उत्तर भी दिया: पलायन और आरंभीकरण को रोकने के लिए वर्कफ़्लो?

ग्रीनफ़ील्ड प्रोजेक्ट के लिए TL-DR संस्करण

अपने डेटाबेस स्कीमा को डिज़ाइन करें क्योंकि आप परंपरागत रूप से शुद्ध एसक्यूएल स्क्रिप्ट का उपयोग करेंगे या यदि आप इसके बजाय एक गुई टूल का उपयोग करेंगे
जब आप अपने db स्कीमा के अपने सभी 95% को अंतिम रूप दे देते हैं और इससे खुश हो जाते हैं, तो आगे बढ़ें और इसे पूरी .sqlफाइल को ऊपर ले जाकर सीक्वेलाइज करें।
अपना पहला प्रवास करें। भागो sequelize init:migrateजो कुछ फ़ोल्डर जहाँ आपके में modelsकर रहे हैं
अपनी पहली माइग्रेशन फ़ाइल बनाएँ। Daudsequelize migration:generate --name [name_of_your_migration]
उस माइग्रेशन फ़ाइल में, इस कोड को वहाँ रखें

("use strict");
/**
 * DROP SCHEMA public CASCADE; CREATE SCHEMA public
 * ^ there's a schema file with all the tables in there. it drops all of that, recreates
 */
const fs = require("fs");
const initialSqlScript = fs.readFileSync("./migrations/sql/Production001.sql", {
  encoding: "utf-8",
});
const db = require("../models");
module.exports = {
  up: () => db.sequelize.query(initialSqlScript),
  down: () =>
    db.sequelize.query(`DROP SCHEMA public CASCADE; CREATE SCHEMA public;
`),
};

इस सामान्य फ़ोल्डर संरचना के साथ

अब आपका सीक्वेल सेटअप आपके प्रारंभिक डेटाबेस स्कीमा के साथ समन्वयित है
जब आप अपने डेटाबेस स्कीमा को संपादित करना चाहते हैं, तो इसे फिर से चलाएँ sequelize migration:generate --name [name_of_your_migration]
आगे बढ़ो और यहाँ पर अपना संशोधन करने upऔर downमाइग्रेशन पथ। कॉलम नाम, DELETE, ADD कॉलम आदि बदलने के लिए ये आपके ALTER स्टेटमेंट हैं
Daud sequelize db:migrate
आप चाहते हैं कि मॉडल आपके दूरस्थ db में परिवर्तनों के साथ समन्वयित हों, इसलिए अब आप क्या कर सकते हैं npm install sequelize-auto।
यह आपके डेटाबेस पर वर्तमान डेटाबेस स्कीमा और ऑटो उत्पन्न मॉडल फ़ाइलों को पढ़ेगा। Https://github.com/fterelize/fterelize-auto केsequelize-auto -o "./models" -d sequelize_auto_test -h localhost -u my_username -p 5432 -x my_password -e postgres तहत मिली समान कमांड का उपयोग करें

आप अपने मॉडल पर अंतर देखने के लिए git का उपयोग कर सकते हैं, केवल डेटाबेस मॉडल में परिवर्तन को प्रतिबिंबित करने वाले परिवर्तन होने चाहिए। एक साइड नोट के रूप में, modelsयदि आप उपयोग करते हैं तो कभी भी सीधे संशोधित न करें sequelize auto, क्योंकि यह उन्हें आपके लिए उत्पन्न करेगा। इसी तरह, अब आपको अपने डेटाबेस स्कीमा को सीधे SQL फ़ाइलों के साथ संशोधित नहीं करना चाहिए, बशर्ते यह एक विकल्प है क्योंकि आप उन .sqlफ़ाइलों को भी आयात कर सकते हैं

अब आपका डेटाबेस स्कीमा अद्यतित है, और आपने आधिकारिक तौर पर केवल डेटाबेस पलायन को सीक्वेल करने के लिए स्थानांतरित किया है।

सब कुछ संस्करण नियंत्रित है। यह डेटाबेस और बैकएंड डेवलपर के लिए आदर्श वर्कफ़्लो है

— विन्सेंट तांग
स्रोत

0

और भी सरल तरीका है (Sequalize से बचना)। जो इस प्रकार है:

आप अपने प्रोजेक्ट के अंदर एक कमांड टाइप करते हैं: npm run migrate: new
इससे 3 फाइलें बनती हैं। एक js फ़ाइल और दो sql फाइलें ऊपर और नीचे नामित हैं
आप अपने SQL स्टेटमेंट को उन फाइलों में डालते हैं, जो शुद्ध sql है
फिर आप टाइप करें: npm run migrate: up या npm run migrate: down

इस काम के लिए, कृपया db-migrate मॉड्यूल पर एक नज़र डालें ।

एक बार जब आप इसे सेटअप कर लेते हैं (जो मुश्किल नहीं है), तो अपना DB बदलना वास्तव में आसान है और बहुत समय बचाता है।

— वेदरन मारिसविक।
स्रोत