Python Language
डेटाबेस एक्सेस
खोज…
टिप्पणियों
अजगर कई अलग-अलग प्रकार के डेटाबेस को संभाल सकता है। इनमें से प्रत्येक प्रकार के लिए एक अलग एपीआई मौजूद है। इसलिए उन विभिन्न एपीआई के बीच समानता को प्रोत्साहित करें, पीईपी 249 को पेश किया गया है।
इस एपीआई को डेटाबेस तक पहुंचने के लिए उपयोग किए जाने वाले पायथन मॉड्यूल के बीच समानता को प्रोत्साहित करने के लिए परिभाषित किया गया है। ऐसा करने से, हम अधिक आसानी से समझे जाने वाले मॉड्यूल के लिए अग्रणी स्थिरता प्राप्त करने की उम्मीद करते हैं, कोड जो कि आमतौर पर डेटाबेस में अधिक पोर्टेबल है, और पायथन से डेटाबेस कनेक्टिविटी की एक व्यापक पहुंच है। पीईपी-249
MySQLdb का उपयोग करके MySQL डेटाबेस तक पहुँचना
पहली चीज जो आपको करने की ज़रूरत है वह कनेक्ट विधि का उपयोग करके डेटाबेस से कनेक्शन बनाना है। उसके बाद, आपको एक कर्सर की आवश्यकता होगी जो उस कनेक्शन के साथ काम करेगा।
डेटाबेस के साथ बातचीत करने के लिए कर्सर के निष्पादन विधि का उपयोग करें, और हर एक समय में, कनेक्शन ऑब्जेक्ट की प्रतिबद्ध पद्धति का उपयोग करके परिवर्तन करें।
एक बार सब कुछ हो जाने के बाद, कर्सर और कनेक्शन को बंद करना न भूलें।
यहाँ सब कुछ के साथ एक Dbconnect क्लास है जिसकी आपको आवश्यकता होगी।
import MySQLdb
class Dbconnect(object):
def __init__(self):
self.dbconection = MySQLdb.connect(host='host_example',
port=int('port_example'),
user='user_example',
passwd='pass_example',
db='schema_example')
self.dbcursor = self.dbconection.cursor()
def commit_db(self):
self.dbconection.commit()
def close_db(self):
self.dbcursor.close()
self.dbconection.close()
डेटाबेस के साथ बातचीत सरल है। ऑब्जेक्ट बनाने के बाद, बस निष्पादित विधि का उपयोग करें।
db = Dbconnect()
db.dbcursor.execute('SELECT * FROM %s' % 'table_example')
यदि आप किसी संग्रहीत कार्यविधि को कॉल करना चाहते हैं, तो निम्न सिंटैक्स का उपयोग करें। ध्यान दें कि पैरामीटर सूची वैकल्पिक है।
db = Dbconnect()
db.callproc('stored_procedure_name', [parameters] )
क्वेरी किए जाने के बाद, आप परिणाम कई तरीकों से एक्सेस कर सकते हैं। कर्सर ऑब्जेक्ट एक जनरेटर है जो सभी परिणामों को प्राप्त कर सकता है या लूप किया जा सकता है।
results = db.dbcursor.fetchall()
for individual_row in results:
first_field = individual_row[0]
यदि आप सीधे जनरेटर का उपयोग कर एक लूप चाहते हैं:
for individual_row in db.dbcursor:
first_field = individual_row[0]
यदि आप डेटाबेस में परिवर्तन करना चाहते हैं:
db.commit_db()
यदि आप कर्सर और कनेक्शन को बंद करना चाहते हैं:
db.close_db()
SQLite
SQLite एक हल्का, डिस्क-आधारित डेटाबेस है। चूंकि इसे एक अलग डेटाबेस सर्वर की आवश्यकता नहीं होती है, इसलिए इसे अक्सर प्रोटोटाइप के लिए या छोटे अनुप्रयोगों के लिए उपयोग किया जाता है जो अक्सर एक उपयोगकर्ता द्वारा या किसी दिए गए समय में एक उपयोगकर्ता द्वारा उपयोग किया जाता है।
import sqlite3
conn = sqlite3.connect("users.db")
c = conn.cursor()
c.execute("CREATE TABLE user (name text, age integer)")
c.execute("INSERT INTO user VALUES ('User A', 42)")
c.execute("INSERT INTO user VALUES ('User B', 43)")
conn.commit()
c.execute("SELECT * FROM user")
print(c.fetchall())
conn.close()
उपर्युक्त कोड, users.db नाम की फ़ाइल में संग्रहीत डेटाबेस से जुड़ता है, यदि पहले से मौजूद नहीं है तो फ़ाइल पहले बनाएँ। आप SQL स्टेटमेंट के माध्यम से डेटाबेस के साथ बातचीत कर सकते हैं।
इस उदाहरण का परिणाम होना चाहिए:
[(u'User A', 42), (u'User B', 43)]
SQLite सिंटैक्स: एक गहन विश्लेषण
शुरू करना
का उपयोग कर sqlite मॉड्यूल आयात करें
>>> import sqlite3मॉड्यूल का उपयोग करने के लिए, आपको पहले एक कनेक्शन ऑब्जेक्ट बनाना होगा जो डेटाबेस का प्रतिनिधित्व करता है। यहां डेटा example.db फ़ाइल में संग्रहीत किया जाएगा:
>>> conn = sqlite3.connect('users.db')वैकल्पिक रूप से, आप विशेष नाम की आपूर्ति भी कर सकते हैं
:memory:रैम में एक अस्थायी डेटाबेस बनाने के लिए, निम्नानुसार है:>>> conn = sqlite3.connect(':memory:')एक बार आपके पास
Connection, आप एकCursorऑब्जेक्ट बना सकते हैं और एसक्यूएल कमांड्स को निष्पादित करने के लिए इसकेexecute()विधि को कॉल कर सकते हैं:c = conn.cursor() # Create table c.execute('''CREATE TABLE stocks (date text, trans text, symbol text, qty real, price real)''') # Insert a row of data c.execute("INSERT INTO stocks VALUES ('2006-01-05','BUY','RHAT',100,35.14)") # Save (commit) the changes conn.commit() # We can also close the connection if we are done with it. # Just be sure any changes have been committed or they will be lost. conn.close()
Connection महत्वपूर्ण गुण और कार्य
isolation_levelयह एक विशेषता है जिसका उपयोग वर्तमान अलगाव स्तर को प्राप्त करने या निर्धारित करने के लिए किया जाता है। ऑटोकॉमिट मोड या
DEFERRED,IMMEDIATEयाEXCLUSIVE।
cursorकर्सर ऑब्जेक्ट का उपयोग SQL कमांड और क्वेरी को निष्पादित करने के लिए किया जाता है।
commit()वर्तमान लेन-देन करता है।
rollback()पिछली कॉल के बाद से किए गए किसी भी परिवर्तन को वापस करने के
commit()
close()डेटाबेस कनेक्शन बंद कर देता है। यह फोन नहीं करता है
commit()स्वचालित रूप से। यदि पहले कॉलिंगcommit()बिनाclose()कहा जाता है (यह मानते हुए कि आप ऑटोकॉमिट मोड में नहीं हैं) तो किए गए सभी परिवर्तन खो जाएंगे।
total_changesएक विशेषता जो डेटाबेस खोले जाने के बाद संशोधित, हटाई या डाली गई पंक्तियों की कुल संख्या को लॉग करती है।
execute,executemany, औरexecutescriptये कार्य उसी तरह से करते हैं जैसे कि कर्सर ऑब्जेक्ट। यह एक शॉर्टकट है क्योंकि इन ऑब्जेक्ट्स को कनेक्शन ऑब्जेक्ट के माध्यम से इंटरमीडिएट कर्सर ऑब्जेक्ट के निर्माण में कॉल किया जाता है और कर्सर ऑब्जेक्ट की संबंधित विधि को कॉल करता है।
row_factoryआप इस विशेषता को एक कॉल करने योग्य में बदल सकते हैं जो कर्सर और मूल पंक्ति को टुपल के रूप में स्वीकार करता है और वास्तविक परिणाम पंक्ति लौटाएगा।
def dict_factory(cursor, row): d = {} for i, col in enumerate(cursor.description): d[col[0]] = row[i] return d conn = sqlite3.connect(":memory:") conn.row_factory = dict_factory
Cursor महत्वपूर्ण कार्य
execute(sql[, parameters])एकल SQL कथन निष्पादित करता है। SQL स्टेटमेंट पैरामीट्रिज्ड हो सकता है (यानी एसक्यूएल शाब्दिक के बजाय प्लेसहोल्डर)। Sqlite3 मॉड्यूल दो प्रकार के प्लेसहोल्डर्स का समर्थन करता है: प्रश्न चिह्न
?("Qmark style") और नामित प्लेसहोल्डर:name("नामित शैली")।import sqlite3 conn = sqlite3.connect(":memory:") cur = conn.cursor() cur.execute("create table people (name, age)") who = "Sophia" age = 37 # This is the qmark style: cur.execute("insert into people values (?, ?)", (who, age)) # And this is the named style: cur.execute("select * from people where name=:who and age=:age", {"who": who, "age": age}) # the keys correspond to the placeholders in SQL print(cur.fetchone())
खबरदार: एसक्यूएल कमांड में तार डालने के लिए
%sउपयोग न करें क्योंकि यह आपके प्रोग्राम को SQL इंजेक्शन के हमले के लिए असुरक्षित बना सकता है (अन्य इंजेक्शन देखें)।
executemany(sql, seq_of_parameters)अनुक्रम sql में पाए जाने वाले सभी पैरामीटर अनुक्रमों या मैपिंग के खिलाफ एक SQL कमांड निष्पादित करता है। Sqlite3 मॉड्यूल एक अनुक्रम के बजाय एक इटैलर पैदावार मापदंडों का उपयोग करने की अनुमति देता है।
L = [(1, 'abcd', 'dfj', 300), # A list of tuples to be inserted into the database (2, 'cfgd', 'dyfj', 400), (3, 'sdd', 'dfjh', 300.50)] conn = sqlite3.connect("test1.db") conn.execute("create table if not exists book (id int, name text, author text, price real)") conn.executemany("insert into book values (?, ?, ?, ?)", L) for row in conn.execute("select * from book"): print(row)आप पुनरावृत्ति करने के लिए एक पैरामीटर के रूप में पुनरावृत्त वस्तुओं को भी पारित कर सकते हैं, और फ़ंक्शन पुनरावृत्त मानों के प्रत्येक टपल पर पुनरावृति करेगा। पुनरावृत्ति करने वाले को मानों का एक टपल वापस करना होगा।
import sqlite3 class IterChars: def __init__(self): self.count = ord('a') def __iter__(self): return self def __next__(self): # (use next(self) for Python 2) if self.count > ord('z'): raise StopIteration self.count += 1 return (chr(self.count - 1),) conn = sqlite3.connect("abc.db") cur = conn.cursor() cur.execute("create table characters(c)") theIter = IterChars() cur.executemany("insert into characters(c) values (?)", theIter) rows = cur.execute("select c from characters") for row in rows: print(row[0]),executescript(sql_script)यह एक बार में कई SQL कथनों को निष्पादित करने के लिए एक गैर-मानक सुविधा है। यह पहले एक
COMMITस्टेटमेंट जारी करता है, फिर SQL स्क्रिप्ट को एक पैरामीटर के रूप में निष्पादित करता है।sql_scriptstrयाbytesका एक उदाहरण हो सकता है।import sqlite3 conn = sqlite3.connect(":memory:") cur = conn.cursor() cur.executescript(""" create table person( firstname, lastname, age ); create table book( title, author, published ); insert into book(title, author, published) values ( 'Dirk Gently''s Holistic Detective Agency', 'Douglas Adams', 1987 ); """)कार्यों का अगला सेट SQL में
SELECTस्टेटमेंट के साथ संयोजन में उपयोग किया जाता है।SELECTस्टेटमेंट को निष्पादित करने के बाद डेटा को पुनः प्राप्त करने के लिए, आप या तो कर्सर कोfetchone()के रूप मेंfetchone()हैं, मेल खाने वाली पंक्तियों की सूची प्राप्त करने के लिए कर्सर कीfetchone()विधि को एकल मिलान पंक्ति को पुनः प्राप्त करने के लिए कह सकते हैं, याfetchall()कॉल कर सकते हैं।पुनरावृति फार्म का उदाहरण:
import sqlite3 stocks = [('2006-01-05', 'BUY', 'RHAT', 100, 35.14), ('2006-03-28', 'BUY', 'IBM', 1000, 45.0), ('2006-04-06', 'SELL', 'IBM', 500, 53.0), ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)] conn = sqlite3.connect(":memory:") conn.execute("create table stocks (date text, buysell text, symb text, amount int, price real)") conn.executemany("insert into stocks values (?, ?, ?, ?, ?)", stocks) cur = conn.cursor() for row in cur.execute('SELECT * FROM stocks ORDER BY price'): print(row) # Output: # ('2006-01-05', 'BUY', 'RHAT', 100, 35.14) # ('2006-03-28', 'BUY', 'IBM', 1000, 45.0) # ('2006-04-06', 'SELL', 'IBM', 500, 53.0) # ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)fetchone()किसी भी परिणाम के उपलब्ध नहीं होने पर, एक एकल अनुक्रम लौटाते हुए, या कोई नहीं, किसी क्वेरी परिणाम सेट की अगली पंक्ति प्राप्त करता है।
cur.execute('SELECT * FROM stocks ORDER BY price') i = cur.fetchone() while(i): print(i) i = cur.fetchone() # Output: # ('2006-01-05', 'BUY', 'RHAT', 100, 35.14) # ('2006-03-28', 'BUY', 'IBM', 1000, 45.0) # ('2006-04-06', 'SELL', 'IBM', 500, 53.0) # ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)fetchmany(size=cursor.arraysize)किसी क्वेरी परिणाम की पंक्तियों का अगला सेट (आकार द्वारा निर्दिष्ट), एक सूची लौटाता है। यदि आकार छोड़ दिया जाता है, तो एक पंक्ति में भ्रूण वापस आ जाता है। कोई और पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है।
cur.execute('SELECT * FROM stocks ORDER BY price') print(cur.fetchmany(2)) # Output: # [('2006-01-05', 'BUY', 'RHAT', 100, 35.14), ('2006-03-28', 'BUY', 'IBM', 1000, 45.0)]fetchall()किसी क्वेरी परिणाम की सभी (शेष) पंक्तियों को एक सूची में लौटाता है।
cur.execute('SELECT * FROM stocks ORDER BY price') print(cur.fetchall()) # Output: # [('2006-01-05', 'BUY', 'RHAT', 100, 35.14), ('2006-03-28', 'BUY', 'IBM', 1000, 45.0), ('2006-04-06', 'SELL', 'IBM', 500, 53.0), ('2006-04-05', 'BUY', 'MSFT', 1000, 72.0)]
SQLite और पायथन डेटा प्रकार
SQLite मूल रूप से निम्न प्रकारों का समर्थन करता है: NULL, INTEGER, REAL, TEXT, BLOB।
SQL से अजगर या इसके विपरीत चलते समय डेटा प्रकार परिवर्तित किए जाते हैं।
None <-> NULL
int <-> INTEGER/INT
float <-> REAL/FLOAT
str <-> TEXT/VARCHAR(n)
bytes <-> BLOB
Psgopg2 का उपयोग कर PostgreSQL डाटाबेस का उपयोग
psycopg2 सबसे लोकप्रिय PostgreSQL डेटाबेस एडाप्टर है जो हल्का और कुशल दोनों है। यह PostgreSQL एडॉप्टर का वर्तमान कार्यान्वयन है।
इसकी मुख्य विशेषताएं पायथन डीबी एपीआई 2.0 विनिर्देश का पूर्ण कार्यान्वयन और थ्रेड सुरक्षा (कई धागे एक ही कनेक्शन साझा कर सकते हैं) हैं
डेटाबेस से एक कनेक्शन स्थापित करना और एक टेबल बनाना
import psycopg2
# Establish a connection to the database.
# Replace parameter values with database credentials.
conn = psycopg2.connect(database="testpython",
user="postgres",
host="localhost",
password="abc123",
port="5432")
# Create a cursor. The cursor allows you to execute database queries.
cur = conn.cursor()
# Create a table. Initialise the table name, the column names and data type.
cur.execute("""CREATE TABLE FRUITS (
id INT ,
fruit_name TEXT,
color TEXT,
price REAL
)""")
conn.commit()
conn.close()
तालिका में डेटा सम्मिलित करना:
# After creating the table as shown above, insert values into it.
cur.execute("""INSERT INTO FRUITS (id, fruit_name, color, price)
VALUES (1, 'Apples', 'green', 1.00)""")
cur.execute("""INSERT INTO FRUITS (id, fruit_name, color, price)
VALUES (1, 'Bananas', 'yellow', 0.80)""")
प्राप्त तालिका डेटा:
# Set up a query and execute it
cur.execute("""SELECT id, fruit_name, color, price
FROM fruits""")
# Fetch the data
rows = cur.fetchall()
# Do stuff with the data
for row in rows:
print "ID = {} ".format(row[0])
print "FRUIT NAME = {}".format(row[1])
print("COLOR = {}".format(row[2]))
print("PRICE = {}".format(row[3]))
उपरोक्त का उत्पादन होगा:
ID = 1
NAME = Apples
COLOR = green
PRICE = 1.0
ID = 2
NAME = Bananas
COLOR = yellow
PRICE = 0.8
और इसलिए, आप वहां जाते हैं, आप अब psycopg2 के बारे में जानना चाहते हैं, जो आपको पता है! :)
Oracle डेटाबेस
पूर्व आवश्यक वस्तुएँ:
- cx_Oracle पैकेज - सभी संस्करणों के लिए यहां देखें
- ओरेकल इंस्टेंट क्लाइंट - विंडोज एक्स 64 , लिनक्स एक्स 64 के लिए
सेट अप:
के रूप में cx_Oracle पैकेज स्थापित करें:
sudo rpm -i <YOUR_PACKAGE_FILENAME>ओरेकल इंस्टेंट क्लाइंट निकालें और पर्यावरण चर सेट करें:
ORACLE_HOME=<PATH_TO_INSTANTCLIENT>
PATH=$ORACLE_HOME:$PATH
LD_LIBRARY_PATH=<PATH_TO_INSTANTCLIENT>:$LD_LIBRARY_PATH
एक कनेक्शन बनाना:
import cx_Oracle
class OraExec(object):
_db_connection = None
_db_cur = None
def __init__(self):
self._db_connection =
cx_Oracle.connect('<USERNAME>/<PASSWORD>@<HOSTNAME>:<PORT>/<SERVICE_NAME>')
self._db_cur = self._db_connection.cursor()
डेटाबेस संस्करण प्राप्त करें:
ver = con.version.split(".")
print ver
नमूना आउटपुट: ['12 ',' 1 ',' 0 ',' 2 ',' 0 ']
निष्पादित क्वेरी: का चयन करें
_db_cur.execute("select * from employees order by emp_id")
for result in _db_cur:
print result
पायथन टुपल्स में आउटपुट होगा:
(10, 'SYSADMIN', 'IT-INFRA', 7)
(23, 'एचआर एसोसिएट', 'मानव संसाधन', 6)
निष्पादित क्वेरी: INSERT
_db_cur.execute("insert into employees(emp_id, title, dept, grade)
values (31, 'MTS', 'ENGINEERING', 7)
_db_connection.commit()
जब आप ओरेकल डेटाबेस में इन्सर्ट / अपडेट / डिलीट ऑपरेशंस करते हैं, तो बदलाव केवल आपके सत्र के भीतर ही उपलब्ध होते हैं जब तक कि commit जारी नहीं किया जाता। जब अद्यतन डेटा डेटाबेस के लिए प्रतिबद्ध होता है, तो यह अन्य उपयोगकर्ताओं और सत्रों के लिए उपलब्ध होता है।
निष्पादन क्वेरी: Bind चर का उपयोग करके INSERT
बिंद चर आपको नए मूल्यों के साथ बयानों को फिर से निष्पादित करने में सक्षम करते हैं, बयान को फिर से भरने के बिना। बाइंड वैरिएबल कोड री-यूएबिलिटी में सुधार करते हैं, और SQL इंजेक्शन के हमलों के जोखिम को कम कर सकते हैं।
rows = [ (1, "First" ),
(2, "Second" ),
(3, "Third" ) ]
_db_cur.bindarraysize = 3
_db_cur.setinputsizes(int, 10)
_db_cur.executemany("insert into mytab(id, data) values (:1, :2)", rows)
_db_connection.commit()
निकट संबंध:
_db_connection.close()
बंद () विधि कनेक्शन को बंद कर देती है। स्क्रिप्ट समाप्त होने पर स्पष्ट रूप से बंद नहीं किए गए किसी भी कनेक्शन को स्वचालित रूप से जारी किया जाएगा।
संबंध
संबंध बनाना
PEP 249 के अनुसार, एक कनेक्शन connect() कंस्ट्रक्टर का उपयोग करके एक डेटाबेस से कनेक्शन स्थापित किया जाना चाहिए, जो एक Connection ऑब्जेक्ट लौटाता है। इस निर्माता के तर्क डेटाबेस पर निर्भर हैं। प्रासंगिक तर्कों के लिए डेटाबेस विशिष्ट विषयों का संदर्भ लें।
import MyDBAPI
con = MyDBAPI.connect(*database_dependent_args)
इस कनेक्शन ऑब्जेक्ट में चार विधियाँ हैं:
1: करीब
con.close()
तुरंत कनेक्शन बंद कर देता है। ध्यान दें कि यदि Connection.__del___ विधि कहलाता है तो कनेक्शन स्वतः बंद हो जाता है। किसी भी लंबित लेनदेन को संक्षेप में वापस ले लिया जाएगा।
2: प्रतिबद्ध
con.commit()
किसी भी लंबित लेनदेन को डेटाबेस में भेजता है।
3: रोलबैक
con.rollback()
किसी भी लंबित लेन-देन की शुरुआत में रोल। दूसरे शब्दों में: यह किसी भी गैर-प्रतिबद्ध लेनदेन को डेटाबेस में रद्द कर देता है।
4: कर्सर
cur = con.cursor()
एक Cursor वस्तु लौटाता है। इसका उपयोग डेटाबेस पर लेनदेन करने के लिए किया जाता है।
Sqlalchemy का उपयोग करना
डेटाबेस के लिए sqlalchemy का उपयोग करने के लिए:
from sqlalchemy import create_engine
from sqlalchemy.engine.url import URL
url = URL(drivername='mysql',
username='user',
password='passwd',
host='host',
database='db')
engine = create_engine(url) # sqlalchemy engine
अब इस इंजन का उपयोग किया जा सकता है: उदाहरण के लिए माण्ड्स से सीधे डेटाफ्रेम लाने के लिए पांडा के साथ
import pandas as pd
con = engine.connect()
dataframe = pd.read_sql(sql=query, con=con)
