फ्लास्क मेगा-ट्यूटोरियल, भाग 4: डेटाबेस

यह एक श्रृंखला का चौथा लेख है जहां मैं फ्लास्क माइक्रोफ्रामवर्क का उपयोग करके पायथन वेब एप्लिकेशन लिखने के अपने अनुभव का वर्णन करता हूं।

इस गाइड का उद्देश्य एक काफी कार्यात्मक माइक्रोब्लॉगिंग एप्लीकेशन विकसित करना है, जिसे मैंने मौलिकता की कमी के लिए माइक्रोब्लॉग कहने का फैसला किया।

संक्षिप्त पुनरावृत्ति

पिछले भाग में, हमने प्रस्तुति और सत्यापन के साथ अपना लॉगिन फ़ॉर्म पूर्ण बनाया।

इस लेख में, हम अपने डेटाबेस बनाने और इसे बढ़ाने का इरादा रखते हैं ताकि हम अपने उपयोगकर्ताओं को वहां रिकॉर्ड कर सकें।

इस भाग का पालन करने के लिए, आपका माइक्रोब्लॉगिंग एप्लिकेशन वैसा ही होना चाहिए जैसा कि हमने पिछले एक के अंत में छोड़ा था। कृपया सुनिश्चित करें कि एप्लिकेशन इंस्टॉल और काम कर रहा है।

कमांड लाइन से पायथन स्क्रिप्ट चला रहा है

इस भाग में, हम कुछ स्क्रिप्ट लिखने जा रहे हैं जो हमारे डेटाबेस के प्रबंधन को सरल बनाएगी। आरंभ करने से पहले, आइए देखें कि पायथन स्क्रिप्ट को कमांड लाइन से कैसे निष्पादित किया जाता है।

यदि आप एक Linux या OS X उपयोगकर्ता हैं, तो स्क्रिप्ट को निष्पादन अधिकार दिए जाने की आवश्यकता है:

chmod a+x script.py 

स्क्रिप्ट में एक शबंग रेखा है । पहले स्थान) का उपयोग दुभाषिया के लिए पथ के रूप में किया जाता है। ), जो निर्धारित करता है कि किस दुभाषिया का उपयोग किया जाना चाहिए। दी गई निष्पादन अधिकारों और एक शबंग रेखा के साथ एक स्क्रिप्ट को इस तरह आसानी से चलाया जा सकता है:

 ./script.py <> 

विंडोज पर, हालांकि, यह काम नहीं करेगा, और इसके बजाय आपको चयनित पायथन दुभाषिया के तर्क के रूप में स्क्रिप्ट को पास करना चाहिए:

 flask\Scripts\python script.py <> 

दुभाषिया के लिए पथ में प्रवेश करने से बचने के लिए, आप सिस्टम PATH में अपने माइक्रोब्लॉग \ फ्लास्क \ लिपियों निर्देशिका को जोड़ सकते हैं, यह सुनिश्चित करते हुए कि यह [दुभाषिया के लिए पथ] आपके नियमित दुभाषिया को लिखा गया है।

अब से, यह गाइड संक्षिप्तता के लिए लिनक्स / ओएस एक्स सिंटैक्स का उपयोग करेगा। यदि आप एक विंडोज उपयोगकर्ता हैं, तो तदनुसार सिंटैक्स को बदलना सुनिश्चित करें।

फ्लास्क में डेटाबेस

हमारे आवेदन को नियंत्रित करने के लिए, हम Flask-SQLAlchemy एक्सटेंशन का उपयोग करेंगे। यह एक्सटेंशन SQLAlchemy प्रोजेक्ट के लिए एक आवरण प्रदान करता है, जो ORM या ऑब्जेक्ट-रिलेशनल मैपिंग है।

