Python 3.7

sqlite3 - SQLite डेटाबेस के लिए DB-API 2.0 इंटरफ़ेस




python

sqlite3 - SQLite डेटाबेस के लिए DB-API 2.0 इंटरफ़ेस

स्रोत कोड: Lib/sqlite3/

SQLite एक C लाइब्रेरी है जो एक लाइटवेट डिस्क-आधारित डेटाबेस प्रदान करती है, जिसे अलग सर्वर प्रक्रिया की आवश्यकता नहीं होती है और SQL क्वेरी भाषा के एक गैरमानक प्रकार का उपयोग करके डेटाबेस तक पहुँचने की अनुमति देता है। कुछ एप्लिकेशन आंतरिक डेटा भंडारण के लिए SQLite का उपयोग कर सकते हैं। SQLite का उपयोग करके किसी एप्लिकेशन को प्रोटोटाइप करना भी संभव है और फिर कोड को किसी बड़े डेटाबेस जैसे PostgreSQL या Oracle में पोर्ट करना संभव है।

Sqlite3 मॉड्यूल को गेरहार्ड हैरिंग ने लिखा था। यह PEP 249 द्वारा वर्णित DB-API 2.0 विनिर्देश के साथ एक SQL इंटरफ़ेस अनुपालन प्रदान करता है।

मॉड्यूल का उपयोग करने के लिए, आपको पहले एक Connection ऑब्जेक्ट बनाना होगा जो डेटाबेस का प्रतिनिधित्व करता है। यहां डेटा को example.db फ़ाइल में संग्रहीत किया जाएगा:

import sqlite3
conn = sqlite3.connect('example.db')

आप रैम में डेटाबेस बनाने के लिए विशेष नाम :memory: की भी आपूर्ति कर सकते हैं।

एक बार आपके पास एक Connection , आप एक Cursor ऑब्जेक्ट बना सकते हैं और SQL कमांड्स को निष्पादित करने के लिए इसके 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()

आपके द्वारा सहेजा गया डेटा लगातार है और बाद के सत्रों में उपलब्ध है:

import sqlite3
conn = sqlite3.connect('example.db')
c = conn.cursor()

