SQLAlchemy में रॉ SQL को कैसे निष्पादित करें?

SQLAlchemy एक SQL टूल है जिसे Python के साथ बनाया गया है जो डेवलपर्स को उच्च-प्रदर्शन डेटाबेस को डिज़ाइन करने और प्रबंधित करने के लिए कई शक्तिशाली सुविधाएँ प्रदान करता है।

हम संक्षेप में यह पता लगाएंगे कि SQLAlchemy का उपयोग कैसे करें और फिर पाइथन डोमेन भाषा के आराम से कच्चे SQL कथनों को निष्पादित करने के तरीके में गहराई से गोता लगाएँ।

SQLAlchemy का उपयोग करना

जैसा कि सभी पायथन पुस्तकालयों के साथ होता है, SQLAlchemy स्थापित करके प्रारंभ करें। एक बार इंस्टॉल हो जाने पर हम पायथन में मजा शुरू कर सकते हैं।

इसके बाद, आयात करें sqlalchemy स्वयं, फिर कुछ मॉड्यूल आयात करें ताकि हम आसानी से SQLAlchemy डेटाबेस इंजन तक पहुँच सकें:

import sqlalchemy
from sqlalchemy import create_engine
from sqlalchemy import Table, Column, Integer, String, MetaData, ForeignKey
from sqlalchemy import inspect

create_engine . के अलावा , हम कई अतिरिक्त मॉड्यूल भी आयात कर रहे हैं जिनकी हमें एक नई तालिका बनाने के लिए आवश्यकता होगी। इससे पहले कि हम उस तक पहुंचें, सुनिश्चित करें कि SQLAlchemy स्थापित, आयात किया गया था, और .__version__ पर कॉल करके काम कर रहा है। इस तरह:

print sqlalchemy.__version__
Out[*]: 1.0.9

टेबल बनाना

हम कुछ metadata बनाने के लिए SQLAlchemy की मूलभूत कार्यक्षमता का उपयोग करेंगे जो SQL अभिव्यक्ति भाषा है। जिसमें कई संबंधित मॉड्यूल (या ऑब्जेक्ट) शामिल होंगे जो हमारी नई book . को परिभाषित करते हैं डेटाबेस तालिका:

metadata = MetaData()
books = Table('book', metadata,
  Column('id', Integer, primary_key=True),
  Column('title', String),
  Column('primary_author', String),
)

engine = create_engine('sqlite:///bookstore.db')
metadata.create_all(engine)

सबसे ऊपर हम metadata . को परिभाषित करते हैं , फिर हम उसे Table() . में पास करते हैं विधि, जहां हम अपनी तालिका को book . नाम देते हैं . इसके भीतर, हम प्रत्येक कॉलम को डेटा प्रकार और primary_key . जैसी महत्वपूर्ण विशेषताओं के साथ परिभाषित करते हैं ।

एक बार जब हमारी टेबल्स परिभाषित हो जाती हैं और हमारे metadata . से जुड़ जाती हैं ऑब्जेक्ट, हमें एक डेटाबेस इंजन बनाने की आवश्यकता है जिसके साथ हम जुड़ सकते हैं। यह create_engine . का उपयोग करके पूरा किया जाता है समारोह।

engine = create_engine('sqlite:///bookstore.db')

हमारे उदाहरण के लिए, हम एक साधारण SQLite . का उपयोग करेंगे डेटाबेस। आप अन्य इंजन जैसे MySQL या PostgreSQL के लिए कनेक्शन स्ट्रिंग्स का भी उपयोग कर सकते हैं। यहाँ PostgreSQL के लिए एक इंजन बनाने के लिए सिंटैक्स का एक उदाहरण दिया गया है:

engine = create_engine('postgresql://user:password@host/database')

इंजन के निर्माण के साथ, अब हमें .create_all() . का उपयोग करने की आवश्यकता है हमारे metadata . की विधि ऑब्जेक्ट करें और engine पास करें इसके साथ कनेक्शन, जो स्वचालित रूप से SQLAlchemy को हमारे लिए हमारी तालिका उत्पन्न करने का कारण बनेगा, जैसा कि ऊपर देखा गया है।

उस पूर्ण के साथ, हम तालिका का उपयोग कर सकते हैं जैसा कि हम फिट देखते हैं। इस सरल उदाहरण में, हम केवल inspect . का उपयोग करेंगे कॉलम देखने और हमारी तालिका को सत्यापित करने के लिए मॉड्यूल सफलतापूर्वक बनाया गया था:

inspector = inspect(engine)
inspector.get_columns('book')
Out[*]:
[{'autoincrement': True,
  'default': None,
  'name': u'id',
  'nullable': False,
  'primary_key': 1,
  'type': INTEGER()},
 {'autoincrement': True,
  'default': None,
  'name': u'title',
  'nullable': True,
  'primary_key': 0,
  'type': VARCHAR()},
 {'autoincrement': True,
  'default': None,
  'name': u'primary_author',
  'nullable': True,
  'primary_key': 0,
  'type': VARCHAR()}]

निश्चित रूप से, .get_columns() . का उपयोग करके हमारी book . के लिए विधि तालिका, हम देखते हैं कि हमारे तीन कॉलम उत्पन्न हुए थे।

SQL कथन निष्पादित करना

मूल बातों के साथ, अब हम SQLAlchemy का उपयोग करके कुछ कच्चे SQL को निष्पादित करने का प्रयास कर सकते हैं।

टेक्स्ट मॉड्यूल का उपयोग करना

कच्चे SQL को क्रियान्वित करने का एक तरीका text . का उपयोग करना है मॉड्यूल, या Textual SQL . text . का उपयोग करने का सबसे पठनीय तरीका मॉड्यूल आयात करना है, फिर engine . से कनेक्ट करने के बाद , text परिभाषित करें .execute . का उपयोग करने से पहले SQL कथन स्ट्रिंग इसे चलाने के लिए:

from sqlalchemy.sql import text
with engine.connect() as con:

    data = ( { "id": 1, "title": "The Hobbit", "primary_author": "Tolkien" },
             { "id": 2, "title": "The Silmarillion", "primary_author": "Tolkien" },
    )

    statement = text("""INSERT INTO book(id, title, primary_author) VALUES(:id, :title, :primary_author)""")

    for line in data:
        con.execute(statement, **line)

यहां हम text() . का उपयोग करके अपने डेटाबेस में दो रिकॉर्ड डाल रहे हैं -परिभाषित कथन।

निष्पादन विधि का उपयोग करना

वैकल्पिक तरीका text() . का उपयोग करके छोड़ना है और कच्चे SQL स्ट्रिंग को .execute() . पर पास करें तरीका। उदाहरण के लिए, यहां हम .execute() . का उपयोग करेंगे ऊपर डाले गए नए रिकॉर्ड देखने के लिए:

with engine.connect() as con:

    rs = con.execute('SELECT * FROM book')

    for row in rs:
        print row

Out[*]:
(4, u'The Hobbit', u'Tolkien')
(5, u'The Silmarillion', u'Tolkien')

वहाँ हमारे पास है! SQLAlchemy में अपरिष्कृत SQL कथनों को क्रियान्वित करने के लिए सरल और प्रभावी तरीके।