ORM डेटाबेस एप्लिकेशन को टेबल या SQL के बजाय ऑब्जेक्ट के साथ काम करने की अनुमति देता है। संचालन ऑब्जेक्ट पर किए जाते हैं, और फिर ORM का उपयोग करके पारदर्शी रूप से डेटाबेस कमांड में अनुवादित किया जाता है। वास्तव में, इसका मतलब है कि हम इस गाइड में एसक्यूएल का अध्ययन नहीं करेंगे, लेकिन फ्लास्क-एसक्यूएलचेमी को हमारे लिए एसक्यूएल बोलने दें।

प्रवास

अधिकांश मैनुअल जो मैंने डेटाबेस के निर्माण और उपयोग को देखा है, लेकिन एप्लिकेशन की वृद्धि के कारण डेटाबेस को अपडेट करने की समस्याओं को ठीक से संबोधित नहीं करते हैं। आमतौर पर यह सभी पुराने डेटाबेस को हटाने और हर बार जब आप अपग्रेड करने की आवश्यकता होती है, तो एक नया डेटा बनाते हुए सभी डेटा खो देते हैं। और यदि डेटा को आसानी से पुनः प्राप्त नहीं किया जा सकता है, तो आपको निर्यात और आयात स्क्रिप्ट स्वयं लिखनी पड़ सकती है।

सौभाग्य से, हमारे पास एक बेहतर विकल्प है।

हम अपने लिए डेटाबेस अपडेट ट्रैक करने के लिए SQLAlchemy-migrate का उपयोग करने जा रहे हैं। यह डेटाबेस को शुरू करने के लिए थोड़ा काम करेगा, लेकिन मैनुअल डेटाबेस माइग्रेशन के बारे में कभी चिंता न करने के लिए यह कम लागत है।

पर्याप्त सिद्धांत, आरंभ करने का समय!

विन्यास

हमारे छोटे अनुप्रयोग के लिए हम sqlite उपयोग करेंगे। ये डेटाबेस छोटे अनुप्रयोगों के लिए सबसे उपयुक्त विकल्प हैं, क्योंकि प्रत्येक डेटाबेस को एक अलग फ़ाइल में संग्रहीत किया जाता है।

हमारे पास कुछ आइटम हैं जिन्हें हम कॉन्फ़िगरेशन फ़ाइल (config.py file) में जोड़ेंगे:

 import os basedir = os.path.abspath(os.path.dirname(__file__)) SQLALCHEMY_DATABASE_URI = 'sqlite:///' + os.path.join(basedir, 'app.db') SQLALCHEMY_MIGRATE_REPO = os.path.join(basedir, 'db_repository') 

SQLALCHEMY_DATABASE_URI Flask-SQLAlchemy एक्सटेंशन के लिए SQLALCHEMY_DATABASE_URI आवश्यक है। यह हमारे डेटाबेस के साथ फ़ाइल का पथ है।

SQLALCHEMY_MIGRATE_REPO वह फ़ोल्डर है जहाँ हम SQLAlchemy-migrate. फ़ाइलों को संग्रहीत करेंगे SQLAlchemy-migrate.

अंत में, जब हम अपने एप्लिकेशन को इनिशियलाइज़ करते हैं, तो हमें अपने डेटाबेस को इनिशियलाइज़ करने की भी आवश्यकता होगी। यहां हमारी अपडेट की गई इनिट फ़ाइल (ऐप / __ init__.py फ़ाइल) है:

 from flask import Flask from flask.ext.sqlalchemy import SQLAlchemy app = Flask(__name__) app.config.from_object('config') db = SQLAlchemy(app) from app import views, models 

हमारे init स्क्रिप्ट में किए गए दो बदलावों पर ध्यान दें। अब हम db ऑब्जेक्ट बनाते हैं, जो हमारा डेटाबेस होगा, और हम एक नया मॉड्यूल भी आयात करते हैं, जिसे models कहा जाता models । हम इस मॉड्यूल को आगे लिखेंगे।

डेटाबेस मॉडल

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