आमतौर पर आपके SQL संचालन को पायथन वेरिएबल्स के मानों का उपयोग करने की आवश्यकता होगी। आपको अजगर के स्ट्रिंग ऑपरेशन का उपयोग करके अपनी क्वेरी को इकट्ठा नहीं करना चाहिए क्योंकि ऐसा करना असुरक्षित है; यह आपके प्रोग्राम को SQL इंजेक्शन के हमले के प्रति संवेदनशील बनाता है (जो गलत हो सकता है उसका हास्य उदाहरण के लिए https://xkcd.com/327/ देखें)।

इसके बजाय, DB-API के पैरामीटर प्रतिस्थापन का उपयोग करें। डाल दिया ? एक प्लेसहोल्डर के रूप में जहां भी आप एक मूल्य का उपयोग करना चाहते हैं, और फिर कर्सर के execute() विधि के लिए दूसरे तर्क के रूप में मूल्यों का एक टपल प्रदान करते हैं। (अन्य डेटाबेस मॉड्यूल %s या :1 जैसे अलग प्लेसहोल्डर का उपयोग कर सकते हैं।) उदाहरण के लिए:

# Never do this -- insecure!
symbol = 'RHAT'
c.execute("SELECT * FROM stocks WHERE symbol = '%s'" % symbol)

# Do this instead
t = ('RHAT',)
c.execute('SELECT * FROM stocks WHERE symbol=?', t)
print(c.fetchone())

# Larger example that inserts many records at a time
purchases = [('2006-03-28', 'BUY', 'IBM', 1000, 45.00),
             ('2006-04-05', 'BUY', 'MSFT', 1000, 72.00),
             ('2006-04-06', 'SELL', 'IBM', 500, 53.00),
            ]
c.executemany('INSERT INTO stocks VALUES (?,?,?,?,?)', purchases)

fetchone() स्टेटमेंट को निष्पादित करने के बाद डेटा को पुनः प्राप्त करने के लिए, आप या तो कर्सर को fetchone() के रूप में fetchone() हैं, मेल खाने वाली पंक्तियों की एक सूची प्राप्त करने के लिए कर्सर की fetchone() विधि को एकल मिलान पंक्ति को पुनः प्राप्त करने के लिए कह सकते हैं, या कॉल कर सकते हैं।

यह उदाहरण पुनरावृत्ति प्रपत्र का उपयोग करता है:

>>> for row in c.execute('SELECT * FROM stocks ORDER BY price'):
        print(row)

('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)

यह भी देखें

https://github.com/ghaering/pysqlite
Pysqlite वेब पेज - sqlite3 को "pysqlite" नाम से बाहरी रूप से विकसित किया गया है।
https://www.sqlite.org
SQLite वेब पेज; प्रलेखन सिंटैक्स और समर्थित SQL बोली के लिए उपलब्ध डेटा प्रकारों का वर्णन करता है।
https://www.w3schools.com/sql/
SQL सिंटैक्स सीखने के लिए ट्यूटोरियल, संदर्भ और उदाहरण।
PEP 249 - डेटाबेस एपीआई विनिर्देश 2.0
पीईपी मार्क-आंद्रे लिम्बर्ग द्वारा लिखित।

मॉड्यूल कार्यों और स्थिरांक

sqlite3.version

एक स्ट्रिंग के रूप में इस मॉड्यूल की संस्करण संख्या। यह SQLite लाइब्रेरी का संस्करण नहीं है।

sqlite3.version_info

पूर्णांक के टपल के रूप में इस मॉड्यूल की संस्करण संख्या। यह SQLite लाइब्रेरी का संस्करण नहीं है।

sqlite3.sqlite_version

एक स्ट्रिंग के रूप में रन-टाइम SQLite लाइब्रेरी का संस्करण संख्या।

sqlite3.sqlite_version_info

पूर्णांक के ट्यूपल के रूप में रन-टाइम SQLite लाइब्रेरी का संस्करण संख्या।

sqlite3.PARSE_DECLTYPES

इस स्थिरांक का उपयोग connect() फ़ंक्शन के डिटे_टाइप्स पैरामीटर के साथ किया जाना है।

इसे सेट करना sqlite3 मॉड्यूल को प्रत्येक कॉलम के लिए घोषित प्रकार को पार्स करता है। यह घोषित प्रकार के पहले शब्द को बाहर करेगा, अर्थात "पूर्णांक प्राथमिक कुंजी" के लिए, यह "पूर्णांक", या "संख्या (10)" के लिए इसे "संख्या" के रूप में बताएगा। फिर उस कॉलम के लिए, यह कन्वर्टर्स डिक्शनरी में दिखेगा और उस प्रकार के लिए पंजीकृत कन्वर्टर फंक्शन का उपयोग करेगा।

sqlite3.PARSE_COLNAMES

इस स्थिरांक का उपयोग connect() फ़ंक्शन के डिटे_टाइप्स पैरामीटर के साथ किया जाना है।

इसे सेट करने से SQLite इंटरफ़ेस स्तंभ के प्रत्येक स्तंभ के नाम को लौटा देता है। यह वहां बने [mytype] स्ट्रिंग की तलाश करेगा, और फिर तय करेगा कि 'mytype' कॉलम का प्रकार है। यह कन्वर्टर्स डिक्शनरी में 'mytype' की प्रविष्टि खोजने की कोशिश करेगा और फिर वैल्यू वापस करने के लिए वहां पाए गए कनवर्टर फंक्शन का उपयोग करेगा। Cursor.description में पाया जाने Cursor.description कॉलम नाम कॉलम नाम का पहला शब्द है, यानी यदि आप अपनी SQL में 'as "x [datetime]"' Cursor.description 'as "x [datetime]"' जैसी किसी चीज़ का उपयोग करते हैं, तो हम कॉलम के लिए पहला रिक्त होने तक सब कुछ पार्स कर देंगे। नाम: कॉलम का नाम बस "x" होगा।

sqlite3.connect(database[, timeout, detect_types, isolation_level, check_same_thread, factory, cached_statements, uri])

SQLite डेटाबेस फ़ाइल डेटाबेस के लिए एक कनेक्शन खोलता है। डिफ़ॉल्ट रूप से एक Connection ऑब्जेक्ट देता है, जब तक कि एक कस्टम कारखाना नहीं दिया जाता है।

डेटाबेस एक पथ जैसा ऑब्जेक्ट होता है, जिसे खोलने के लिए डेटाबेस फ़ाइल का pathname (वर्तमान वर्किंग डायरेक्टरी के पूर्ण या सापेक्ष) दिया जाता है। आप एक डेटाबेस से डेटाबेस कनेक्शन खोलने के लिए ":memory:" का उपयोग कर सकते हैं जो डिस्क पर ऑन करने के बजाय रैम में रहता है।

जब एक डेटाबेस कई कनेक्शनों द्वारा एक्सेस किया जाता है, और एक प्रक्रिया डेटाबेस को संशोधित करती है, तो SQLite डेटाबेस को तब तक लॉक किया जाता है जब तक कि लेनदेन नहीं हो जाता। टाइमआउट पैरामीटर निर्दिष्ट करता है कि एक अपवाद को बढ़ाने तक कनेक्शन को लॉक के दूर जाने के लिए कितनी देर तक इंतजार करना चाहिए। टाइमआउट पैरामीटर के लिए डिफ़ॉल्ट 5.0 (पांच सेकंड) है।

आइसोलेशन_लेवल पैरामीटर के लिए, कृपया Connection ऑब्जेक्ट्स की isolation_level संपत्ति देखें।

SQLite केवल मूल रूप से TEXT, INTEGER, REAL, BLOB और NULL का समर्थन करता है। यदि आप अन्य प्रकारों का उपयोग करना चाहते हैं, तो आपको स्वयं उनके लिए समर्थन जोड़ना होगा। Det_types पैरामीटर और मॉड्यूल-स्तर register_converter() फ़ंक्शन के साथ पंजीकृत कस्टम कन्वर्टर्स का उपयोग करके आप आसानी से ऐसा कर सकते हैं।

डिटेक्ट_टाइप्स डिफॉल्ट टू 0 (यानी ऑफ, नो टाइप डिटेक्शन), आप इसे टाइप डिटेक्शन को चालू करने के लिए PARSE_DECLTYPES और PARSE_COLNAMES किसी भी संयोजन में सेट कर सकते हैं।

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

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

विवरण के लिए इस मैनुअल के अनुभाग SQLite और पायथन प्रकार से परामर्श करें।

sqlite3 ओवरहेड से बचने के लिए sqlite3 मॉड्यूल आंतरिक रूप से स्टेटमेंट कैश का उपयोग करता है। यदि आप स्पष्ट रूप से कनेक्शन के लिए कैश की गई स्टेटमेंट की संख्या सेट करना चाहते हैं, तो आप कैश्ड_स्टैटेमेंट पैरामीटर सेट कर सकते हैं। वर्तमान में कार्यान्वित डिफ़ॉल्ट 100 स्टेटमेंट को कैश करना है।

यदि uri सत्य है, तो डेटाबेस को URI के रूप में व्याख्या किया जाता है। यह आपको विकल्प निर्दिष्ट करने की अनुमति देता है। उदाहरण के लिए, केवल-पढ़ने के लिए मोड में एक डेटाबेस खोलने के लिए आप इसका उपयोग कर सकते हैं:

db = sqlite3.connect('file:path/to/database?mode=ro', uri=True)

इस सुविधा के बारे में अधिक जानकारी, मान्यता प्राप्त विकल्पों की सूची सहित, SQLite URI प्रलेखन में पाई जा सकती है।

संस्करण ४.४ में परिवर्तित: उरी पैरामीटर जोड़ा गया।

संस्करण 3.7 में परिवर्तित: डेटाबेस अब एक पथ जैसा ऑब्जेक्ट भी हो सकता है, न केवल एक स्ट्रिंग।

sqlite3.register_converter(typename, callable)

डेटाबेस से बाइटस्ट्रिंग को कस्टम पायथन प्रकार में बदलने के लिए एक कॉल करने योग्य बनाता है। कॉल करने योग्य सभी डेटाबेस मानों के लिए लागू किया जाएगा जो टाइप टाइपनेम के होते हैं । प्रकार का पता लगाने के कार्य के लिए connect() फ़ंक्शन के पैरामीटर detect_types को देखें। ध्यान दें कि टाइपिंगनाम और आपकी क्वेरी के प्रकार का नाम केस-असंवेदनशील तरीके से मेल खाता है।

sqlite3.register_adapter(type, callable)

कस्टम पायथन प्रकार प्रकार को SQLite के समर्थित प्रकारों में से एक में बदलने के लिए एक कॉल करने योग्य बनाता है। कॉल करने योग्य कॉल करने योग्य एकल पैरामीटर को पायथन मान के रूप में स्वीकार करता है, और निम्न प्रकारों का मान वापस करना चाहिए: int, float, str या बाइट्स।

sqlite3.complete_statement(sql)

यदि स्ट्रिंग sql में एक या अधिक पूर्ण SQL कथन अर्धविराम द्वारा समाप्त किए गए हैं, तो सही है। यह सत्यापित नहीं करता है कि SQL सिंटैक्टिक रूप से सही है, केवल यह कि कोई अशुद्ध स्ट्रिंग शाब्दिक नहीं हैं और स्टेटमेंट अर्धविराम द्वारा समाप्त हो गया है।

निम्न उदाहरण में SQLite के लिए एक शेल बनाने के लिए इसका उपयोग किया जा सकता है:

# A minimal SQLite shell for experiments

import sqlite3

con = sqlite3.connect(":memory:")
con.isolation_level = None
cur = con.cursor()

buffer = ""

print("Enter your SQL commands to execute in sqlite3.")
print("Enter a blank line to exit.")

while True:
    line = input()
    if line == "":
        break
    buffer += line
    if sqlite3.complete_statement(buffer):
        try:
            buffer = buffer.strip()
            cur.execute(buffer)

            if buffer.lstrip().upper().startswith("SELECT"):
                print(cur.fetchall())
        except sqlite3.Error as e:
            print("An error occurred:", e.args[0])
        buffer = ""

con.close()
sqlite3.enable_callback_tracebacks(flag)

डिफ़ॉल्ट रूप से आपको उपयोगकर्ता-परिभाषित फ़ंक्शन, एग्रीगेट, कन्वर्टर्स, ऑथराइज़र कॉलबैक आदि में कोई ट्रेसबैक नहीं मिलेगा। यदि आप उन्हें डीबग करना चाहते हैं, तो आप इस फ़ंक्शन को फ़्लैग सेट से True कॉल कर सकते हैं। बाद में, आप sys.stderr पर कॉलबैक से ट्रेसबैक प्राप्त करेंगे। सुविधा को फिर से अक्षम करने के लिए False का उपयोग करें।

कनेक्शन ऑब्जेक्ट

class sqlite3.Connection

SQLite डेटाबेस कनेक्शन में निम्नलिखित विशेषताएँ और विधियाँ हैं:

isolation_level

वर्तमान डिफ़ॉल्ट अलगाव स्तर प्राप्त करें या सेट करें। ऑटोकॉमिट मोड या "DEFERRED", "IMMEDIATE" या "EXCLUSIVE" में से कोई भी नहीं। अधिक विस्तृत विवरण के लिए अनुभाग नियंत्रित लेनदेन देखें।

in_transaction

True कि यदि कोई लेन-देन सक्रिय है (अनपेक्षित परिवर्तन हैं), अन्यथा False । पढ़ें- केवल विशेषता

संस्करण 3.2 में नया।

cursor(factory=Cursor)

कर्सर विधि एकल वैकल्पिक पैरामीटर कारखाने को स्वीकार करती है। यदि आपूर्ति की जाती है, तो यह एक कॉल करने योग्य होना चाहिए जो कि Cursor या उसके उपवर्गों का एक उदाहरण है।

commit()

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

rollback()

यह विधि अंतिम कॉल करने के बाद से डेटाबेस में किसी भी परिवर्तन को वापस लाती है।

close()

यह डेटाबेस कनेक्शन बंद कर देता है। ध्यान दें कि यह स्वचालित रूप से commit() नहीं कहता है। यदि आप पहले कॉलिंग commit() बिना अपने डेटाबेस कनेक्शन को बंद करते हैं, तो आपके परिवर्तन खो जाएंगे!

execute(sql[, parameters])

यह एक अमानक शॉर्टकट है जो cursor() विधि को कॉल करके एक कर्सर ऑब्जेक्ट बनाता है, कर्सर के execute() विधि को दिए गए मापदंडों के साथ कॉल करता है, और कर्सर लौटाता है।

executemany(sql[, parameters])

यह एक अमानक शॉर्टकट है जो cursor() विधि को कॉल करके एक ऑब्जेक्ट बनाता है, दिए गए मापदंडों के साथ कर्सर के executemany() विधि को कॉल करता है, और कर्सर को लौटाता है।

executescript(sql_script)

यह एक अमानक शॉर्टकट है जो cursor() विधि को कॉल करके एक कर्सर ऑब्जेक्ट बनाता है, दिए गए sql_script के साथ कर्सर के निष्पादन cursor() विधि को कॉल executescript() , और कर्सर लौटाता है।

create_function(name, num_params, func)

एक उपयोगकर्ता-परिभाषित फ़ंक्शन बनाता है जिसे आप बाद में फ़ंक्शन नाम के तहत SQL कथनों के भीतर से उपयोग कर सकते हैं। num_params फ़ंक्शन को स्वीकार करने वाले मापदंडों की संख्या है (यदि num_params -1 है, तो फ़ंक्शन किसी भी संख्या में तर्क ले सकता है), और func एक Python callable है जिसे SQL फ़ंक्शन कहा जाता है।

फ़ंक्शन SQLite द्वारा समर्थित किसी भी प्रकार को वापस कर सकता है: बाइट्स, स्ट्र, इंट, फ्लोट और None

उदाहरण:

import sqlite3
import hashlib

def md5sum(t):
    return hashlib.md5(t).hexdigest()

con = sqlite3.connect(":memory:")
con.create_function("md5", 1, md5sum)
cur = con.cursor()
cur.execute("select md5(?)", (b"foo",))
print(cur.fetchone()[0])
create_aggregate(name, num_params, aggregate_class)

एक उपयोगकर्ता-परिभाषित कुल फ़ंक्शन बनाता है।

कुल वर्ग को एक step विधि लागू करनी चाहिए, जो कि संख्या के मान को सुन्न करता है num_params (यदि num_params -1 है, तो फ़ंक्शन किसी भी संख्या में तर्क ले सकता है), और एक finalize विधि जो समुच्चय के अंतिम परिणाम को लौटाएगी।

finalize विधि SQLite द्वारा समर्थित किसी भी प्रकार को वापस कर सकती है: बाइट्स, स्ट्र, इंट, फ्लोट और None

उदाहरण:

import sqlite3

class MySum:
    def __init__(self):
        self.count = 0

    def step(self, value):
        self.count += value

    def finalize(self):
        return self.count

con = sqlite3.connect(":memory:")
con.create_aggregate("mysum", 1, MySum)
cur = con.cursor()
cur.execute("create table test(i)")
cur.execute("insert into test(i) values (1)")
cur.execute("insert into test(i) values (2)")
cur.execute("select mysum(i) from test")
print(cur.fetchone()[0])
create_collation(name, callable)

निर्दिष्ट नाम और कॉल करने योग्य के साथ एक संयोजन बनाता है। कॉल करने योग्य दो स्ट्रिंग तर्क पारित किए जाएंगे। यह -1 वापस आ जाना चाहिए यदि पहले को दूसरे से कम ऑर्डर किया गया है, 0 अगर उन्हें बराबर का ऑर्डर दिया गया है और 1 को अगर दूसरे से ज्यादा ऑर्डर किया गया है। ध्यान दें कि यह नियंत्रण (ORDER BY SQL में) को नियंत्रित करता है ताकि आपकी तुलना अन्य SQL संचालन को प्रभावित न करें।

ध्यान दें कि कॉल करने योग्य को इसके पैरामीटर पायथन बाईस्ट्रेस के रूप में मिलेंगे, जो आमतौर पर UTF-8 में एन्कोड किया जाएगा।

निम्न उदाहरण एक कस्टम कोलाज दिखाता है जो "गलत तरीके" को हल करता है:

import sqlite3

def collate_reverse(string1, string2):
    if string1 == string2:
        return 0
    elif string1 < string2:
        return 1
    else:
        return -1

con = sqlite3.connect(":memory:")
con.create_collation("reverse", collate_reverse)

cur = con.cursor()
cur.execute("create table test(x)")
cur.executemany("insert into test(x) values (?)", [("a",), ("b",)])
cur.execute("select x from test order by x collate reverse")
for row in cur:
    print(row)
con.close()

create_collation को हटाने के लिए, create_collation को कॉल create_collation None रूप में:

con.create_collation("reverse", None)
interrupt()

आप कनेक्शन पर निष्पादित होने वाले किसी भी प्रश्न को निरस्त करने के लिए एक अलग थ्रेड से इस विधि को कॉल कर सकते हैं। क्वेरी तब गर्भपात करेगी और कॉलर को एक अपवाद मिलेगा।

set_authorizer(authorizer_callback)

यह दिनचर्या कॉलबैक पंजीकृत करती है। डेटाबेस में एक तालिका के एक स्तंभ तक पहुंचने के प्रत्येक प्रयास के लिए कॉलबैक आमंत्रित किया गया है। कॉलबैक SQLITE_OK लौटना चाहिए यदि एक्सेस की अनुमति दी जाती है, तो SQLITE_OK यदि संपूर्ण SQL स्टेटमेंट को एक एरर और SQLITE_IGNORE साथ निरस्त किया SQLITE_IGNORE यदि कॉलम को NULL मान माना जाए। ये स्थिरांक sqlite3 मॉड्यूल में उपलब्ध हैं।

कॉलबैक के लिए पहला तर्क दर्शाता है कि किस तरह के ऑपरेशन को अधिकृत किया जाना है। दूसरा और तीसरा तर्क पहले तर्क के आधार पर तर्क या None होगा। 4 वाँ तर्क डेटाबेस का नाम है ("मुख्य", "अस्थायी", आदि) यदि लागू हो। 5 वाँ तर्क इनर-मोस्ट ट्रिगर या व्यू का नाम है जो एक्सेस प्रयास के लिए ज़िम्मेदार है या None अगर यह एक्सेस प्रयास सीधे SQL कोड से होता है।

कृपया पहले तर्क और पहले के आधार पर दूसरे और तीसरे तर्क के अर्थ के लिए संभावित मानों के बारे में SQLite प्रलेखन से परामर्श करें। सभी आवश्यक स्थिरांक sqlite3 मॉड्यूल में उपलब्ध हैं।

set_progress_handler(handler, n)

यह दिनचर्या कॉलबैक पंजीकृत करती है। कॉलबैक SQLite वर्चुअल मशीन के हर एन निर्देशों के लिए मंगवाया गया है। यदि आप लंबे समय से चल रहे संचालन के दौरान SQLite से कॉल करना चाहते हैं, तो यह उपयोगी है, उदाहरण के लिए GUI को अपडेट करने के लिए।

यदि आप पहले से इंस्टॉल किए गए प्रगति हैंडलर को खाली करना चाहते हैं, तो हैंडलर के लिए None के साथ विधि को कॉल करें।

हैंडलर फ़ंक्शन से एक गैर-शून्य मान लौटना वर्तमान में निष्पादित क्वेरी को समाप्त कर देगा और इसे OperationalError अपवाद को बढ़ाने के लिए पैदा करेगा।

set_trace_callback(trace_callback)

प्रत्येक SQL कथन जो वास्तव में SQLite बैकएंड द्वारा निष्पादित किया जाता है, के लिए ट्रेस_ कॉलबैक पंजीकृत करता है।

कॉलबैक के लिए दिया गया एकमात्र तर्क स्टेटमेंट (स्ट्रिंग के रूप में) है जिसे निष्पादित किया जा रहा है। कॉलबैक का रिटर्न मान अनदेखा किया जाता है। ध्यान दें कि बैकएंड केवल execute() विधियों के लिए दिए गए स्टेटमेंट को नहीं चलाता है। अन्य स्रोतों में पायथन मॉड्यूल के लेनदेन प्रबंधन और वर्तमान डेटाबेस में परिभाषित ट्रिगर्स का निष्पादन शामिल है।

ट्रेस_ कॉलबैक के रूप में None को None पास करना ट्रेस कॉलबैक को अक्षम करेगा।

संस्करण 3.3 में नया।

enable_load_extension(enabled)

यह दिनचर्या साझा पुस्तकालयों से SQLite एक्सटेंशन लोड करने के लिए SQLite इंजन को अनुमति / अस्वीकार करता है। SQLite एक्सटेंशन नए फ़ंक्शन, समुच्चय या पूरे नए वर्चुअल टेबल कार्यान्वयन को परिभाषित कर सकते हैं। एक प्रसिद्ध एक्सटेंशन SQLite के साथ वितरित पूर्ण-खोज एक्सटेंशन है।

लोड करने योग्य एक्सटेंशन डिफ़ॉल्ट रूप से अक्षम हैं। देखें [1]

संस्करण 3.2 में नया।

import sqlite3

con = sqlite3.connect(":memory:")

# enable extension loading
con.enable_load_extension(True)

# Load the fulltext search extension
con.execute("select load_extension('./fts3.so')")

# alternatively you can load the extension using an API call:
# con.load_extension("./fts3.so")

# disable extension loading again
con.enable_load_extension(False)

# example from SQLite wiki
con.execute("create virtual table recipe using fts3(name, ingredients)")
con.executescript("""
    insert into recipe (name, ingredients) values ('broccoli stew', 'broccoli peppers cheese tomatoes');
    insert into recipe (name, ingredients) values ('pumpkin stew', 'pumpkin onions garlic celery');
    insert into recipe (name, ingredients) values ('broccoli pie', 'broccoli cheese onions flour');
    insert into recipe (name, ingredients) values ('pumpkin pie', 'pumpkin sugar flour butter');
    """)
for row in con.execute("select rowid, name, ingredients from recipe where name match 'pie'"):
    print(row)
load_extension(path)

यह दिनचर्या साझा लाइब्रेरी से SQLite एक्सटेंशन को लोड करती है। इससे पहले कि आप इस दिनचर्या का उपयोग कर सकें, आपको enable_load_extension() साथ एक्सटेंशन लोडिंग को सक्षम करना होगा।

लोड करने योग्य एक्सटेंशन डिफ़ॉल्ट रूप से अक्षम हैं। देखें [1]

संस्करण 3.2 में नया।

row_factory

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

उदाहरण:

import sqlite3

def dict_factory(cursor, row):
    d = {}
    for idx, col in enumerate(cursor.description):
        d[col[0]] = row[idx]
    return d

con = sqlite3.connect(":memory:")
con.row_factory = dict_factory
cur = con.cursor()
cur.execute("select 1 as a")
print(cur.fetchone()["a"])

यदि टपल लौटना पर्याप्त नहीं है और आप स्तंभों के लिए नाम-आधारित पहुँच चाहते हैं, तो आपको अत्यधिक अनुकूलित sqlite3.Row प्रकार के लिए row_factory सेट करने पर विचार करना चाहिए। sqlite3.Row लगभग बिना मेमोरी ओवरहेड वाले स्तंभों के लिए अनुक्रमणिका-आधारित और केस-असंवेदनशील नाम-आधारित पहुँच प्रदान करता है। यह संभवतः आपके स्वयं के कस्टम शब्दकोश-आधारित दृष्टिकोण या यहां तक ​​कि db_row आधारित समाधान से बेहतर होगा।

text_factory

इस विशेषता का उपयोग करके आप यह नियंत्रित कर सकते हैं कि TEXT डेटा प्रकार के लिए कौन सी वस्तुएं लौटा दी गई हैं। डिफ़ॉल्ट रूप से, यह विशेषता str सेट है और sqlite3 मॉड्यूल TEXT लिए यूनिकोड ऑब्जेक्ट लौटाएगा। यदि आप इसके बजाय बाइटस्ट्रेस वापस करना चाहते हैं, तो आप इसे bytes सेट कर सकते हैं।

आप इसे किसी अन्य कॉल करने योग्य के लिए भी सेट कर सकते हैं जो एकल बायट्रैस्टिंग पैरामीटर को स्वीकार करता है और परिणामी वस्तु को वापस करता है।

चित्रण के लिए निम्न उदाहरण कोड देखें:

import sqlite3

con = sqlite3.connect(":memory:")
cur = con.cursor()

AUSTRIA = "\xd6sterreich"

# by default, rows are returned as Unicode
cur.execute("select ?", (AUSTRIA,))
row = cur.fetchone()
assert row[0] == AUSTRIA

# but we can make sqlite3 always return bytestrings ...
con.text_factory = bytes
cur.execute("select ?", (AUSTRIA,))
row = cur.fetchone()
assert type(row[0]) is bytes
# the bytestrings will be encoded in UTF-8, unless you stored garbage in the
# database ...
assert row[0] == AUSTRIA.encode("utf-8")

# we can also implement a custom text_factory ...
# here we implement one that appends "foo" to all strings
con.text_factory = lambda x: x.decode("utf-8") + "foo"
cur.execute("select ?", ("bar",))
row = cur.fetchone()
assert row[0] == "barfoo"
total_changes

डेटाबेस कनेक्शन खोले जाने के बाद, संशोधित, डाली गई या हटाई गई डेटाबेस पंक्तियों की कुल संख्या लौटाता है।

iterdump()

SQL पाठ प्रारूप में डेटाबेस को डंप करने के लिए एक पुनरावृत्ति देता है। बाद में बहाली के लिए एक इन-मेमोरी डेटाबेस को बचाने के लिए उपयोगी है। यह फ़ंक्शन sqlite3 शेल में .dump कमांड के समान क्षमता प्रदान करता है।

उदाहरण:

# Convert file existing_db.db to SQL dump file dump.sql
import sqlite3

con = sqlite3.connect('existing_db.db')
with open('dump.sql', 'w') as f:
    for line in con.iterdump():
        f.write('%s\n' % line)
backup(target, *, pages=0, progress=None, name="main", sleep=0.250)

यह विधि SQLite डेटाबेस का बैकअप तब भी बनाती है, जब वह अन्य ग्राहकों द्वारा एक्सेस किया जा रहा हो, या समवर्ती रूप से उसी कनेक्शन द्वारा। प्रतिलिपि को अनिवार्य तर्क लक्ष्य में लिखा जाएगा, जो कि एक और Connection उदाहरण होना चाहिए।

डिफ़ॉल्ट रूप से, या जब पृष्ठ 0 या एक नकारात्मक पूर्णांक होते हैं, तो संपूर्ण डेटाबेस को एक ही चरण में कॉपी किया जाता है; अन्यथा विधि एक बार में पृष्ठों को पृष्ठों पर कॉपी करने वाला लूप निष्पादित करती है।

यदि प्रगति निर्दिष्ट की जाती है, तो यह या तो None होनी चाहिए या एक कॉल करने योग्य ऑब्जेक्ट जिसे प्रत्येक पूर्णांक पर तीन पूर्णांक तर्कों के साथ निष्पादित किया जाएगा, क्रमशः अंतिम पुनरावृत्ति की स्थिति , शेष पृष्ठों की प्रतिलिपि अभी भी और पृष्ठों की कुल संख्या।

नाम तर्क डेटाबेस का नाम निर्दिष्ट करता है जिसे कॉपी किया जाएगा: यह एक स्ट्रिंग होना चाहिए जिसमें "main" , डिफ़ॉल्ट हो, मुख्य डेटाबेस को इंगित करने के लिए हो, अस्थायी डेटाबेस को इंगित करने के लिए "temp" या AS कीवर्ड के बाद निर्दिष्ट नाम ATTACH DATABASE लिए ATTACH DATABASE कथन।

नींद का तर्क बैकअप के शेष पृष्ठों के बीच सोने की सेकंड की संख्या को निर्दिष्ट करता है, इसे पूर्णांक या फ्लोटिंग पॉइंट मान के रूप में निर्दिष्ट किया जा सकता है।

उदाहरण 1, मौजूदा डेटाबेस को दूसरे में कॉपी करें:

import sqlite3

def progress(status, remaining, total):
    print(f'Copied {total-remaining} of {total} pages...')

con = sqlite3.connect('existing_db.db')
with sqlite3.connect('backup.db') as bck:
    con.backup(bck, pages=1, progress=progress)

उदाहरण 2, एक मौजूदा डेटाबेस को एक क्षणिक प्रतिलिपि में कॉपी करें:

import sqlite3

source = sqlite3.connect('existing_db.db')
dest = sqlite3.connect(':memory:')
source.backup(dest)

उपलब्धता: SQLite 3.6.11 या उच्चतर

संस्करण 3.7 में नया।

कर्सर वस्तुओं

class sqlite3.Cursor

एक Cursor उदाहरण में निम्नलिखित विशेषताएँ और विधियाँ हैं।

execute(sql[, parameters])

SQL कथन निष्पादित करता है। SQL स्टेटमेंट को पैरामीटरेट किया जा सकता है (यानी SQL लीटर के बजाय प्लेसहोल्डर)। sqlite3 मॉड्यूल दो प्रकार के प्लेसहोल्डर्स का समर्थन करता है: प्रश्न चिह्न (qmark स्टाइल) और नामित प्लेसहोल्डर (नाम शैली)।

यहाँ दोनों शैलियों का एक उदाहरण दिया गया है:

import sqlite3

con = sqlite3.connect(":memory:")
cur = con.cursor()
cur.execute("create table people (name_last, age)")

who = "Yeltsin"
age = 72

# 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_last=:who and age=:age", {"who": who, "age": age})

print(cur.fetchone())

execute() केवल एक SQL कथन निष्पादित करेगा। यदि आप इसके साथ एक से अधिक कथन निष्पादित करने का प्रयास करते हैं, तो यह एक Warning को बढ़ाएगा। यदि आप एक कॉल के साथ कई SQL स्टेटमेंट्स निष्पादित करना चाहते हैं, तो executescript() उपयोग करें।

executemany(sql, seq_of_parameters)

अनुक्रम seq_of_parameters में पाए गए सभी पैरामीटर अनुक्रमों या मैपिंग के खिलाफ एक SQL कमांड निष्पादित करता है। sqlite3 मॉड्यूल एक अनुक्रम के बजाय एक iterator उपज मापदंडों का उपयोग करने की अनुमति देता है।

import sqlite3

class IterChars:
    def __init__(self):
        self.count = ord('a')

    def __iter__(self):
        return self

    def __next__(self):
        if self.count > ord('z'):
            raise StopIteration
        self.count += 1
        return (chr(self.count - 1),) # this is a 1-tuple

con = sqlite3.connect(":memory:")
cur = con.cursor()
cur.execute("create table characters(c)")

theIter = IterChars()
cur.executemany("insert into characters(c) values (?)", theIter)

cur.execute("select c from characters")
print(cur.fetchall())

यहां एक generator का उपयोग करके एक छोटा उदाहरण दिया गया है:

import sqlite3
import string

def char_generator():
    for c in string.ascii_lowercase:
        yield (c,)

con = sqlite3.connect(":memory:")
cur = con.cursor()
cur.execute("create table characters(c)")

cur.executemany("insert into characters(c) values (?)", char_generator())

cur.execute("select c from characters")
print(cur.fetchall())
executescript(sql_script)

यह एक बार में कई SQL कथनों को निष्पादित करने के लिए एक गैर-मानक सुविधा है। यह पहले COMMIT स्टेटमेंट जारी करता है, फिर SQL स्क्रिप्ट को एक पैरामीटर के रूप में निष्पादित करता है।

sql_script str उदाहरण हो सकता है।

उदाहरण:

import sqlite3

con = sqlite3.connect(":memory:")
cur = con.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
    );
    """)
fetchone()

किसी भी परिणाम के उपलब्ध None होने पर, एक एकल अनुक्रम लौटाते हुए, या None , किसी क्वेरी परिणाम सेट की अगली पंक्ति प्राप्त करता है।

fetchmany(size=cursor.arraysize)

किसी क्वेरी परिणाम की पंक्तियों का अगला सेट प्राप्त करता है, एक सूची लौटाता है। कोई और पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है।

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

ध्यान दें कि आकार पैरामीटर के साथ प्रदर्शन विचार शामिल हैं। अनुकूलतम प्रदर्शन के लिए, आमतौर पर ऐरेसेलेट विशेषता का उपयोग करना सबसे अच्छा है। यदि आकार पैरामीटर का उपयोग किया जाता है, तो यह एक fetchmany() कॉल से अगले तक उसी मूल्य को बनाए रखने के लिए सबसे अच्छा है।

fetchall()

किसी क्वेरी परिणाम की सभी (शेष) पंक्तियों को एक सूची में लौटाता है। ध्यान दें कि कर्सर का सरणि गुण इस ऑपरेशन के प्रदर्शन को प्रभावित कर सकता है। कोई पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है।

close()

अब कर्सर बंद करें (जब भी __del__ कहा जाता है)।

आगे इस बिंदु से कर्सर अनुपयोगी होगा; यदि किसी भी ऑपरेशन को कर्सर के साथ करने का प्रयास किया जाता है, तो एक ProgrammingError अपवाद को उठाया जाएगा।

rowcount

यद्यपि sqlite3 मॉड्यूल का Cursor वर्ग इस विशेषता को लागू करता है, "प्रभावित पंक्तियों" / "चयनित पंक्तियों" के निर्धारण के लिए डेटाबेस इंजन का स्वयं का समर्थन विचित्र है।

executemany() कथनों के लिए, संशोधनों की संख्या को executemany() में अभिव्यक्त किया जाता है।

जैसा कि पायथन डीबी एपीआई स्पेक द्वारा आवश्यक है, rowcount विशेषता "-1 है, यदि कर्सर पर कोई executeXX() निष्पादित नहीं किया गया है या अंतिम ऑपरेशन की executeXX() इंटरफ़ेस द्वारा निर्धारित नहीं है"। इसमें SELECT स्टेटमेंट शामिल हैं क्योंकि हम उन पंक्तियों की संख्या को निर्धारित नहीं कर सकते हैं जब तक कि सभी पंक्तियों को प्राप्त नहीं किया जाता है।

3.6.5 से पहले SQLite संस्करणों के साथ, यदि आप बिना किसी शर्त के DELETE FROM table बनाते हैं, तो rowcount 0 पर सेट है।

lastrowid

यह रीड-ओनली विशेषता अंतिम संशोधित पंक्ति की पंक्ति प्रदान करता है। यह केवल तभी सेट किया जाता है जब आपने एक INSERT या REPLACE स्टेटमेंट को execute() विधि का उपयोग करके जारी किया हो। INSERT या REPLACE या जब executemany() कहा जाता है, के अलावा अन्य संचालन के लिए, lastrowid किसी के लिए सेट None

यदि INSERT या REPLACE कथन पिछले सफल पंक्ति को सम्मिलित करने में विफल रहा है तो वापस कर दिया गया है।

संस्करण 3.6 में बदला: REPLACE स्टेटमेंट के लिए जोड़ा गया समर्थन।

arraysize

उस विशेषता को पढ़ें / लिखें जो fetchmany() द्वारा लौटी पंक्तियों की संख्या को नियंत्रित करती है। डिफ़ॉल्ट मान 1 है जिसका अर्थ है कि प्रति पंक्ति एक पंक्ति में लाया जाएगा।

description

यह रीड-ओनली विशेषता अंतिम क्वेरी का कॉलम नाम प्रदान करती है। पायथन डीबी एपीआई के साथ संगत बने रहने के लिए, यह प्रत्येक कॉलम के लिए 7-ट्यूपल लौटाता है जहां प्रत्येक ट्यूपल के अंतिम छह आइटम None

यह किसी भी मिलान पंक्तियों के बिना भी SELECT स्टेटमेंट के लिए सेट है।

connection

यह रीड-ओनली विशेषता Cursor ऑब्जेक्ट द्वारा उपयोग किए गए SQLite डेटाबेस Connection प्रदान करता है। cursor() को कॉल करके बनाई गई एक Cursor ऑब्जेक्ट में एक connection विशेषता होगी जो कि con को संदर्भित करती है:

>>> con = sqlite3.connect(":memory:")
>>> cur = con.cursor()
>>> cur.connection == con
True

रो वस्तुओं

class sqlite3.Row

एक sqlite3.Row उदाहरण Connection ऑब्जेक्ट्स के लिए एक अत्यधिक अनुकूलित row_factory रूप में कार्य करता है। यह अपनी अधिकांश विशेषताओं में टपल की नकल करने की कोशिश करता है।

यह कॉलम नाम और सूचकांक, पुनरावृत्ति, प्रतिनिधित्व, समानता परीक्षण और len() द्वारा मानचित्रण अभिगम का समर्थन करता है।

यदि दो sqlite3.Row वस्तुओं में समान स्तंभ हैं और उनके सदस्य समान हैं, तो वे बराबर की तुलना करते हैं।

keys()

यह विधि स्तंभ नामों की सूची लौटाती है। क्वेरी के तुरंत बाद, यह Cursor.description में प्रत्येक टपल का पहला सदस्य है।

संस्करण 3.5 में बदला गया : स्लाइसिंग का जोड़ा गया समर्थन।

चलिए मान लेते हैं कि हम ऊपर दिए गए उदाहरण के अनुसार एक तालिका को आरंभ करते हैं:

conn = sqlite3.connect(":memory:")
c = conn.cursor()
c.execute('''create table stocks
(date text, trans text, symbol text,
 qty real, price real)''')
c.execute("""insert into stocks
          values ('2006-01-05','BUY','RHAT',100,35.14)""")
conn.commit()
c.close()

अब हम sqlite3.Row को प्लग इन करते हैं:

>>> conn.row_factory = sqlite3.Row
>>> c = conn.cursor()
>>> c.execute('select * from stocks')
<sqlite3.Cursor object at 0x7f4e7dd8fa80>
>>> r = c.fetchone()
>>> type(r)
<class 'sqlite3.Row'>
>>> tuple(r)
('2006-01-05', 'BUY', 'RHAT', 100.0, 35.14)
>>> len(r)
5
>>> r[2]
'RHAT'
>>> r.keys()
['date', 'trans', 'symbol', 'qty', 'price']
>>> r['qty']
100.0
>>> for member in r:
...     print(member)
...
2006-01-05
BUY
RHAT
100.0
35.14

अपवाद

exception sqlite3.Warning

Exception का एक उपवर्ग।

exception sqlite3.Error

इस मॉड्यूल में अन्य अपवादों का आधार वर्ग। यह Exception का एक उपवर्ग है।

exception sqlite3.DatabaseError

डेटाबेस से संबंधित त्रुटियों के लिए उठाया गया अपवाद।

exception sqlite3.IntegrityError

डेटाबेस की संबंधपरक अखंडता प्रभावित होने पर अपवाद उठाया जाता है, जैसे कि एक विदेशी कुंजी जांच विफल। यह DatabaseError का एक उपवर्ग है।

exception sqlite3.ProgrammingError

प्रोग्रामिंग त्रुटियों के लिए उठाया गया अपवाद, उदाहरण के लिए तालिका नहीं मिली है या पहले से मौजूद है, SQL कथन में वाक्यविन्यास त्रुटि, निर्दिष्ट मापदंडों की गलत संख्या, आदि यह डेटाबेसआयर का एक उपवर्ग है।

exception sqlite3.OperationalError

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

exception sqlite3.NotSupportedError

किसी विधि या डेटाबेस API का उपयोग किए जाने पर उत्पन्न अपवाद का उपयोग किया गया था जो डेटाबेस द्वारा समर्थित नहीं है, उदाहरण के लिए rollback() किसी कनेक्शन पर विधि को कॉल करना जो लेनदेन का समर्थन नहीं करता है या लेनदेन बंद है। यह एक उपवर्ग है DatabaseError

SQLite और पायथन प्रकार

परिचय

: SQLite देशी रूप निम्नलिखित प्रकार का समर्थन करता है NULL , INTEGER , REAL , TEXT , BLOB

निम्नलिखित पायथन प्रकार इस प्रकार बिना किसी समस्या के SQLite को भेजे जा सकते हैं:

अजगर का प्रकार SQLite प्रकार
None NULL
int INTEGER
float REAL
str TEXT
bytes BLOB

यह है कि कैसे SQLite प्रकार डिफ़ॉल्ट रूप से पायथन प्रकार में बदल जाते हैं:

SQLite प्रकार अजगर का प्रकार
NULL None
INTEGER int
REAL float
TEXT पर निर्भर करता है text_factory , str डिफ़ॉल्ट रूप से
BLOB bytes

sqlite3 मॉड्यूल का प्रकार प्रणाली दो तरह से एक्स्टेंसिबल है: आप ऑब्जेक्ट अनुकूलन के माध्यम से अतिरिक्त Python प्रकारों को SQLite डेटाबेस में संग्रहीत कर सकते हैं और आप sqlite3 मॉड्यूल के माध्यम से SQLite प्रकारों को भिन्न Python प्रकारों में परिवर्तित कर सकते हैं।

SQLite डेटाबेस में अतिरिक्त पायथन प्रकारों को संग्रहीत करने के लिए एडेप्टर का उपयोग करना

जैसा कि पहले बताया गया है, SQLite केवल प्रकार के सीमित सेट का समर्थन करता है। SQLite के साथ अन्य पायथन प्रकारों का उपयोग करने के लिए, आपको उन्हें SQLite के लिए sqlite3 मॉड्यूल के समर्थित प्रकारों में से एक के लिए अनुकूलित करना होगा : NoType, int, float, str, बाइट्स में से एक।

sqlite3 मॉड्यूल को सक्षम करने के लिए दो तरीके हैं एक कस्टम पायथन प्रकार को समर्थित लोगों में से एक को अनुकूलित करने के लिए।

अपनी वस्तु को अपने अनुकूल होने देना

यदि आप स्वयं कक्षा लिखते हैं तो यह एक अच्छा तरीका है। मान लीजिए कि आपके पास इस तरह एक वर्ग है:

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

अब आप बिंदु को एक एकल SQLite कॉलम में संग्रहीत करना चाहते हैं। पहले आपको बिंदु का प्रतिनिधित्व करने के लिए उपयोग किए जाने वाले पहले समर्थित प्रकारों में से एक चुनना होगा। आइए अभी str का उपयोग करें और एक अर्धविराम का उपयोग करके निर्देशांक को अलग करें। फिर आपको अपनी कक्षा को एक विधि देने की आवश्यकता है __conform__(self, protocol) जिसे परिवर्तित मूल्य वापस करना होगा। पैरामीटर प्रोटोकॉल होगा PrepareProtocol

import sqlite3

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __conform__(self, protocol):
        if protocol is sqlite3.PrepareProtocol:
            return "%f;%f" % (self.x, self.y)

con = sqlite3.connect(":memory:")
cur = con.cursor()

p = Point(4.0, -3.2)
cur.execute("select ?", (p,))
print(cur.fetchone()[0])

एडॉप्टर कॉल करने योग्य पंजीकृत करना

अन्य संभावना एक फ़ंक्शन बनाने के लिए है जो टाइप को स्ट्रिंग प्रतिनिधित्व में परिवर्तित करती है और फ़ंक्शन को पंजीकृत करती है register_adapter()

import sqlite3

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

def adapt_point(point):
    return "%f;%f" % (point.x, point.y)

sqlite3.register_adapter(Point, adapt_point)

con = sqlite3.connect(":memory:")
cur = con.cursor()

p = Point(4.0, -3.2)
cur.execute("select ?", (p,))
print(cur.fetchone()[0])

sqlite3 मॉड्यूल अजगर के अंतर्निहित के लिए दो डिफ़ॉल्ट एडाप्टर है datetime.date और datetime.datetime प्रकार के। अब मान लेते हैं कि हम datetime.datetime वस्तुओं को आईएसओ प्रतिनिधित्व में नहीं, बल्कि यूनिक्स टाइमस्टैम्प के रूप में संग्रहीत करना चाहते हैं ।

import sqlite3
import datetime
import time

def adapt_datetime(ts):
    return time.mktime(ts.timetuple())

sqlite3.register_adapter(datetime.datetime, adapt_datetime)

con = sqlite3.connect(":memory:")
cur = con.cursor()

now = datetime.datetime.now()
cur.execute("select ?", (now,))
print(cur.fetchone()[0])

कस्टम मानों के लिए SQLite मानों को परिवर्तित करना

एडेप्टर लिखने से आप कस्टम पायथन प्रकारों को SQLite में भेज सकते हैं। लेकिन इसे वास्तव में उपयोगी बनाने के लिए हमें पायथन को SQLite से पायथन राउंडट्रिप कार्य करने की आवश्यकता है।

कन्वर्टर्स दर्ज करें।

चलो Point कक्षा में वापस जाते हैं । हमने SQLite में स्ट्रिंग्स के रूप में अर्धविराम के माध्यम से अलग किए गए x और y निर्देशांक संग्रहीत किए।

सबसे पहले, हम एक कनवर्टर फंक्शन को परिभाषित करेंगे जो स्ट्रिंग को एक पैरामीटर के रूप में स्वीकार करता है और Point उससे एक ऑब्जेक्ट का निर्माण करता है।

ध्यान दें

कन्वर्टर फ़ंक्शंस को हमेशा bytes ऑब्जेक्ट के साथ बुलाया जाता है , इससे कोई फर्क नहीं पड़ता कि आपने किस प्रकार के डेटा को SQLite पर भेजा है।

def convert_point(s):
    x, y = map(float, s.split(b";"))
    return Point(x, y)

अब आपको sqlite3 मॉड्यूल को यह जानने की जरूरत है कि आप डेटाबेस से जो चुनते हैं वह वास्तव में एक बिंदु है। इसे करने के दो तरीके हैं:

  • घोषित प्रकार के माध्यम से
  • स्पष्ट रूप से कॉलम नाम के माध्यम से

दोनों तरीके खंड मॉड्यूल कार्यों और स्थिरांक में वर्णित हैं , स्थिरांक के लिए प्रविष्टियों में PARSE_DECLTYPES और PARSE_COLNAMES

निम्न उदाहरण दोनों दृष्टिकोणों को दिखाता है।

import sqlite3

class Point:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return "(%f;%f)" % (self.x, self.y)

def adapt_point(point):
    return ("%f;%f" % (point.x, point.y)).encode('ascii')

def convert_point(s):
    x, y = list(map(float, s.split(b";")))
    return Point(x, y)

# Register the adapter
sqlite3.register_adapter(Point, adapt_point)

# Register the converter
sqlite3.register_converter("point", convert_point)

p = Point(4.0, -3.2)

#########################
# 1) Using declared types
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES)
cur = con.cursor()
cur.execute("create table test(p point)")

cur.execute("insert into test(p) values (?)", (p,))
cur.execute("select p from test")
print("with declared types:", cur.fetchone()[0])
cur.close()
con.close()

#######################
# 1) Using column names
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES)
cur = con.cursor()
cur.execute("create table test(p)")

cur.execute("insert into test(p) values (?)", (p,))
cur.execute('select p as "p [point]" from test')
print("with column names:", cur.fetchone()[0])
cur.close()
con.close()

डिफ़ॉल्ट एडेप्टर और कन्वर्टर्स

डेटाइम मॉड्यूल में दिनांक और डेटाटाइम प्रकार के लिए डिफ़ॉल्ट एडेप्टर हैं। उन्हें ISO तिथियों / ISO टाइमस्टैम्प के रूप में SQLite पर भेजा जाएगा।

डिफ़ॉल्ट कन्वर्टर्स नाम "दिनांक" के लिए datetime.date और "टाइमस्टैम्प" नाम के तहत पंजीकृत हैं datetime.datetime

इस तरह, आप ज्यादातर मामलों में बिना किसी अतिरिक्त फिडलिंग के पाइथन से तारीख / टाइमस्टैम्प का उपयोग कर सकते हैं। एडाप्टर्स का प्रारूप प्रयोगात्मक SQLite दिनांक / समय फ़ंक्शन के साथ भी संगत है।

निम्न उदाहरण यह प्रदर्शित करता है।

import sqlite3
import datetime

con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES)
cur = con.cursor()
cur.execute("create table test(d date, ts timestamp)")

today = datetime.date.today()
now = datetime.datetime.now()

cur.execute("insert into test(d, ts) values (?, ?)", (today, now))
cur.execute("select d, ts from test")
row = cur.fetchone()
print(today, "=>", row[0], type(row[0]))
print(now, "=>", row[1], type(row[1]))

cur.execute('select current_date as "d [date]", current_timestamp as "ts [timestamp]"')
row = cur.fetchone()
print("current_date", row[0], type(row[0]))
print("current_timestamp", row[1], type(row[1]))

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

लेन-देन पर नियंत्रण

अंतर्निहित sqlite3 लाइब्रेरी autocommit डिफ़ॉल्ट रूप से मोड में काम करती है , लेकिन डिफ़ॉल्ट रूप से पायथन sqlite3 मॉड्यूल नहीं है।

autocommit मोड का मतलब है कि डेटाबेस को संशोधित करने वाले बयान तुरंत प्रभावी होते हैं। एक BEGIN या SAVEPOINT कथन autocommit मोड को निष्क्रिय करता है, और एक COMMIT , ROLLBACK या, RELEASE जो सबसे बाहरी लेनदेन को समाप्त करता autocommit है , मोड को वापस चालू करता है।

sqlite3 डिफ़ॉल्ट रूप से पायथन मॉड्यूल BEGIN डेटा संशोधन भाषा (डीएमएल) कथन (यानी INSERT / UPDATE / DELETE / REPLACE ) से पहले एक बयान को स्पष्ट रूप से जारी करता है ।

आप नियंत्रित कर सकते हैं कि किस तरह के BEGIN बयानों को फोन करने के लिए या कनेक्शन की संपत्ति के sqlite3 माध्यम से अलगाव_लेवल पैरामीटर के माध्यम से निष्पादित किया जाता है । यदि आप कोई आइसोलेशन_लेवल निर्दिष्ट नहीं करते हैं , तो एक प्लेन का उपयोग किया जाता है, जो निर्दिष्ट करने के बराबर है । अन्य संभावित मान हैं और । connect() isolation_level BEGIN DEFERRED IMMEDIATE EXCLUSIVE

आप निष्क्रिय कर सकते हैं sqlite3 की स्थापना करके मॉड्यूल का अंतर्निहित लेनदेन प्रबंधन isolation_level करने के लिए None । यह अंतर्निहित sqlite3 लाइब्रेरी को autocommit मोड में काम करेगा । इसके बाद आप पूरी तरह से स्पष्ट रूप से जारी कर लेन-देन राज्य नियंत्रित कर सकते हैं BEGIN , ROLLBACK , SAVEPOINT , और RELEASE अपने कोड में बयान।

संस्करण 3.6 में परिवर्तित: sqlite3 डीडीएल बयानों से पहले खुले तौर पर लेनदेन करने के लिए इस्तेमाल किया जाता है। यह अब मामला ही नहीं है।

Sqlite3 का कुशलता से उपयोग करना

शॉर्टकट तरीकों का उपयोग करना

ऑब्जेक्ट के गैर-मानक execute() , executemany() और executescript() विधियों का उपयोग करके Connection , आपका कोड अधिक संक्षिप्त रूप से लिखा जा सकता है क्योंकि आपको Cursor स्पष्ट रूप से (अक्सर सुपरफ्लस) ऑब्जेक्ट बनाने की आवश्यकता नहीं है । इसके बजाय, Cursor ऑब्जेक्ट अंतर्निहित रूप से बनाए जाते हैं और ये शॉर्टकट तरीके कर्सर ऑब्जेक्ट को वापस करते हैं। इस तरह, आप किसी SELECT स्टेटमेंट को निष्पादित कर सकते हैं और Connection ऑब्जेक्ट पर केवल एक कॉल का उपयोग करके सीधे उस पर पुनरावृति कर सकते हैं ।

import sqlite3

persons = [
    ("Hugo", "Boss"),
    ("Calvin", "Klein")
    ]

con = sqlite3.connect(":memory:")

# Create the table
con.execute("create table person(firstname, lastname)")

# Fill the table
con.executemany("insert into person(firstname, lastname) values (?, ?)", persons)

# Print the table contents
for row in con.execute("select firstname, lastname from person"):
    print(row)

print("I just deleted", con.execute("delete from person").rowcount, "rows")

अनुक्रमणिका के बजाय नाम से कॉलम एक्सेस करना

sqlite3 मॉड्यूल की एक उपयोगी विशेषता बिल्ट-इन sqlite3.Row क्लास है जिसे एक पंक्ति कारखाने के रूप में उपयोग करने के लिए डिज़ाइन किया गया है।

इस वर्ग से लिपटी हुई पंक्तियों को अनुक्रमणिका (जैसे टुपल्स) और केस-इनसेंसिटिवली नाम से एक्सेस किया जा सकता है:

import sqlite3

con = sqlite3.connect(":memory:")
con.row_factory = sqlite3.Row

cur = con.cursor()
cur.execute("select 'John' as name, 42 as age")
for row in cur:
    assert row[0] == row["name"]
    assert row["name"] == row["nAmE"]
    assert row[1] == row["age"]
    assert row[1] == row["AgE"]

संदर्भ प्रबंधक के रूप में कनेक्शन का उपयोग करना

कनेक्शन ऑब्जेक्ट्स को संदर्भ प्रबंधकों के रूप में इस्तेमाल किया जा सकता है जो स्वचालित रूप से प्रतिबद्ध या रोलबैक लेनदेन करते हैं। अपवाद की स्थिति में, लेन-देन वापस लुढ़का हुआ है; अन्यथा, लेनदेन प्रतिबद्ध है:

import sqlite3

con = sqlite3.connect(":memory:")
con.execute("create table person (id integer primary key, firstname varchar unique)")

# Successful, con.commit() is called automatically afterwards
with con:
    con.execute("insert into person(firstname) values (?)", ("Joe",))

# con.rollback() is called after the with block finishes with an exception, the
# exception is still raised and must be caught
try:
    with con:
        con.execute("insert into person(firstname) values (?)", ("Joe",))
except sqlite3.IntegrityError:
    print("couldn't add Joe twice")

सामान्य मुद्दे

बहु सूत्रण

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

एकमात्र अपवाद interrupt() विधि को कॉल कर रहा है, जो केवल एक अलग धागे से कॉल करने के लिए समझ में आता है।

फुटनोट

[1] ( 1 , 2 ) sqlite3 मॉड्यूल को डिफ़ॉल्ट रूप से लोड करने योग्य विस्तार समर्थन के साथ नहीं बनाया गया है, क्योंकि कुछ प्लेटफार्मों (विशेष रूप से मैक ओएस एक्स) में SQLite पुस्तकालय हैं जो इस सुविधा के बिना संकलित हैं। लोड करने योग्य एक्सटेंशन समर्थन प्राप्त करने के लिए, आपको कॉन्फ़िगर करने के लिए -enable-loadable-sqlite- एक्सटेंशन पास करना होगा।

Original text