आइए एक मॉडल बनाकर शुरू करें जो हमारे उपयोगकर्ताओं का वर्णन करेगा। WWW SQL डिज़ाइनर टूल का उपयोग करते हुए, हमने अपने उपयोगकर्ताओं की तालिका प्रदर्शित करने के लिए निम्नलिखित चित्र बनाए:


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

nickname और email फ़ील्ड को स्ट्रिंग (या डेटाबेस शब्दजाल में VARCHAR ) के रूप में परिभाषित किया गया है, और उनकी अधिकतम लंबाई निर्धारित है, जो हमारे डेटाबेस को अंतरिक्ष के उपयोग का अनुकूलन करने की अनुमति देगा।

role क्षेत्र एक पूर्णांक है जिसका उपयोग हम यह देखने के लिए करेंगे कि कौन से उपयोगकर्ता प्रशासक हैं और कौन से नहीं हैं।

अब हमने फैसला किया है कि हम अपनी तालिका क्या देखना चाहते हैं। इस सब को कोड में अनुवादित करना काफी सरल है (फ़ाइल ऐप / मॉडल ओडीएम):

 from app import db ROLE_USER = 0 ROLE_ADMIN = 1 class User(db.Model): id = db.Column(db.Integer, primary_key = True) nickname = db.Column(db.String(64), index = True, unique = True) email = db.Column(db.String(120), index = True, unique = True) role = db.Column(db.SmallInteger, default = ROLE_USER) def __repr__(self): return '<User %r>' % (self.nickname) 

हमारे द्वारा अभी बनाया गया User वर्ग कई क्षेत्रों को वर्ग चर के रूप में परिभाषित करता है। फ़ील्ड db.Column उदाहरणों के रूप में बनाए जाते हैं, जो फ़ील्ड प्रकार को एक तर्क के रूप में लेता है, साथ ही अन्य वैकल्पिक तर्क, जो हमें उदाहरण के लिए, यह इंगित करने की अनुमति देता है कि कौन से फ़ील्ड अद्वितीय और अनुक्रमित हैं।

__repr__ विधि पायथन को बताती है कि इस वर्ग की वस्तुओं का उत्पादन कैसे किया जाता है। हम इसका उपयोग डिबगिंग के लिए करेंगे।

डेटाबेस निर्माण

हमें कॉन्फ़िगरेशन और मॉडल के साथ किया जाता है, अब हम अपने डेटाबेस के साथ एक फ़ाइल बनाने के लिए तैयार हैं। SQLAlchemy-migrate पैकेज डेटाबेस बनाने के लिए कमांड-लाइन टूल और API के साथ आता है जो भविष्य में आसान अपडेट की अनुमति देगा, जो हम करेंगे। मुझे कुछ स्थानों पर कमांड लाइन टूल का उपयोग करने में असुविधाजनक लगता है, इसलिए इसके बजाय मैंने छोटे पायथन लिपियों के अपने सेट को लिखा है जो माइग्रेशन कॉल को कहते हैं।

यहाँ वह स्क्रिप्ट है जो डेटाबेस बनाता है (db_create.py फ़ाइल):

 #!flask/bin/python from migrate.versioning import api from config import SQLALCHEMY_DATABASE_URI from config import SQLALCHEMY_MIGRATE_REPO from app import db import os.path db.create_all() if not os.path.exists(SQLALCHEMY_MIGRATE_REPO): api.create(SQLALCHEMY_MIGRATE_REPO, 'database repository') api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) else: api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, api.version(SQLALCHEMY_MIGRATE_REPO)) 

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

डेटाबेस बनाने के लिए, आपको बस स्क्रिप्ट चलाने की ज़रूरत है (याद रखें कि यदि आप विंडोज पर हैं, तो कमांड थोड़ा अलग है):

 ./db_create.py 

कमांड डालने के बाद, आपको एक नया app.db फाइल मिलेगा। यह एक खाली sqlite डेटाबेस है जो मूल रूप से माइग्रेशन का समर्थन करता है। आपके पास एक db_repository निर्देशिका भी है जिसमें अंदर कई फाइलें हैं। इस बिंदु पर, SQLAlchemy-migrate अपनी डेटा फ़ाइलों को संग्रहीत करता है। मैं ध्यान देता हूं कि यदि यह पहले से ही बनाया गया है तो हम भंडार को फिर से नहीं बनाते हैं। यदि आवश्यक हो तो यह हमें मौजूदा रिपॉजिटरी से डेटाबेस को फिर से बनाने की अनुमति देगा।

हमारा पहला प्रवास

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

माइग्रेशन शुरू करने के लिए, मैं एक और सहायक स्क्रिप्ट (db_migrate.py फ़ाइल) का उपयोग करता हूं:

 #!flask/bin/python import imp from migrate.versioning import api from app import db from config import SQLALCHEMY_DATABASE_URI from config import SQLALCHEMY_MIGRATE_REPO migration = SQLALCHEMY_MIGRATE_REPO + '/versions/%03d_migration.py' % (api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) + 1) tmp_module = imp.new_module('old_model') old_model = api.create_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) exec old_model in tmp_module.__dict__ script = api.make_update_script_for_model(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, tmp_module.meta, db.metadata) open(migration, "wt").write(script) api.upgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) print 'New migration saved as ' + migration print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)) 

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

हालांकि मुझे उपरोक्त स्क्रिप्ट द्वारा माइग्रेशन की स्वचालित पीढ़ी के साथ कोई समस्या नहीं थी, मैं यह देख सकता था कि कई बार यह निर्धारित करना मुश्किल है, बस पुराने और नए प्रारूप की तुलना करना, क्या बदलाव किए गए थे। परिवर्तनों को परिभाषित SQLAlchemy-migrate में SQLAlchemy-migrate के काम को आसान बनाने के लिए, मैं कभी भी मौजूदा फ़ील्ड का नाम नहीं बदलता, मॉडल या फ़ील्ड को जोड़ने / हटाने के लिए परिवर्तनों को प्रतिबंधित करता हूं, बनाए गए फ़ील्ड के प्रकारों को बदलता है। और मैं हमेशा सुनिश्चित माइग्रेशन स्क्रिप्ट का निरीक्षण करता हूं ताकि यह सुनिश्चित हो सके कि यह सही है।

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

तो चलिए आगे बढ़ते हैं और अपना माइग्रेशन लिखते हैं:

 ./db_migrate.py 

और स्क्रिप्ट का उत्पादन होगा:

 New migration saved as db_repository/versions/001_migration.py Current database version: 1 

स्क्रिप्ट से पता चलता है कि माइग्रेशन स्क्रिप्ट को कहाँ सहेजा गया था, और डेटाबेस का वर्तमान संस्करण भी प्रदर्शित करता है। खाली डेटाबेस में संस्करण 0 था, उपयोगकर्ताओं के शामिल किए जाने के साथ प्रवास के बाद, हमारे पास संस्करण 1 है।

डेटाबेस को अपग्रेड और डाउनग्रेड करें

अब आप सोच रहे होंगे कि डेटाबेस माइग्रेशन रिकॉर्ड करने में अतिरिक्त परेशानियों से गुजरना इतना महत्वपूर्ण क्यों है।

कल्पना करें कि आपके पास अपने काम के कंप्यूटर पर एक आवेदन है, और आपके पास उपयोग में एक प्रति भी है, जो एक उत्पादन सर्वर पर तैनात है।

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

यदि आपके पास डेटाबेस माइग्रेशन समर्थन है, जब आप अपने उत्पादन सर्वर पर एप्लिकेशन का एक नया संस्करण जारी करने के लिए तैयार हैं, तो आपको बस नया माइग्रेशन लिखने की आवश्यकता है, माइग्रेशन स्क्रिप्ट को अपने सर्वर पर कॉपी करें और एक साधारण स्क्रिप्ट चलाएं जो आपके परिवर्तनों को लागू करती है। डेटाबेस को अपडेट करना इस छोटे पायथन स्क्रिप्ट (db_upgrad.py फ़ाइल) के साथ किया जा सकता है:

 #!flask/bin/python from migrate.versioning import api from config import SQLALCHEMY_DATABASE_URI from config import SQLALCHEMY_MIGRATE_REPO v = api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO) api.downgrade(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO, v - 1) print 'Current database version: ' + str(api.db_version(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)) 

यह स्क्रिप्ट डेटाबेस को एक संशोधन द्वारा डाउनग्रेड करेगी। आप इसे कई बार कई संशोधनों के लिए वापस चलाने के लिए चला सकते हैं।

डेटाबेस संबंध

डेटा आइटम के बीच संबंधों को संग्रहीत करने में संबंधपरक डेटाबेस अच्छे हैं। उस मामले पर विचार करें जिसमें कोई उपयोगकर्ता ब्लॉग पोस्ट लिखता है। उसके पास उपयोगकर्ता तालिका में एक प्रविष्टि होगी, और पोस्ट को पोस्ट टेबल में जोड़ा जाएगा। इस पोस्ट को लिखने का सबसे प्रभावी तरीका दो संबंधित रिकॉर्डों को जोड़ना है।

उपयोगकर्ता और पोस्ट के बीच संबंध स्थापित होने के बाद, दो प्रकार के अनुरोध हैं जिनकी हमें आवश्यकता हो सकती है। जब आपके पास कोई पोस्ट हो तो सबसे तुच्छ और आपको यह जानना होगा कि किस उपयोगकर्ता ने इसे लिखा था। थोड़ा और जटिल सवाल इस का उल्टा है। यदि आपके पास एक उपयोगकर्ता है, तो आपको उसके द्वारा लिखित सभी प्रविष्टियाँ प्राप्त करने की आवश्यकता हो सकती है। Flask-SQLAlchemy हमें दोनों प्रकार के प्रश्नों के साथ मदद करेगा।

हम पदों को संग्रहीत करने के लिए अपने डेटाबेस का विस्तार करेंगे ताकि हम कार्रवाई में कनेक्शन देख सकें। ऐसा करने के लिए, हम अपने डेटाबेस डिज़ाइन टूल पर लौटेंगे और रिकॉर्ड्स की एक तालिका बनाएंगे:


रिकॉर्ड की हमारी तालिका में होगा: आईडी, रिकॉर्ड और तारीख का पाठ। कोई नई बात नहीं। लेकिन user_id फ़ील्ड स्पष्टीकरण के योग्य है।

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

आइए इन बदलावों को प्रतिबिंबित करने के लिए अपना मॉडल बदलें (ऐप / मॉडल ओडीएम):

 from app import db ROLE_USER = 0 ROLE_ADMIN = 1 class User(db.Model): id = db.Column(db.Integer, primary_key = True) nickname = db.Column(db.String(64), unique = True) email = db.Column(db.String(120), unique = True) role = db.Column(db.SmallInteger, default = ROLE_USER) posts = db.relationship('Post', backref = 'author', lazy = 'dynamic') def __repr__(self): return '<User %r>' % (self.nickname) class Post(db.Model): id = db.Column(db.Integer, primary_key = True) body = db.Column(db.String(140)) timestamp = db.Column(db.DateTime) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) def __repr__(self): return '<Post %r>' % (self.body) 

हमने Post क्लास को जोड़ा है, जो उपयोगकर्ता ब्लॉग प्रविष्टियों का प्रतिनिधित्व करेगा। पोस्ट क्लास में user_id फ़ील्ड को एक विदेशी कुंजी के रूप में आरंभीकृत किया जाएगा, इसलिए Flask-SQLAlchemy पता है कि यह फ़ील्ड उपयोगकर्ता के साथ संबद्ध होगी।

ध्यान दें कि हमने User वर्ग में एक नया posts फ़ील्ड भी जोड़ा है, जिसे db.relationship फ़ील्ड के रूप में लागू किया गया है। वास्तव में, यह एक डीबी क्षेत्र नहीं है, इसलिए यह हमारे आरेख में नहीं है। एक-से-कई db.relationship फ़ील्ड db.relationship आमतौर पर "एक" पक्ष पर परिभाषित किया जाता है। इस कनेक्शन के साथ, हमें user.posts उपयोगकर्ता मिलता है, जो हमें सभी उपयोगकर्ता प्रविष्टियों की एक सूची देता है। db.relationship का पहला तर्क इस संबंध में "कई" वर्ग की ओर db.relationship करता है। backref तर्क "कई" वर्ग की वस्तुओं में "एक" ऑब्जेक्ट की ओर इंगित करने के लिए फ़ील्ड को निर्दिष्ट करता है। हमारे मामले में, इसका मतलब है कि हम post.author का उपयोग कर सकते हैं। User प्रविष्टि प्राप्त करने के लिए जिसके द्वारा यह प्रविष्टि बनाई गई थी। चिंता न करें अगर ये विवरण आपको समझ में नहीं आते हैं, तो हम इस लेख के अंत में उदाहरण देखेंगे।

आइए इस बदलाव के साथ एक और प्रवास लिखें। बस चलाएं:

 ./db_migrate.py 

और स्क्रिप्ट वापस आ जाएगी:

 New migration saved as db_repository/versions/002_migration.py Current database version: 2 

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

लॉन्च का समय

हमने अपने डेटाबेस को परिभाषित करने में बहुत समय बिताया, लेकिन अभी तक यह नहीं देखा है कि यह कैसे काम करता है। जब तक हमारे आवेदन में कोई डेटाबेस कोड नहीं होता है, हम पायथन दुभाषिया में अपने नए आधार का उपयोग करेंगे।

पायथन चलाएं। लिनक्स या OS X पर:

 flask/bin/python 

या विंडोज पर:

 flask\Scripts\python 

हम निम्नलिखित लिखते हैं:

 >>> from app import db, models >>> 

यह हमारे डेटाबेस और मॉडल को याद करेगा।

एक नया उपयोगकर्ता बनाएँ:

 >>> u = models.User(nickname='john', email='john@email.com', role=models.ROLE_USER) >>> db.session.add(u) >>> db.session.commit() >>> 

डेटाबेस में परिवर्तन वर्तमान सत्र के संदर्भ में किया जाता है। एक सत्र में कई परिवर्तन एकत्र किए जा सकते हैं, और जैसे ही वे सभी पंजीकृत होते हैं, आप एक db.session.commit() जारी कर सकते हैं, जो स्वचालित रूप से सभी परिवर्तनों को रिकॉर्ड करेगा। यदि सत्र में काम करते समय कोई त्रुटि होती है, तो db.session.rollback() कॉल करने से सत्र शुरू होने से पहले राज्य में डेटाबेस वापस आ जाएगा। यदि न तो प्रतिबद्ध और न ही रोलबैक कहा जाता है, तो सिस्टम डिफ़ॉल्ट रूप से सत्र को वापस रोल करेगा। सत्र यह सुनिश्चित करते हैं कि डेटाबेस कभी भी असंगत स्थिति में न रहे।

कोई अन्य उपयोगकर्ता जोड़ें:

 >>> u = models.User(nickname='susan', email='susan@email.com', role=models.ROLE_USER) >>> db.session.add(u) >>> db.session.commit() >>> 

अब हम अपने सभी उपयोगकर्ताओं से अनुरोध कर सकते हैं:

 >>> users = models.User.query.all() >>> print users [<User u'john'>, <User u'susan'>] >>> for u in users: ... print u.id,u.nickname ... 1 john 2 susan >>> 

ऐसा करने के लिए, हमने एक कस्टम क्वेरी का उपयोग किया, जो कक्षा के सभी मॉडलों के लिए उपलब्ध है। कृपया ध्यान दें कि उपयोगकर्ता आईडी हमारे लिए स्वचालित रूप से कैसे सेट की गई थी।

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

 >>> u = models.User.query.get(1) >>> print u <User u'john'> >>> 

अब एक ब्लॉग पोस्ट जोड़ें:

 >>> import datetime >>> u = models.User.query.get(1) >>> p = models.Post(body='my first post!', timestamp=datetime.datetime.utcnow(), author=u) >>> db.session.add(p) >>> db.session.commit() 

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

आपने देखा होगा कि हमने Post class में user_id फ़ील्ड सेट नहीं किया था। इसके बजाय, हम अपने author क्षेत्र के अंदर User ऑब्जेक्ट को संग्रहीत करते हैं। इस आभासी क्षेत्र को रिश्तों में मदद करने के लिए फ्लास्क-एसक्यूएलचेमी द्वारा जोड़ा गया था, हमने अपने मॉडल के db.relationship में backref तर्क में इस क्षेत्र के नाम को परिभाषित किया। इस जानकारी के साथ, ORM परत को पता चलेगा कि हमारे लिए user_id को कैसे आबाद किया जाए।

इस सत्र को समाप्त करने के लिए, हम कुछ और डेटाबेस प्रश्नों को देखते हैं, जो हम कर सकते हैं:

 #     >>> u = models.User.query.get(1) >>> print u <User u'john'> >>> posts = u.posts.all() >>> print posts [<Post u'my first post!'>] #     >>> for p in posts: ... print p.id,p.author.nickname,p.body ... 1 john my first post! #    >>> u = models.User.query.get(2) >>> print u <User u'susan'> >>> print u.posts.all() [] #        >>> print models.User.query.order_by('nickname desc').all() [<User u'susan'>, <User u'john'>] >>> 

फ्लास्क-SQLAlchemy प्रलेखन डेटाबेस प्रश्नों के लिए उपलब्ध कई विकल्पों का पता लगाने के लिए सबसे अच्छी जगह है।

समाप्त करने से पहले, आइए हम परीक्षण उपयोगकर्ताओं को हटा दें और अगले अध्याय में एक स्वच्छ डेटाबेस के साथ शुरू करने के लिए प्रविष्टियां बनाएं:

 >>> users = models.User.query.all() >>> for u in users: ... db.session.delete(u) ... >>> posts = models.Post.query.all() >>> for p in posts: ... db.session.delete(p) ... >>> db.session.commit() >>> 

निष्कर्ष

यह एक लंबी मार्गदर्शिका है। हमने डेटाबेस के साथ काम करने की मूल बातें सीखीं, लेकिन अभी तक इसे अपने आवेदन में नहीं बनाया है। अगले भाग में, हम सब कुछ लागू करेंगे जो हमने डेटाबेस के बारे में सीखा था, जब हम अपने लॉगिन सिस्टम को देखते हैं।

इस बीच, यदि आप हमारे साथ कोई एप्लिकेशन नहीं लिख रहे हैं, तो आप इसे वर्तमान संस्करण में डाउनलोड कर सकते हैं:
microblog-0.4.zip

कृपया ध्यान दें, मैंने ऊपर के ज़िप आर्काइव में डेटाबेस को शामिल नहीं किया है, लेकिन माइग्रेशन के साथ रिपॉजिटरी है। एक नया डेटाबेस बनाने के लिए बस db_create.py का उपयोग करें, फिर db_upgrad.py, डेटाबेस को नवीनतम संशोधन में अद्यतन करने के लिए।

आपसे फिर मिलने की उम्मीद है!

मिगुएल।