पायथन डेटा एक्सेस - त्वरित गाइड

डेटाबेस इंटरफेस के लिए पायथन मानक पायथन डीबी-एपीआई है। अधिकांश पायथन डेटाबेस इंटरफेस इस मानक का पालन करते हैं।

आप अपने आवेदन के लिए सही डेटाबेस चुन सकते हैं। अजगर डेटाबेस एपीआई डेटाबेस सर्वर की एक विस्तृत श्रृंखला का समर्थन करता है जैसे -

GadFly
mSQL
MySQL
PostgreSQL
Microsoft SQL Server 2000
Informix
Interbase
Oracle
Sybase

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

Mysql-कनेक्टर-पायथन क्या है

MySQL पायथन / कनेक्टर Python से MySQL डेटाबेस सर्वर से कनेक्ट करने के लिए एक इंटरफ़ेस है। यह पायथन डेटाबेस एपीआई को लागू करता है और MySQL के शीर्ष पर बनाया गया है।

मैं mysql-कनेक्टर-पायथन कैसे स्थापित करूं?

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

C:\Users\Tutorialspoint>python
Python 3.7.3 (v3.7.3:ef4ec6ed12, Mar 25 2019, 22:22:05) [MSC v.1916 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

अब ctrl + z दबाएं और फिर अजगर के खोल से बाहर निकलने के लिए एंटर करें और एक फ़ोल्डर बनाएं (जिसमें आपने Python-MySQL कनेक्टर को Python_MySQL नाम दिया है -

>>> ^Z
C:\Users\Tutorialspoint>d:
D:\>mkdir Python_MySQL

PIP सत्यापित करें

PIP अजगर में एक पैकेज मैनेजर है जिसके उपयोग से आप Python में विभिन्न मॉड्यूल / पैकेज स्थापित कर सकते हैं। इसलिए, माईसकल-पाइथन mysql-कनेक्टर-पायथन को स्थापित करने के लिए आपको यह सुनिश्चित करने की आवश्यकता है कि आपके कंप्यूटर में पीआईपी स्थापित है और इसका स्थान पथ में जोड़ा गया है।

आप ऐसा कर सकते हैं, पाइप कमांड को निष्पादित करके। यदि आपके पास आपके सिस्टम में PIP नहीं है या, यदि आपने इसमें अपना स्थान नहीं जोड़ा हैPath पर्यावरण चर, आपको एक त्रुटि संदेश मिलेगा -

D:\Python_MySQL>pip
'pip' is not recognized as an internal or external command,
operable program or batch file.

PIP स्थापित करने के लिए, ऊपर बने फ़ोल्डर में get-pip.py डाउनलोड करें और कमांड से इसे नेविगेट करें और निम्नानुसार पाइप स्थापित करें -

D:\>cd Python_MySQL
D:\Python_MySQL>python get-pip.py
Collecting pip
Downloading https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl (1.4MB)
|████████████████████████████████| 1.4MB 1.3MB/s
Collecting wheel
Downloading https://files.pythonhosted.org/packages/00/83/b4a77d044e78ad1a45610eb88f745be2fd2c6d658f9798a15e384b7d57c9/wheel-0.33.6-py2.py3-none-any.whl
Installing collected packages: pip, wheel
Consider adding this directory to PATH or, if you prefer to suppress this warning, use --no-warn-script-location.
Successfully installed pip-19.2.2 wheel-0.33.6

Mysql-कनेक्टर-अजगर स्थापित करना

एक बार जब आप पायथन और पीआईपी स्थापित कर लेते हैं, तो कमांड प्रॉम्प्ट खोलें और नीचे दिखाए अनुसार पाइप (वैकल्पिक) को अपग्रेड करें -

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Python Data Access
4
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

फिर व्यवस्थापक मोड में कमांड प्रॉम्प्ट खोलें और अजगर MySQL कनेक्ट के रूप में स्थापित करें -

C:\WINDOWS\system32>pip install mysql-connector-python
Collecting mysql-connector-python
Using cached https://files.pythonhosted.org/packages/99/74/f41182e6b7aadc62b038b6939dce784b7f9ec4f89e2ae14f9ba8190dc9ab/mysql_connector_python-8.0.17-py2.py3-none-any.whl
Collecting protobuf>=3.0.0 (from mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/09/0e/614766ea191e649216b87d331a4179338c623e08c0cca291bcf8638730ce/protobuf-3.9.1-cp37-cp37m-win32.whl
Collecting six>=1.9 (from protobuf>=3.0.0->mysql-connector-python)
Using cached https://files.pythonhosted.org/packages/73/fb/00a976f728d0d1fecfe898238ce23f502a721c0ac0ecfedb80e0d88c64e9/six-1.12.0-py2.py3-none-any.whl
Requirement already satisfied: setuptools in c:\program files (x86)\python37-32\lib\site-packages (from protobuf>=3.0.0->mysql-connector-python) (40.8.0)
Installing collected packages: six, protobuf, mysql-connector-python
Successfully installed mysql-connector-python-8.0.17 protobuf-3.9.1 six-1.12.0

सत्यापन

इसमें निम्न पंक्ति के साथ एक नमूना अजगर स्क्रिप्ट बनाने की स्थापना को सत्यापित करने के लिए।

import mysql.connector

यदि स्थापना सफल होती है, जब आप इसे निष्पादित करते हैं, तो आपको कोई त्रुटि नहीं मिलनी चाहिए -

D:\Python_MySQL>python test.py
D:\Python_MySQL>

स्क्रैच से अजगर स्थापित करना

बस, अगर आपको स्क्रैच से अजगर को स्थापित करने की आवश्यकता है। यात्रा अजगर मुख पृष्ठ ।

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

उदाहरण के लिए, हमने python-3.7.4.exe (विंडोज़ के लिए) डाउनलोड किया है। डाउनलोड की गई .exe फ़ाइल को डबल-क्लिक करके इंस्टॉलेशन प्रक्रिया शुरू करें ।

पथ विकल्प में जोड़ें पायथन 3.7 की जाँच करें और स्थापना के साथ आगे बढ़ें। इस प्रक्रिया के पूरा होने के बाद, आपके सिस्टम में अजगर स्थापित हो जाएगा।

MySQL से जुड़ने के लिए, (एक तरीका यह है) अपने सिस्टम में MySQL कमांड प्रॉम्प्ट खोलें जैसा कि नीचे दिखाया गया है -

यह यहां पासवर्ड मांगता है; आपको स्थापना के समय डिफ़ॉल्ट उपयोगकर्ता (रूट) पर निर्धारित पासवर्ड टाइप करना होगा।

तब MySQL के साथ एक कनेक्शन स्थापित किया जाता है जो निम्नलिखित संदेश प्रदर्शित करता है -

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 4
Server version: 5.7.12-log MySQL Community Server (GPL)

Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

आप MySQL डेटाबेस से किसी भी समय mysql> प्रॉम्प्ट पर निकास कमांड का उपयोग करके डिस्कनेक्ट कर सकते हैं।

mysql> exit
Bye

अजगर का उपयोग करके MySQL के साथ संबंध स्थापित करना

अजगर का उपयोग करके MySQL डेटाबेस से संबंध स्थापित करने से पहले, मान लें -

कि हमने mydb नाम से एक डेटाबेस बनाया है।
हमने स्तंभ FIRST_NAME, LAST_NAME, AGE, SEX और INCOME के साथ एक तालिका EMPLOYEE बनाई है।
MySQL से जुड़ने के लिए हम जिन क्रेडेंशियल्स का उपयोग कर रहे हैं, वे उपयोगकर्ता नाम हैं: root, कुंजिका: password।

आप का उपयोग कर एक कनेक्शन स्थापित कर सकते हैं connect()निर्माता। यह उपयोगकर्ता नाम, पासवर्ड, होस्ट और, उस डेटाबेस का नाम स्वीकार करता है जिसे आपको (वैकल्पिक) के साथ कनेक्ट करने की आवश्यकता है और, MySQLConnection class का ऑब्जेक्ट देता है।

उदाहरण

निम्नलिखित MySQL डेटाबेस "mydb" से जुड़ने का उदाहरण है।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("SELECT DATABASE()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()

उत्पादन

निष्पादित करने पर, यह स्क्रिप्ट निम्नलिखित आउटपुट का उत्पादन करती है -

D:\Python_MySQL>python EstablishCon.py
Connection established to: ('mydb',)

आप क्रेडेंशियल (उपयोगकर्ता नाम, पासवर्ड, होस्टनाम और डेटाबेस का नाम) पास करके भी MySQL से कनेक्शन स्थापित कर सकते हैं connection.MySQLConnection() जैसा कि नीचे दिखाया गया है -

from mysql.connector import (connection)

#establishing the connection
conn = connection.MySQLConnection(user='root', password='password', host='127.0.0.1', database='mydb')

#Closing the connection
conn.close()

आप CREATE DATABASE क्वेरी का उपयोग करके MYSQL में एक डेटाबेस बना सकते हैं।

वाक्य - विन्यास

निम्नलिखित रचना डेटाबेस क्वेरी का सिंटैक्स है -

CREATE DATABASE name_of_the_database

उदाहरण

निम्नलिखित कथन MySQL में mydb नाम के साथ एक डेटाबेस बनाता है -

mysql> CREATE DATABASE mydb;
Query OK, 1 row affected (0.04 sec)

यदि आप SHOW DATABASES स्टेटमेंट का उपयोग करके डेटाबेस की सूची का निरीक्षण करते हैं, तो आप इसमें नए बनाए गए डेटाबेस का निरीक्षण कर सकते हैं जैसे कि नीचे दिखाया गया है -

mysql> SHOW DATABASES;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| logging            |
| mydatabase         |
| mydb               |
| performance_schema |
| students           |
| sys                |
+--------------------+
26 rows in set (0.15 sec)

अजगर का उपयोग करके MySQL में एक डेटाबेस बनाना

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

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

उदाहरण

निम्न उदाहरण MYSQL के साथ संबंध स्थापित करता है और इसमें एक डेटाबेस बनाता है।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(user='root', password='password', host='127.0.0.1')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping database MYDATABASE if already exists.
cursor.execute("DROP database IF EXISTS MyDatabase")

#Preparing query to create a database
sql = "CREATE database MYDATABASE";

#Creating a database
cursor.execute(sql)

#Retrieving the list of databases
print("List of databases: ")
cursor.execute("SHOW DATABASES")
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

List of databases:
[('information_schema',), ('dbbug61332',), ('details',), ('exampledatabase',), ('mydatabase',), ('mydb',), ('mysql',), ('performance_schema',)]

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

वाक्य - विन्यास

MySQL में टेबल बनाने के लिए सिंटैक्स निम्नलिखित है -

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

उदाहरण

निम्नलिखित क्वेरी MySQL में EMPLOYEE नाम की एक तालिका बनाती है जिसमें पाँच कॉलम हैं, FIRST_NAME, LAST_NAME, AGE, SEX और, INCOME।

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.42 sec)

DESC कथन आपको निर्दिष्ट तालिका का विवरण देता है। इसका उपयोग कर आप यह सत्यापित कर सकते हैं कि तालिका बनाई गई है या नहीं जैसा कि नीचे दिखाया गया है -

mysql> Desc Employee;
+------------+----------+------+-----+---------+-------+
| Field      | Type     | Null | Key | Default | Extra |
+------------+----------+------+-----+---------+-------+
| FIRST_NAME | char(20) | NO   |     | NULL    |       |
| LAST_NAME  | char(20) | YES  |     | NULL    |       |
| AGE        | int(11)  | YES  |     | NULL    |       |
| SEX        | char(1)  | YES  |     | NULL    |       |
| INCOME     | float    | YES  |     | NULL    |       |
+------------+----------+------+-----+---------+-------+
5 rows in set (0.07 sec)

अजगर का उपयोग करके MySQL में एक टेबल बनाना

नाम की विधि execute() (कर्सर ऑब्जेक्ट पर आमंत्रित) दो चर स्वीकार करता है -

निष्पादित करने के लिए क्वेरी का प्रतिनिधित्व करने वाला स्ट्रिंग मान।
एक वैकल्पिक आर्ग्स पैरामीटर जो टपल या, लिस्ट या डिक्शनरी हो सकता है, क्वेरी के मापदंडों (प्लेस होल्डर्स के मान) का प्रतिनिधित्व करता है।

यह क्वेरी द्वारा प्रभावित पंक्तियों की संख्या का प्रतिनिधित्व करते हुए एक पूर्णांक मान देता है।

एक बार डेटाबेस कनेक्शन स्थापित हो जाने के बाद, आप क्रिएट टेबल क्वेरी को पास करके टेबल बना सकते हैं execute() तरीका।

संक्षेप में, अजगर 7minus का उपयोग कर एक तालिका बनाने के लिए;

आयात mysql.connector पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ mysql.connector.connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
एक कर्सर ऑब्जेक्ट बनाकर cursor() ऊपर बनाई गई कनेक्शन ऑब्जेक्ट पर विधि।
फिर, इसे पैरामीटर के रूप में पास करके क्रिएट टेबल स्टेटमेंट को निष्पादित करेंexecute() तरीका।

उदाहरण

निम्नलिखित उदाहरण एक तालिका बनाता है जिसका नाम है Employee डेटाबेस में mydb।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Dropping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Closing the connection
conn.close()

आप MySQL की मौजूदा तालिका में नई पंक्तियों को जोड़ सकते हैं INSERT INTOबयान। इसमें, आपको तालिका का नाम, कॉलम के नाम और मान निर्दिष्ट करने की आवश्यकता है (कॉलम नामों के समान क्रम में)।

वाक्य - विन्यास

निम्नलिखित MySQL के INSERT INTO स्टेटमेंट का सिंटैक्स है।

INSERT INTO TABLE_NAME (column1, column2,column3,...columnN)
VALUES (value1, value2, value3,...valueN);

उदाहरण

निम्नलिखित क्वेरी EMPLOYEE नामक तालिका में एक रिकॉर्ड सम्मिलित करती है।

INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES ('
   Mac', 'Mohan', 20, 'M', 2000
);

आप सेलेक्ट स्टेटमेंट का उपयोग करके ऑपरेशन डालने के बाद तालिका के रिकॉर्ड को सत्यापित कर सकते हैं -

mysql> select * from Employee;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Mac        | Mohan     | 20   | M    | 2000   | 
+------------+-----------+------+------+--------+
1 row in set (0.00 sec)

कॉलम के नामों को हमेशा निर्दिष्ट करना अनिवार्य नहीं है, यदि आप तालिका के स्तंभों के समान क्रम में एक रिकॉर्ड के मानों को पास करते हैं, तो आप स्तंभ के नामों के बिना सेलेक्ट स्टेटमेंट को निम्नानुसार निष्पादित कर सकते हैं -

INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000);

अजगर का उपयोग करके MySQL तालिका में डेटा सम्मिलित करना

execute()विधि (कर्सर ऑब्जेक्ट पर आह्वान) एक क्वेरी को पैरामीटर के रूप में स्वीकार करती है और दिए गए क्वेरी को निष्पादित करती है। डेटा डालने के लिए, आपको इसके पैरामीटर के रूप में MySQL INSERT स्टेटमेंट पास करना होगा।

cursor.execute("""INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)""")

अजगर का उपयोग कर MySQL में एक तालिका में डेटा सम्मिलित करने के लिए -

आयात mysql.connector पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ mysql.connector.connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
एक कर्सर ऑब्जेक्ट बनाकर cursor() ऊपर बनाई गई कनेक्शन ऑब्जेक्ट पर विधि
फिर, निष्पादित करें INSERT यह एक पैरामीटर के रूप में पारित करके बयान execute() तरीका।

उदाहरण

निम्न उदाहरण EMPLOYEE तालिका में रिकॉर्ड सम्मिलित करने के लिए SQL INSERT विवरण निष्पादित करता है -

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
sql = """INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)
   VALUES ('Mac', 'Mohan', 20, 'M', 2000)"""

try:
   # Executing the SQL command
   cursor.execute(sql)

   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

# Closing the connection
conn.close()

मूल्यों को गतिशील रूप से सम्मिलित करना

आप मानों के बजाय "% s" का उपयोग कर सकते हैं INSERT MySQL की क्वेरी और उनके मानों को सूची के रूप में नीचे दिखाए अनुसार -

cursor.execute("""INSERT INTO EMPLOYEE VALUES ('Mac', 'Mohan', 20, 'M', 2000)""", 
   ('Ramya', 'Ramapriya', 25, 'F', 5000))

उदाहरण

निम्नलिखित उदाहरण गतिशील रूप से कर्मचारी तालिका में एक रिकॉर्ड सम्मिलित करता है।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL query to INSERT a record into the database.
insert_stmt = (
   "INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX, INCOME)"
   "VALUES (%s, %s, %s, %s, %s)"
)
data = ('Ramya', 'Ramapriya', 25, 'F', 5000)

try:
   # Executing the SQL command
   cursor.execute(insert_stmt, data)
   
   # Commit your changes in the database
   conn.commit()

except:
   # Rolling back in case of error
   conn.rollback()

print("Data inserted")

# Closing the connection
conn.close()

उत्पादन

Data inserted

आप चयन क्वेरी का उपयोग करके MySQL की एक तालिका से डेटा पुनः प्राप्त / प्राप्त कर सकते हैं। यह प्रश्न / कथन सारणीबद्ध रूप में निर्दिष्ट तालिका की सामग्री देता है और इसे परिणाम-सेट कहा जाता है।

वाक्य - विन्यास

निम्नलिखित सिलेक्ट क्वेरी का सिंटैक्स है -

SELECT column1, column2, columnN FROM table_name;

उदाहरण

मान लें कि हमने MySQL में एक तालिका बनाई है जिसका नाम क्रिकेटर्स_डेटा है -

CREATE TABLE cricketers_data(
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Date_Of_Birth date,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

insert into cricketers_data values(
   'Shikhar', 'Dhawan', DATE('1981-12-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Jonathan', 'Trott', DATE('1981-04-22'), 'CapeTown', 'SouthAfrica');
insert into cricketers_data values(
   'Kumara', 'Sangakkara', DATE('1977-10-27'), 'Matale', 'Srilanka');
insert into cricketers_data values(
   'Virat', 'Kohli', DATE('1988-11-05'), 'Delhi', 'India');
insert into cricketers_data values(
   'Rohit', 'Sharma', DATE('1987-04-30'), 'Nagpur', 'India');

निम्न क्वेरी तालिका से FIRST_NAME और देश मान प्राप्त करती है।

mysql> select FIRST_NAME, Country from cricketers_data;
+------------+-------------+
| FIRST_NAME | Country     |
+------------+-------------+
| Shikhar    | India       |
| Jonathan   | SouthAfrica |
| Kumara     | Srilanka    |
| Virat      | India       |
| Rohit      | India       |
+------------+-------------+
5 rows in set (0.00 sec)

आप प्रत्येक रिकॉर्ड के सभी मानों का उपयोग करके पुनः प्राप्त कर सकते हैं जैसे कि कॉलम के नाम से *

mysql> SELECT * from cricketers_data;
+------------+------------+---------------+----------------+-------------+
| First_Name | Last_Name  | Date_Of_Birth | Place_Of_Birth | Country     |
+------------+------------+---------------+----------------+-------------+
| Shikhar    | Dhawan     | 1981-12-05    | Delhi          | India       |
| Jonathan   | Trott      | 1981-04-22    | CapeTown       | SouthAfrica |
| Kumara     | Sangakkara | 1977-10-27    | Matale         | Srilanka    |
| Virat      | Kohli      | 1988-11-05    | Delhi          | India       |
| Rohit      | Sharma     | 1987-04-30    | Nagpur         | India       |
+------------+------------+---------------+----------------+-------------+
5 rows in set (0.00 sec)

पायथन का उपयोग करके एक MYSQL तालिका से डेटा पढ़ना

किसी भी डेटाबेस पर पढ़ें ऑपरेशन का मतलब डेटाबेस से कुछ उपयोगी जानकारी प्राप्त करना है। आप MYSQL से डेटा का उपयोग कर प्राप्त कर सकते हैंfetch() mysql-कनेक्टर-पायथन द्वारा प्रदान की गई विधि।

Cursor.MySQLCursor वर्ग तीन तरीकों अर्थात् प्रदान करता हैfetchall(), fetchmany() तथा, fetchone() कहाँ पे,

fetchall()विधि क्वेरी के परिणाम सेट में सभी पंक्तियों को पुनः प्राप्त करती है और उन्हें टुपल्स की सूची के रूप में वापस करती है। (यदि हम कुछ पंक्तियों को प्राप्त करने के बाद इसे निष्पादित करते हैं तो यह शेष लोगों को वापस कर देता है)।
fetchone() विधि क्वेरी के परिणाम में अगली पंक्ति लाती है और इसे टुप के रूप में लौटाती है।
fetchmany() विधि भ्रूण के समान है (), लेकिन यह एक पंक्ति के बजाय, क्वेरी के परिणाम सेट में पंक्तियों के अगले सेट को पुनः प्राप्त करता है।

Note - एक परिणाम सेट एक ऑब्जेक्ट है जो एक टेबल को क्वेरी करने के लिए कर्सर ऑब्जेक्ट का उपयोग करने पर वापस किया जाता है।

rowcount - यह केवल पढ़ने के लिए विशेषता है और उन पंक्तियों की संख्या को लौटाता है जो एक निष्पादन () विधि से प्रभावित थे।

उदाहरण

उदाहरण के बाद EMPLOYEE तालिका की सभी पंक्तियों को SELECT क्वेरी का उपयोग करके और प्राप्त परिणाम सेट से शुरू में, हम भ्रूण () विधि का उपयोग करके पहली पंक्ति को पुनः प्राप्त कर रहे हैं और फिर भ्रूण () विधि का उपयोग करके शेष पंक्तियों को प्राप्त कर रहे हैं।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

उत्पादन

('Krishna', 'Sharma', 19, 'M', 2000.0)
[('Raj', 'Kandukuri', 20, 'M', 7000.0), ('Ramya', 'Ramapriya', 25, 'M', 5000.0)]

उदाहरण के बाद भ्रूण () विधि का उपयोग करते हुए EMPLOYEE तालिका की पहली दो पंक्तियों को पुनः प्राप्त करता है।

उदाहरण

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchmany(size =2);
print(result)

#Closing the connection
conn.close()

उत्पादन

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

यदि आप MySQL में किसी तालिका की विशेष पंक्तियों को लाना, हटाना या अपडेट करना चाहते हैं, तो आपको ऑपरेशन के लिए तालिका की पंक्तियों को फ़िल्टर करने के लिए शर्त निर्दिष्ट करने के लिए जहां क्लॉज का उपयोग करना होगा।

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

वाक्य - विन्यास

निम्नलिखित WHERE क्लॉज का वाक्य विन्यास है -

SELECT column1, column2, columnN
FROM table_name
WHERE [condition]

उदाहरण

मान लें कि हमने MySQL में एक तालिका बनाई है जिसका नाम EMPLOYEES है -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 4 रिकॉर्ड डाले हैं -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

MySQL स्टेटमेंट के बाद उन कर्मचारियों के रिकॉर्ड को पुनः प्राप्त किया जाता है जिनकी आय 4000 से अधिक है।

mysql> SELECT * FROM EMPLOYEE WHERE INCOME > 4000;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Raj        | Kandukuri | 20   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

जहां अजगर का उपयोग कर खंड

अजगर कार्यक्रम का उपयोग कर एक मेज से विशिष्ट रिकॉर्ड लाने के लिए -

आयात mysql.connector पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ mysql.connector.connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
एक कर्सर ऑब्जेक्ट बनाकर cursor() ऊपर बनाई गई कनेक्शन ऑब्जेक्ट पर विधि।
फिर, WHECT क्लॉज़ के साथ SELECT स्टेटमेंट को निष्पादित करें , इसे पैरामीटर के रूप में पास करकेexecute() तरीका।

उदाहरण

निम्नलिखित उदाहरण कर्मचारी नाम की एक तालिका बनाता है और इसे पॉप्युलेट करता है। फिर जहां क्लॉज का उपयोग करते हुए यह 23 से कम आयु मान के साथ रिकॉर्ड प्राप्त करता है।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 19, 'M', 2000), ('Raj', 'Kandukuri', 20, 'M', 7000),
('Ramya', 'Ramapriya', 25, 'F', 5000),('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

SELECT क्‍वेरी का उपयोग करके डेटा लाते समय, आप ऑर्डरब्रांड क्‍लॉज का उपयोग कर वांछित क्रम (आरोही या अवरोही) में परिणाम सॉर्ट कर सकते हैं। डिफ़ॉल्ट रूप से, यह क्लॉज़ आरोही क्रम में परिणाम देता है, यदि आपको उन्हें अवरोही क्रम में व्यवस्थित करने की आवश्यकता है तो आपको "DESC" का स्पष्ट रूप से उपयोग करने की आवश्यकता है।

वाक्य - विन्यास

निम्नलिखित सिंटैक्स सेलेक्ट कॉलम-सूची है

FROM table_name
[WHERE condition]
[ORDER BY column1, column2,.. columnN] [ASC | DESC]; of the ORDER BY clause:

उदाहरण

मान लें कि हमने MySQL में एक तालिका बनाई है जिसका नाम EMPLOYEES है -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 4 रिकॉर्ड डाले हैं -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

निम्नलिखित कथन आयु के आरोही क्रम में EMPLOYEE तालिका की सामग्री को पुनः प्राप्त करता है।

mysql> SELECT * FROM EMPLOYEE ORDER BY AGE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
| Mac        | Mohan     |   26 |    M |   2000 |
+------------+-----------+------+------+--------+
4 rows in set (0.04 sec)

आप DESC का उपयोग करके अवरोही क्रम में डेटा पुनः प्राप्त कर सकते हैं -

mysql> SELECT * FROM EMPLOYEE ORDER BY FIRST_NAME, INCOME DESC;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    |   19 |    M |   2000 |
| Mac        | Mohan     |   26 |    M |   2000 |
| Raj        | Kandukuri |   20 |    M |   7000 |
| Ramya      | Ramapriya |   25 |    F |   5000 |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

अजगर का उपयोग करके खंड द्वारा आदेश

विशिष्ट क्रम में तालिका की सामग्री प्राप्त करने के लिए, आह्वान करें execute() कर्सर ऑब्जेक्ट पर विधि और, ORDER BY क्लॉज़ के साथ सेलेक्ट स्टेटमेंट पास करें, इसके पैरामीटर के रूप में।

उदाहरण

निम्नलिखित उदाहरण में हम नाम और कर्मचारी के साथ एक तालिका बना रहे हैं, इसे पॉप्युलेट कर रहे हैं, और अपने रिकॉर्ड को उनकी उम्र के (आरोही) क्रम में वापस प्राप्त कर ORDER BY खंड का उपयोग कर रहे हैं।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"

data = [('Krishna', 'Sharma', 26, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 29, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

[('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0)
]

उसी तरह आप ORDER BY क्लॉज का उपयोग करके अवरोही क्रम में एक तालिका से डेटा पुनः प्राप्त कर सकते हैं।

उदाहरण

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving specific records using the ORDERBY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY INCOME DESC")
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

[('Raj', 'Kandukuri', 20, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000.0), 
   ('Krishna', 'Sharma', 26, 'M', 2000.0), 
   ('Mac', 'Mohan', 26, 'M', 2000.0)
]

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

वाक्य - विन्यास

MySQL में UPDATE स्टेटमेंट का सिंटैक्स निम्न है -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

आप AND या OR ऑपरेटर्स का उपयोग करके N की संख्या को जोड़ सकते हैं।

उदाहरण

मान लें कि हमने MySQL में एक तालिका बनाई है जिसका नाम EMPLOYEES है -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 4 रिकॉर्ड डाले हैं -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

MySQL स्टेटमेंट के बाद सभी पुरुष कर्मचारियों की उम्र एक साल बढ़ जाती है -

mysql> UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M';
Query OK, 3 rows affected (0.06 sec)
Rows matched: 3 Changed: 3 Warnings: 0

यदि आप तालिका की सामग्री को पुनः प्राप्त करते हैं, तो आप अद्यतन मान देख सकते हैं -

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
| Mac        | Mohan     | 27   | M    | 2000   |
+------------+-----------+------+------+--------+
4 rows in set (0.00 sec)

पायथन का उपयोग करके तालिका की सामग्री को अद्यतन करना

अजगर का उपयोग करके MySQL में एक तालिका में रिकॉर्ड अपडेट करने के लिए -

आयात mysql.connector पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ mysql.connector.connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
एक कर्सर ऑब्जेक्ट बनाकर cursor() ऊपर बनाई गई कनेक्शन ऑब्जेक्ट पर विधि।
फिर, इसे पैरामीटर के रूप में पास करके UPDATE विवरण निष्पादित करें execute() तरीका।

उदाहरण

निम्नलिखित उदाहरण सभी पुरुषों की आयु को एक वर्ष तक बढ़ाता है।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing the query to update the records
sql = '''UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M' '''
try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Rollback in case there is any error
   conn.rollback()
   
#Retrieving data
sql = '''SELECT * from EMPLOYEE'''

#Executing the query
cursor.execute(sql)

#Displaying the result
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0)
]

MySQL टेबल से रिकॉर्ड हटाने के लिए, आपको उपयोग करने की आवश्यकता है DELETE FROMबयान। विशिष्ट रिकॉर्ड को निकालने के लिए, आपको इसके साथ WHERE क्लॉज़ का उपयोग करना होगा।

वाक्य - विन्यास

MYSQL में DELETE क्वेरी का सिंटैक्स निम्नलिखित है -

DELETE FROM table_name [WHERE Clause]

उदाहरण

मान लें कि हमने MySQL में एक तालिका बनाई है जिसका नाम EMPLOYEES है -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 4 रिकॉर्ड डाले हैं -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

MySQL स्टेटमेंट के बाद FIRST_NAME "Mac" के साथ कर्मचारी का रिकॉर्ड हटा दिया जाता है।

mysql> DELETE FROM EMPLOYEE WHERE FIRST_NAME = 'Mac';
Query OK, 1 row affected (0.12 sec)

यदि आप तालिका की सामग्री को पुनः प्राप्त करते हैं, तो आप केवल 3 रिकॉर्ड देख सकते हैं क्योंकि हमने एक हटा दिया है।

mysql> select * from EMPLOYEE;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 20   | M    | 2000   |
| Raj        | Kandukuri | 21   | M    | 7000   |
| Ramya      | Ramapriya | 25   | F    | 5000   |
+------------+-----------+------+------+--------+
3 rows in set (0.00 sec)

यदि आप WHET खंड के बिना DELETE कथन को निष्पादित करते हैं, तो निर्दिष्ट तालिका से सभी रिकॉर्ड हटा दिए जाएंगे।

mysql> DELETE FROM EMPLOYEE;
Query OK, 3 rows affected (0.09 sec)

यदि आप तालिका की सामग्री पुनः प्राप्त करते हैं, तो आपको नीचे दिखाया गया एक खाली सेट मिलेगा -

mysql> select * from EMPLOYEE;
Empty set (0.00 sec)

अजगर का उपयोग कर एक मेज के रिकॉर्ड को हटाना

DELETE ऑपरेशन की आवश्यकता तब होती है जब आप अपने डेटाबेस से कुछ रिकॉर्ड हटाना चाहते हैं।

तालिका में रिकॉर्ड हटाने के लिए -

आयात mysql.connector पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ mysql.connector.connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
एक कर्सर ऑब्जेक्ट बनाकर cursor() ऊपर बनाई गई कनेक्शन ऑब्जेक्ट पर विधि।
फिर, निष्पादित करें DELETE यह एक पैरामीटर के रूप में पारित करके बयान execute() तरीका।

उदाहरण

निम्नलिखित कार्यक्रम EMPLOYEE से सभी रिकॉर्ड को हटा देता है, जिसका AGE 20 से अधिक है -

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
print("Contents of the table: ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Preparing the query to delete records
sql = "DELETE FROM EMPLOYEE WHERE AGE > '%d'" % (25)

try:
   # Execute the SQL command
   cursor.execute(sql)
   
   # Commit your changes in the database
   conn.commit()
except:
   # Roll back in case there is any error
   conn.rollback()

#Retrieving data
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

Contents of the table:
[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Ramya', 'Ramapriya', 26, 'F', 5000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0), 
   ('Ramya', 'Rama priya', 27, 'F', 9000.0)]

Contents of the table after delete operation:
[('Krishna', 'Sharma', 22, 'M', 2000.0), 
   ('Raj', 'Kandukuri', 23, 'M', 7000.0), 
   ('Mac', 'Mohan', 20, 'M', 2000.0)]

आप का उपयोग करके एक पूरी तालिका निकाल सकते हैं DROP TABLEबयान। आपको केवल उस तालिका का नाम निर्दिष्ट करना होगा जिसे आपको हटाने की आवश्यकता है।

वाक्य - विन्यास

MySQL में DROP TABLE स्टेटमेंट का सिंटैक्स निम्नलिखित है -

DROP TABLE table_name;

उदाहरण

तालिका हटाने से पहले निम्न तालिका विवरण का उपयोग करते हुए तालिकाओं की सूची प्राप्त करें -

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| sample          |
| tutorials       |
+-----------------+
5 rows in set (0.00 sec)

निम्नलिखित कथन डेटाबेस से नमूना नाम की तालिका को पूरी तरह से हटा देता है -

mysql> DROP TABLE sample;
Query OK, 0 rows affected (0.29 sec)

चूंकि हमने MySQL से सैंपल नाम की टेबल को डिलीट कर दिया है, अगर आपको टेबलों की सूची फिर से मिल जाती है तो आपको इसमें टेबल नेम सैंपल नहीं मिलेगा।

mysql> SHOW TABLES;
+-----------------+
| Tables_in_mydb  |
+-----------------+
| contact         |
| cricketers_data |
| employee        |
| tutorials       |
+-----------------+
4 rows in set (0.00 sec)

अजगर का उपयोग कर एक मेज को हटाना

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

अजगर का उपयोग कर एक MYSQL डेटाबेस से एक टेबल ड्रॉप करने के लिए तालिका को आह्वान करें execute() कर्सर ऑब्जेक्ट पर विधि और ड्रॉप स्टेटमेंट को एक पैरामीटर के रूप में पास करें।

उदाहरण

निम्नलिखित तालिका डेटाबेस से EMPLOYEE नामक एक तालिका को गिराती है।

import mysql.connector

#establishing the connection conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method 
cursor = conn.cursor()

#Retrieving the list of tables print("List of tables in the database: ") 
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Doping EMPLOYEE table if already exists cursor.execute
   ("DROP TABLE EMPLOYEE") print("Table dropped... ")

#Retrieving the list of tables print(
   "List of tables after dropping the EMPLOYEE table: ") 
   cursor.execute("SHOW Tables") print(cursor.fetchall())

#Closing the connection conn.close()

उत्पादन

List of tables in the database:
[('employee',), ('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',), ('tutorials',)]

ड्रॉप टेबल केवल मौजूद है

यदि आप डेटाबेस में मौजूद किसी तालिका को छोड़ने का प्रयास करते हैं, तो एक त्रुटि होती है -

mysql.connector.errors.ProgrammingError: 1051 (42S02): 
   Unknown table 'mydb.employee'

DELETE स्टेटमेंट में IF EXISTS को जोड़कर, टेबल को हटाने से पहले मौजूद है या नहीं, यह सत्यापित करके आप इस त्रुटि को रोक सकते हैं।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving the list of tables
print("List of tables in the database: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
print("Table dropped... ")

#Retrieving the list of tables
print("List of tables after dropping the EMPLOYEE table: ")
cursor.execute("SHOW Tables")
print(cursor.fetchall())

#Closing the connection
conn.close()

उत्पादन

List of tables in the database:
[('employeedata',), ('sample',), ('tutorials',)]
Table dropped...
List of tables after dropping the EMPLOYEE table:
[('employeedata',), ('sample',),
('tutorials',)]

रिकॉर्ड प्राप्त करते समय यदि आप उन्हें किसी विशेष संख्या द्वारा सीमित करना चाहते हैं, तो आप ऐसा कर सकते हैं, MYSQL के लिमट क्लॉज का उपयोग करके।

उदाहरण

मान लें कि हमने MySQL में एक तालिका बनाई है जिसका नाम EMPLOYEES है -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
);
Query OK, 0 rows affected (0.36 sec)

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 4 रिकॉर्ड डाले हैं -

mysql> INSERT INTO EMPLOYEE VALUES
   ('Krishna', 'Sharma', 19, 'M', 2000),
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'F', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000);

SQL स्टेटमेंट के बाद, LITIT क्लॉज का उपयोग करते हुए कर्मचारी तालिका के पहले दो रिकॉर्ड्स को पुनः प्राप्त करता है।

SELECT * FROM EMPLOYEE LIMIT 2;
+------------+-----------+------+------+--------+
| FIRST_NAME | LAST_NAME | AGE  | SEX  | INCOME |
+------------+-----------+------+------+--------+
| Krishna    | Sharma    | 19   | M    | 2000   |
| Raj        | Kandukuri | 20   | M    | 7000   |
+------------+-----------+------+------+--------+
2 rows in set (0.00 sec)

अजगर का उपयोग करते हुए क्लॉज को सीमित करें

यदि आप आह्वान करते हैं execute() लिमिट क्लॉज के साथ सेलेक्ट क्वेरी को पास करके कर्सर ऑब्जेक्ट पर विधि, आप आवश्यक संख्या में रिकॉर्ड पुनः प्राप्त कर सकते हैं।

उदाहरण

अजगर उदाहरण के बाद EMPLOYEE के नाम से एक तालिका बनाता है और उसे, इसके पहले दो रिकॉर्ड प्राप्त करता है लिमिट खंड का उपयोग करके।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

उत्पादन

[('Krishna', 'Sharma', 26, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

OFFSET के साथ सीमा

यदि आपको nth रिकॉर्ड (1 ^सेंट नहीं ) से शुरू होने वाले रिकॉर्ड को सीमित करने की आवश्यकता है , तो आप ऐसा कर सकते हैं, लिफ़िट के साथ OFFSET का उपयोग कर सकते हैं।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

उत्पादन

[('Ramya', 'Ramapriya', 29, 'F', 5000.0), ('Mac', 'Mohan', 26, 'M', 2000.0)]

जब आपने डेटा को दो तालिकाओं में विभाजित किया है तो आप जॉइन का उपयोग करके इन दो तालिकाओं से संयुक्त रिकॉर्ड प्राप्त कर सकते हैं।

उदाहरण

मान लीजिए कि हमने EMPLOYEE नाम से एक तालिका बनाई है और नीचे दिखाए गए अनुसार इसमें पॉपुलेटेड डेटा -

mysql> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT,
   CONTACT INT
);
Query OK, 0 rows affected (0.36 sec)
INSERT INTO Employee VALUES ('Ramya', 'Rama Priya', 27, 'F', 9000, 101), 
   ('Vinay', 'Bhattacharya', 20, 'M', 6000, 102), 
   ('Sharukh', 'Sheik', 25, 'M', 8300, 103), 
   ('Sarmista', 'Sharma', 26, 'F', 10000, 104), 
   ('Trupthi', 'Mishra', 24, 'F', 6000, 105);
Query OK, 5 rows affected (0.08 sec)
Records: 5 Duplicates: 0 Warnings: 0

फिर, यदि हमने एक और तालिका बनाई है और इसे इस रूप में पॉपुलेट किया है -

CREATE TABLE CONTACT(
   ID INT NOT NULL,
   EMAIL CHAR(20) NOT NULL,
   PHONE LONG,
   CITY CHAR(20)
);
Query OK, 0 rows affected (0.49 sec)

INSERT INTO CONTACT (ID, EMAIL, CITY) VALUES 
   (101, '[email protected]', 'Hyderabad'), 
   (102, '[email protected]', 'Vishakhapatnam'), 
   (103, '[email protected]', 'Pune'), 
   (104, '[email protected]', 'Mumbai');
Query OK, 4 rows affected (0.10 sec)
Records: 4 Duplicates: 0 Warnings: 0

निम्न कथन इन दो तालिकाओं में मूल्यों के संयोजन डेटा को पुनः प्राप्त करता है -

mysql> SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID;
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| FIRST_NAME | LAST_NAME    | AGE  | SEX  | INCOME | CONTACT | ID  | EMAIL              | PHONE | CITY           |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
| Ramya      | Rama Priya   | 27   | F    | 9000   | 101     | 101 | [email protected] | NULL  | Hyderabad      |
| Vinay      | Bhattacharya | 20   | M    | 6000   | 102     | 102 | [email protected]    | NULL  | Vishakhapatnam |
| Sharukh    | Sheik        | 25   | M    | 8300   | 103     | 103 | [email protected] | NULL  | Pune           |
| Sarmista   | Sharma       | 26   | F    | 10000  | 104     | 104 | [email protected]    | NULL  | Mumbai         |
+------------+--------------+------+------+--------+---------+-----+--------------------+-------+----------------+
4 rows in set (0.00 sec)

MYSQL जॉय अजगर का उपयोग कर

उदाहरण के बाद EMPLOYEE तालिका के संपर्क कॉलम और संपर्क तालिका के आईडी स्तंभ द्वारा संयुक्त उपरोक्त दो तालिकाओं से डेटा प्राप्त होता है।

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE INNER JOIN CONTACT ON EMPLOYEE.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Closing the connection
conn.close()

उत्पादन

[('Krishna', 'Sharma', 26, 'M', 2000, 101, 101, '[email protected]', 9848022338, 'Hyderabad'), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102, 102, '[email protected]', 9848022339, 'Vishakhapatnam'), 
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103, 103, '[email protected]', 9848022337, 'Pune'), 
   ('Mac', 'Mohan', 26, 'M', 2000, 104, 104, '[email protected]', 9848022330, 'Mumbai')]

MySQLCursor of mysql-कनेक्टर-python (और इसी तरह की लाइब्रेरी) का उपयोग MySQL डेटाबेस के साथ संवाद करने के लिए स्टेटमेंट्स निष्पादित करने के लिए किया जाता है।

इसके तरीकों का उपयोग करके आप SQL कथनों को निष्पादित कर सकते हैं, परिणाम सेट, कॉल प्रक्रियाओं से डेटा प्राप्त कर सकते हैं।

आप बना सकते हैं Cursor कनेक्शन ऑब्जेक्ट / क्लास के कर्सर () पद्धति का उपयोग करके ऑब्जेक्ट।

उदाहरण

import mysql.connector

#establishing the connection
conn = mysql.connector.connect(
   user='root', password='password', host='127.0.0.1', database='mydb'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

तरीकों

निम्नलिखित विभिन्न तरीके Cursor वर्ग / वस्तु द्वारा प्रदान किए गए हैं।

अनु क्रमांक	विधि और विवरण
1	callproc() इस विधि का उपयोग मौजूदा प्रक्रियाओं MySQL डेटाबेस को कॉल करने के लिए किया जाता है।
2	close() वर्तमान कर्सर ऑब्जेक्ट को बंद करने के लिए इस विधि का उपयोग किया जाता है।
3	Info() यह विधि अंतिम क्वेरी के बारे में जानकारी देती है।
4	executemany() यह विधि पैरामीटर सूची की सूची श्रृंखला को स्वीकार करती है। एक MySQL क्वेरी तैयार करता है और इसे सभी मापदंडों के साथ निष्पादित करता है।
5	execute() यह विधि एक पैरामीटर के रूप में MySQL क्वेरी को स्वीकार करती है और दिए गए क्वेरी को निष्पादित करती है।
6	fetchall() यह विधि किसी क्वेरी के परिणाम सेट में सभी पंक्तियों को पुनर्प्राप्त करती है और उन्हें टुपल्स की सूची के रूप में वापस करती है। (यदि हम इसे कुछ पंक्तियों को प्राप्त करने के बाद निष्पादित करते हैं तो यह शेष लोगों को वापस कर देता है)
7	fetchone() यह विधि क्वेरी के परिणाम में अगली पंक्ति लाती है और इसे टुप के रूप में लौटाती है।
8	fetchmany() यह विधि भ्रूण के समान है (), लेकिन यह एक पंक्ति के बजाय, क्वेरी के परिणाम सेट में पंक्तियों के अगले सेट को पुनः प्राप्त करता है।
9	etchwarnings() यह विधि अंतिम निष्पादित क्वेरी द्वारा उत्पन्न चेतावनियों को लौटाती है।

गुण

निम्नलिखित कर्सर श्रेणी के गुण हैं -

अनु क्रमांक	संपत्ति विवरण
1	column_names यह एक रीड ओनली प्रॉपर्टी है, जो रिजल्ट-सेट के कॉलम नामों वाली सूची को लौटाती है।
2	description यह एक रीड ओनली प्रॉपर्टी है, जो रिजल्ट-सेट में कॉलम के विवरण वाली सूची लौटाती है।
3	lastrowid यह एक रीड ओनली प्रॉपर्टी है, यदि टेबल में कोई ऑटो-इन्क्रिमेटेड कॉलम हैं, तो यह उस कॉलम के लिए उत्पन्न मूल्य को पिछले INSERT या, UPDATE ऑपरेशन में लौटाता है।
4	rowcount यह SELECT और UPDATE ऑपरेशन की स्थिति में लौटी / अपडेट की गई पंक्तियों की संख्या लौटाता है।
5	statement यह संपत्ति अंतिम निष्पादित विवरण लौटाती है।

इंस्टालेशन

PostgreSQL एक शक्तिशाली, ओपन सोर्स ऑब्जेक्ट-रिलेशनल डेटाबेस सिस्टम है। इसमें 15 साल से अधिक सक्रिय विकास चरण और एक सिद्ध वास्तुकला है जिसने इसे विश्वसनीयता, डेटा अखंडता और शुद्धता के लिए एक मजबूत प्रतिष्ठा अर्जित की है।

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

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

PIP का उपयोग करके Psycog2 को स्थापित करना

सबसे पहले, सुनिश्चित करें कि अजगर और पीआईपी आपके सिस्टम में ठीक से स्थापित है और, पीआईपी अप-टू-डेट है।

पीआईपी को अपग्रेड करने के लिए, कमांड प्रॉम्प्ट खोलें और निम्नलिखित कमांड निष्पादित करें -

C:\Users\Tutorialspoint>python -m pip install --upgrade pip
Collecting pip
Using cached https://files.pythonhosted.org/packages/8d/07/f7d7ced2f97ca3098c16565efbe6b15fafcba53e8d9bdb431e09140514b0/pip-19.2.2-py2.py3-none-any.whl
Installing collected packages: pip
Found existing installation: pip 19.0.3
Uninstalling pip-19.0.3:
Successfully uninstalled pip-19.0.3
Successfully installed pip-19.2.2

फिर, व्यवस्थापक मोड में कमांड प्रॉम्प्ट खोलें और निष्पादित करें pip install psycopg2-binary जैसा कि नीचे दिखाया गया है -

C:\WINDOWS\system32>pip install psycopg2-binary
Collecting psycopg2-binary
Using cached https://files.pythonhosted.org/packages/80/79/d0d13ce4c2f1addf4786f4a2ded802c2df66ddf3c1b1a982ed8d4cb9fc6d/psycopg2_binary-2.8.3-cp37-cp37m-win32.whl
Installing collected packages: psycopg2-binary
Successfully installed psycopg2-binary-2.8.3

सत्यापन

स्थापना को सत्यापित करने के लिए, इसमें निम्न पंक्ति के साथ एक नमूना अजगर स्क्रिप्ट बनाएं।

import mysql.connector

D:\Python_PostgreSQL>import psycopg2
D:\Python_PostgreSQL>

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

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

अजगर का उपयोग करके कनेक्शन स्थापित करना

का कनेक्शन वर्ग psycopg2किसी कनेक्शन की आवृत्ति का प्रतिनिधित्व / संभालता है। आप का उपयोग करके नए कनेक्शन बना सकते हैंconnect()समारोह। यह मूलभूत कनेक्शन पैरामीटर जैसे dbname, उपयोगकर्ता, पासवर्ड, होस्ट, पोर्ट को स्वीकार करता है और कनेक्शन ऑब्जेक्ट लौटाता है। इस फ़ंक्शन का उपयोग करके, आप PostgreSQL के साथ एक कनेक्शन स्थापित कर सकते हैं।

उदाहरण

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

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Executing an MYSQL function using the execute() method
cursor.execute("select version()")

# Fetch a single row using fetchone() method.
data = cursor.fetchone()
print("Connection established to: ",data)

#Closing the connection
conn.close()
Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

उत्पादन

Connection established to: (
   'PostgreSQL 11.5, compiled by Visual C++ build 1914, 64-bit',
)

आप CREATE DATABASE स्टेटमेंट का उपयोग करके PostgreSQL में एक डेटाबेस बना सकते हैं। कमांड के बाद बनाए जाने वाले डेटाबेस का नाम निर्दिष्ट करके आप पोस्टग्रेसीक्यूएल शेल प्रॉम्प्ट में इस कथन को निष्पादित कर सकते हैं।

वाक्य - विन्यास

इसके बाद CREAT DATABASE स्टेटमेंट का सिंटैक्स है।

CREATE DATABASE dbname;

उदाहरण

निम्न कथन PostgreSQL में testdb नाम का एक डेटाबेस बनाता है।

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

आप \ l कमांड का उपयोग करके डेटाबेस को PostgreSQL में सूचीबद्ध कर सकते हैं। यदि आप डेटाबेस की सूची को सत्यापित करते हैं, तो आप नए बनाए गए डेटाबेस को निम्नानुसार पा सकते हैं -

postgres=# \l
                                           List of databases
Name       | Owner    | Encoding | Collate                    | Ctype       |
-----------+----------+----------+----------------------------+-------------+
mydb       | postgres | UTF8     | English_United States.1252 | ........... |
postgres   | postgres | UTF8     | English_United States.1252 | ........... |
template0  | postgres | UTF8     | English_United States.1252 | ........... |
template1  | postgres | UTF8     | English_United States.1252 | ........... |
testdb     | postgres | UTF8     | English_United States.1252 | ........... |
(5 rows)

आप यह भी आदेश का उपयोग कमांड प्रॉम्प्ट से PostgreSQL में एक डेटाबेस बना सकते हैं createdb , एसक्यूएल बयान के चारों ओर एक आवरण डेटाबेस बनाएँ।

C:\Program Files\PostgreSQL\11\bin> createdb -h localhost -p 5432 -U postgres sampledb
Password:

अजगर का उपयोग कर एक डेटाबेस बनाना

Psycopg2 का कर्सर वर्ग विभिन्न पोस्टग्रेक्यूएल कमांड, विभिन्न रिकॉर्ड और कॉपी डेटा को निष्पादित करने के लिए विभिन्न तरीके प्रदान करता है। आप कनेक्शन वर्ग के कर्सर () पद्धति का उपयोग करके एक कर्सर ऑब्जेक्ट बना सकते हैं।

इस वर्ग का निष्पादन () विधि एक पैरामीटर के रूप में एक PostgreSQL क्वेरी को स्वीकार करता है और इसे निष्पादित करता है।

इसलिए, PostgreSQL में एक डेटाबेस बनाने के लिए, इस पद्धति का उपयोग करके क्रिएट डेटा बेस क्वेरी को निष्पादित करें।

उदाहरण

अजगर उदाहरण के बाद PostgreSQL डेटाबेस में mydb नाम का एक डेटाबेस बनाता है।

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="postgres", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Preparing query to create a database
sql = '''CREATE database mydb''';

#Creating a database
cursor.execute(sql)
print("Database created successfully........")

#Closing the connection
conn.close()

उत्पादन

Database created successfully........

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

वाक्य - विन्यास

PostgreSQL में क्रिएट टेबल स्टेटमेंट का सिंटैक्स निम्नलिखित है।

CREATE TABLE table_name(
   column1 datatype,
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype,
);

उदाहरण

उदाहरण के बाद PostgreSQL में CRICKETERS नाम से एक टेबल बनाता है।

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

आप PostgreSQL के डेटाबेस में तालिकाओं की सूची को \ dt कमांड का उपयोग करके प्राप्त कर सकते हैं। एक तालिका बनाने के बाद, यदि आप तालिकाओं की सूची को सत्यापित कर सकते हैं, तो आप इसमें नई बनाई गई तालिका का निरीक्षण कर सकते हैं -

postgres=# \dt
            List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
(1 row)
postgres=#

उसी तरह, आप नीचे दिखाए गए अनुसार \ d का उपयोग करके बनाई गई तालिका का विवरण प्राप्त कर सकते हैं -

postgres=# \d cricketers
               Table "public.cricketers"
Column          | Type                   | Collation | Nullable | Default
----------------+------------------------+-----------+----------+---------
first_name      | character varying(255) |           |          |
last_name       | character varying(255) |           |          |
age             | integer                |           |          |
place_of_birth  | character varying(255) |           |          |
country         | character varying(255) |           |          |
postgres=#

अजगर का उपयोग कर एक तालिका बनाना

अजगर का उपयोग करके एक तालिका बनाने के लिए आपको pyscopg2 के कर्सर के निष्पादन () विधि का उपयोग करके क्रिएट टेबल स्टेटमेंट को निष्पादित करना होगा ।

उदाहरण

निम्नलिखित पायथन उदाहरण नाम कर्मचारी के साथ एक तालिका बनाता है।

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

#Closing the connection
conn.close()

उत्पादन

Table created successfully........

आप का उपयोग कर PostgreSQL में एक मौजूदा तालिका में रिकॉर्ड सम्मिलित कर सकते हैं INSERT INTOबयान। इसे निष्पादित करते समय, आपको तालिका का नाम, और इसमें कॉलम के लिए मान निर्दिष्ट करने की आवश्यकता है।

वाक्य - विन्यास

निम्नलिखित INSERT बयान की सिफारिश की वाक्य रचना है -

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

जहाँ, column1, column2, column3, .. एक तालिका के स्तंभों के नाम हैं, और value1, value2, value3, ... वे मान हैं जिन्हें आपको तालिका में सम्मिलित करने की आवश्यकता है।

उदाहरण

मान लें कि हमने नीचे दिखाए गए अनुसार क्रेट टेबल स्टेटमेंट का उपयोग करके क्रिकेटर नाम से एक टेबल बनाई है -

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age INT,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
CREATE TABLE
postgres=#

PostgreSQL स्टेटमेंट के बाद उपरोक्त बनाई गई तालिका में एक पंक्ति सम्मिलित होती है -

postgres=# insert into CRICKETERS (
   First_Name, Last_Name, Age, Place_Of_Birth, Country) 
   values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=#

INSERT INTO स्टेटमेंट का उपयोग करते हुए रिकॉर्ड सम्मिलित करते समय , यदि आप किसी भी कॉलम के नाम को छोड़ते हैं, तो रिकॉर्ड को कॉलम में खाली स्थानों को छोड़कर डाला जाएगा, जिसे आपने छोड़ दिया है।

postgres=# insert into CRICKETERS (First_Name, Last_Name, Country) 
   values('Jonathan', 'Trott', 'SouthAfrica');
INSERT 0 1

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

postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1
postgres=#

अभिलेखों को एक तालिका में सम्मिलित करने के बाद, आप नीचे दिखाए गए अनुसार चयन कथन का उपयोग करके इसकी सामग्री को सत्यापित कर सकते हैं -

postgres=# SELECT * from CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      |     |                | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)

अजगर का उपयोग कर डेटा सम्मिलित करना

Psycopg2 का कर्सर वर्ग नाम निष्पादित () विधि के साथ एक विधि प्रदान करता है। यह विधि क्वेरी को एक पैरामीटर के रूप में स्वीकार करती है और इसे निष्पादित करती है।

इसलिए, अजगर का उपयोग करके PostgreSQL में एक तालिका में डेटा सम्मिलित करने के लिए -

आयात psycopg2 पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
विशेषता के मान के रूप में गलत सेट करके ऑटो-कम मोड को बंद करें autocommit।
cursor() की विधि Connectionpsycopg2 लाइब्रेरी का क्लास एक कर्सर ऑब्जेक्ट देता है। इस पद्धति का उपयोग करके एक कर्सर ऑब्जेक्ट बनाएं।
फिर, इसे निष्पादित करने के लिए एक पैरामीटर के रूप में / उन्हें पारित करके INSERT विवरण (ओं) को निष्पादित करें (विधि)।

उदाहरण

पायथन कार्यक्रम के बाद PostgreSQL डेटाबेस में EMPLOYEE के नाम के साथ एक तालिका बनाता है और इसे निष्पादित () विधि का उपयोग करके रिकॉर्ड सम्मिलित करता है -

import psycopg2

#Establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Ramya', 'Rama priya', 27, 'F', 9000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Vinay', 'Battacharya', 20, 'M', 6000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sharukh', 'Sheik', 25, 'M', 8300)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Sarmista', 'Sharma', 26, 'F', 10000)''')
cursor.execute('''INSERT INTO EMPLOYEE(FIRST_NAME, LAST_NAME, AGE, SEX,
   INCOME) VALUES ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

उत्पादन

Records inserted........

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

वाक्य - विन्यास

PostgreSQL में SELECT स्टेटमेंट का सिंटैक्स निम्नलिखित है -

SELECT column1, column2, columnN FROM table_name;

उदाहरण

मान लें कि हमने निम्नलिखित क्वेरी का उपयोग करके CRICKETERS नाम के साथ एक तालिका बनाई है -

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

सेलेक्ट क्वेरी के बाद कॉलम FIRST_NAME, LAST_NAME और, CRICKETERS तालिका से COUNTRY के मूल्यों को पुनः प्राप्त करता है।

postgres=# SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
first_name  | last_name  | country
------------+------------+-------------
Shikhar     | Dhawan     | India
Jonathan    | Trott      | SouthAfrica
Kumara      | Sangakkara | Srilanka
Virat       | Kohli      | India
Rohit       | Sharma     | India
(5 rows)

यदि आप प्रत्येक रिकॉर्ड के सभी स्तंभों को पुनः प्राप्त करना चाहते हैं, तो आपको स्तंभों के नामों को "*" से बदलना होगा जैसा कि नीचे दिखाया गया है -

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(5 rows)
postgres=#

अजगर का उपयोग कर डेटा पुनर्प्राप्त कर रहा है

किसी भी डेटाबेस पर पढ़ें ऑपरेशन का मतलब डेटाबेस से कुछ उपयोगी जानकारी प्राप्त करना है। Psycopg2 द्वारा प्रदान की गई विधि () विधि का उपयोग करके आप PostgreSQL से डेटा प्राप्त कर सकते हैं।

Cursor वर्ग तीन तरीके प्रदान करता है जैसे कि fetchall (), fetchmany () और, fetchone () जहां

भ्रूण () विधि एक क्वेरी के परिणाम सेट में सभी पंक्तियों को पुनः प्राप्त करती है और उन्हें टुपल्स की सूची के रूप में वापस करती है। (यदि हम कुछ पंक्तियों को प्राप्त करने के बाद इसे निष्पादित करते हैं, तो यह शेष लोगों को वापस कर देता है)।
भ्रूण () विधि एक क्वेरी के परिणाम में अगली पंक्ति लाती है और इसे एक टुपल के रूप में वापस करती है।
Fetchmany () विधि fetchone () के समान है, लेकिन, यह एक पंक्ति के बजाय किसी क्वेरी के परिणाम सेट में पंक्तियों के अगले सेट को पुनः प्राप्त करता है।

उदाहरण

निम्नलिखित पायथन प्रोग्राम PostgreSQL के mydb नाम के डेटाबेस से जुड़ता है और EMPLOYEE नाम की तालिका से सभी रिकॉर्ड को पुनः प्राप्त करता है।

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
('Sharukh', 'Sheik', 25, 'M', 8300.0),
('Sarmista', 'Sharma', 26, 'F', 10000.0),
('Tripthi', 'Mishra', 24, 'F', 6000.0)]

SELECT, UPDATE या DELETE संचालन करते समय, आप WHERE क्लॉज का उपयोग करके रिकॉर्ड को फ़िल्टर करने के लिए शर्त निर्दिष्ट कर सकते हैं। ऑपरेशन उन अभिलेखों पर किया जाएगा जो दी गई स्थिति को संतुष्ट करते हैं।

वाक्य - विन्यास

PostgreSQL में WHERE क्लॉज का वाक्य विन्यास निम्नलिखित है -

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

आप तुलना या तार्किक ऑपरेटरों का उपयोग करके एक search_condition निर्दिष्ट कर सकते हैं। जैसे>, <, =, LIKE, NOT, आदि निम्नलिखित उदाहरण इस अवधारणा को स्पष्ट करेंगे।

उदाहरण

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

SELECT स्टेटमेंट के बाद उन रिकॉर्ड्स को पुनः प्राप्त किया जाता है जिनकी उम्र 35 से अधिक है -

postgres=# SELECT * FROM CRICKETERS WHERE AGE > 35;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(2 rows)
postgres=#

जहां अजगर का उपयोग कर खंड

पायथन प्रोग्राम का उपयोग करके किसी तालिका से विशिष्ट रिकॉर्ड प्राप्त करने के लिए WHERE क्लॉज़ के साथ SELECT स्टेटमेंट निष्पादित करें, इसे एक पैरामीटर के रूप में पास करके execute() तरीका।

उदाहरण

अजगर उदाहरण के बाद अजगर का उपयोग करते हुए WHERE कमांड के उपयोग को दर्शाता है।

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) 
   VALUES (%s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 19, 'M', 2000), 
   ('Raj', 'Kandukuri', 20, 'M', 7000),
   ('Ramya', 'Ramapriya', 25, 'M', 5000),
   ('Mac', 'Mohan', 26, 'M', 2000)]
cursor.executemany(insert_stmt, data)

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Krishna', 'Sharma', 19, 'M', 2000.0), ('Raj', 'Kandukuri', 20, 'M', 7000.0)]

आमतौर पर यदि आप किसी तालिका से डेटा पुनर्प्राप्त करने का प्रयास करते हैं, तो आपको रिकॉर्ड उसी क्रम में मिलेंगे, जिसमें आपने उन्हें सम्मिलित किया है।

का उपयोग करते हुए ORDER BY खंड, एक तालिका के रिकॉर्ड को प्राप्त करते समय आप परिणामी रिकॉर्ड को वांछित कॉलम के आधार पर आरोही या अवरोही क्रम में सॉर्ट कर सकते हैं।

वाक्य - विन्यास

PostgreSQL में ORDER BY क्लॉज का वाक्य विन्यास निम्नलिखित है।

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

उदाहरण

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

चयनित चयन के बाद उनकी आयु के बढ़ते क्रम में CRICKETERS तालिका की पंक्तियों को पुनः प्राप्त किया जाता है -

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)es:

तालिका के रिकॉर्ड को सॉर्ट करने के लिए आप एक से अधिक कॉलम का उपयोग कर सकते हैं। सेलेक्ट स्टेटमेंट के बाद कॉलम उम्र और FIRST_NAME के आधार पर CRICKETERS तालिका के रिकॉर्ड को सॉर्ट करें।

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(5 rows)

डिफ़ॉल्ट रूप से, ORDER BYखण्ड आरोही क्रम में तालिका के अभिलेखों को क्रमबद्ध करता है। आप DESC का उपयोग करके अवरोही क्रम में परिणामों की व्यवस्था कर सकते हैं -

postgres=# SELECT * FROM CRICKETERS ORDER BY AGE DESC;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Shikhar     | Dhawan     | 33  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
Virat       | Kohli      | 30  | Delhi          | India
(5 rows)

अजगर का उपयोग करके खंड द्वारा आदेश

विशिष्ट क्रम में एक तालिका की सामग्री को पुनः प्राप्त करने के लिए, कर्सर ऑब्जेक्ट पर निष्पादित () विधि को लागू करें और, ORDER BY खंड के साथ चयन कथन को इसके पैरामीटर के रूप में पास करें।

उदाहरण

निम्नलिखित उदाहरण में, हम नाम और कर्मचारी के साथ एक तालिका बना रहे हैं, इसे पॉप्युलेट कर रहे हैं, और अपने रिकॉर्ड को उनकी उम्र के (आरोही) क्रम में वापस प्राप्त कर ORDER BY खंड का उपयोग कर रहे हैं।

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
insert_stmt = "INSERT INTO EMPLOYEE (
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME, CONTACT) VALUES 
   (%s, %s, %s, %s, %s, %s)"
data = [('Krishna', 'Sharma', 26, 'M', 2000, 101), 
   ('Raj', 'Kandukuri', 20, 'M', 7000, 102),
   ('Ramya', 'Ramapriya', 29, 'F', 5000, 103),
   ('Mac', 'Mohan', 26, 'M', 2000, 104)]
cursor.executemany(insert_stmt, data)
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]

आप UPDATE कथन का उपयोग करके PostgreSQL में एक तालिका के मौजूदा रिकॉर्ड की सामग्री को संशोधित कर सकते हैं। विशिष्ट पंक्तियों को अपडेट करने के लिए, आपको इसके साथ WHERE क्लॉज का उपयोग करना होगा।

वाक्य - विन्यास

PostgreSQL में UPDATE स्टेटमेंट का सिंटैक्स निम्नलिखित है -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

उदाहरण

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

postgres=# insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

निम्नलिखित कथन क्रिकेटर की आयु को संशोधित करता है, जिसका पहला नाम है Shikhar -

postgres=# UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
UPDATE 1
postgres=#

यदि आप उस रिकॉर्ड को पुनः प्राप्त करते हैं जिसका FIRST_NAME शिखर है, तो आप देखते हैं कि आयु मान 45 में बदल दिया गया है -

postgres=# SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
Shikhar     | Dhawan    | 45  | Delhi          | India
(1 row)
postgres=#

यदि आपने WHERE क्लॉज का उपयोग नहीं किया है, तो सभी रिकॉर्ड के मान अपडेट किए जाएंगे। UPDATE के बयान के बाद CRICKETERS तालिका में सभी रिकॉर्डों की आयु 1 से बढ़ जाती है -

postgres=# UPDATE CRICKETERS SET AGE = AGE+1;
UPDATE 5

यदि आप SELECT कमांड का उपयोग करके तालिका की सामग्री को पुनः प्राप्त करते हैं, तो आप अद्यतन मानों को देख सकते हैं -

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Jonathan    | Trott      | 39  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 42  | Matale         | Srilanka
Virat       | Kohli      | 31  | Delhi          | India
Rohit       | Sharma     | 33  | Nagpur         | India
Shikhar     | Dhawan     | 46  | Delhi          | India
(5 rows)

अजगर का उपयोग करके रिकॉर्ड अपडेट करना

इसलिए, अजगर का उपयोग करके PostgreSQL में एक तालिका में डेटा सम्मिलित करने के लिए -

आयात psycopg2 पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
विशेषता के मान के रूप में गलत सेट करके ऑटो-कम मोड को बंद करें autocommit।
cursor() की विधि Connectionpsycopg2 लाइब्रेरी का क्लास एक कर्सर ऑब्जेक्ट देता है। इस पद्धति का उपयोग करके एक कर्सर ऑब्जेक्ट बनाएं।
फिर, निष्पादित () विधि के लिए एक पैरामीटर के रूप में पास करके अद्यतन विवरण को निष्पादित करें।

उदाहरण

पायथन कोड के बाद कर्मचारी तालिका की सामग्री को अद्यतन करता है और परिणाम प्राप्त करता है -

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Updating the records
sql = "UPDATE EMPLOYEE SET AGE = AGE + 1 WHERE SEX = 'M'"
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
sql = '''SELECT * from EMPLOYEE'''
cursor.execute(sql)
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]

आप किसी मौजूदा तालिका में रिकॉर्ड का उपयोग करके हटा सकते हैं DELETE FROMPostgreSQL डेटाबेस का विवरण। विशिष्ट रिकॉर्ड को निकालने के लिए, आपको इसके साथ WHERE क्लॉज़ का उपयोग करना होगा।

वाक्य - विन्यास

PostgreSQL में DELETE क्वेरी का सिंटैक्स निम्नलिखित है -

DELETE FROM table_name [WHERE Clause]

उदाहरण

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), 
   Age int, Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

निम्नलिखित कथन से उस क्रिकेटर का रिकॉर्ड नष्ट हो जाता है जिसका अंतिम नाम 'संगकारा' है। -

postgres=# DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
DELETE 1

यदि आप SELECT स्टेटमेंट का उपयोग करके तालिका की सामग्री को पुनः प्राप्त करते हैं, तो आप केवल 4 रिकॉर्ड देख सकते हैं क्योंकि हमने एक को हटा दिया है।

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+-------------
Jonathan    | Trott     | 39  | CapeTown       | SouthAfrica
Virat       | Kohli     | 31  | Delhi          | India
Rohit       | Sharma    | 33  | Nagpur         | India
Shikhar     | Dhawan    | 46  | Delhi          | India
(4 rows)

यदि आप DELETE FROM स्टेटमेंट को निष्पादित करते हैं तो WHERE क्लॉज के बिना निर्दिष्ट तालिका से सभी रिकॉर्ड हटा दिए जाएंगे।

postgres=# DELETE FROM CRICKETERS;
DELETE 4

चूंकि आपने सभी रिकॉर्ड हटा दिए हैं, अगर आप क्रिकेटर तालिका की सामग्री को पुनः प्राप्त करने का प्रयास करते हैं, तो सेलेक्ट स्टेटमेंट का उपयोग करके आपको नीचे दिखाए गए अनुसार एक खाली परिणाम सेट मिलेगा -

postgres=# SELECT * FROM CRICKETERS;
first_name  | last_name | age | place_of_birth | country
------------+-----------+-----+----------------+---------
(0 rows)

अजगर का उपयोग कर डेटा हटाना

इसलिए, अजगर का उपयोग करके PostgreSQL में एक तालिका में डेटा सम्मिलित करने के लिए -

आयात psycopg2 पैकेज।
का उपयोग कर एक कनेक्शन ऑब्जेक्ट बनाएँ connect() विधि, उपयोगकर्ता नाम, पासवर्ड, होस्ट (वैकल्पिक डिफ़ॉल्ट: लोकलहोस्ट) और, डेटाबेस (वैकल्पिक) को मापदंडों के रूप में पारित करके।
विशेषता के मान के रूप में गलत सेट करके ऑटो-कम मोड को बंद करें autocommit।
cursor()Psycopg2 लाइब्रेरी के कनेक्शन वर्ग की विधि एक कर्सर ऑब्जेक्ट लौटाती है। इस पद्धति का उपयोग करके एक कर्सर ऑब्जेक्ट बनाएं।
फिर, निष्पादित () विधि के लिए एक पैरामीटर के रूप में पास करके अद्यतन विवरण को निष्पादित करें।

उदाहरण

निम्नलिखित पायथन कोड 25 से अधिक उम्र के मूल्यों के साथ EMPLOYEE तालिका के रिकॉर्ड को हटाता है -

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0)]
Contents of the table after delete operation:
[('Tripthi', 'Mishra', 24, 'F', 6000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0)]

आप DROP टेबल स्टेटमेंट का उपयोग करके PostgreSQL डेटाबेस से एक टेबल ड्रॉप कर सकते हैं।

वाक्य - विन्यास

PostgreSQL में DROP टेबल स्टेटमेंट का सिंटैक्स निम्नलिखित है -

DROP TABLE table_name;

उदाहरण

मान लें कि हमने निम्नलिखित प्रश्नों का उपयोग करके CRICKETERS और EMPLOYEES नाम से दो तालिकाएँ बनाई हैं -

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#
postgres=# CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
CREATE TABLE
postgres=#

अब यदि आप "\ dt" कमांड का उपयोग करते हुए तालिकाओं की सूची को सत्यापित करते हैं, तो आप ऊपर बनाई गई तालिकाओं को देख सकते हैं -

postgres=# \dt;
List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
public  | employee   | table | postgres
(2 rows)
postgres=#

निम्नलिखित कथन डेटाबेस से कर्मचारी नाम की तालिका को हटाता है -

postgres=# DROP table employee;
DROP TABLE

चूंकि आपने कर्मचारी तालिका को हटा दिया है, यदि आप फिर से तालिकाओं की सूची प्राप्त करते हैं, तो आप इसमें केवल एक तालिका देख सकते हैं।

postgres=# \dt;
List of relations
Schema  | Name       | Type  | Owner
--------+------------+-------+----------
public  | cricketers | table | postgres
(1 row)
postgres=#

यदि आप कर्मचारी तालिका को फिर से हटाने की कोशिश करते हैं, क्योंकि आपने पहले ही इसे हटा दिया है, तो आपको यह कहते हुए एक त्रुटि मिलेगी कि "तालिका मौजूद नहीं है" जैसा कि नीचे दिखाया गया है -

postgres=# DROP table employee;
ERROR: table "employee" does not exist
postgres=#

इसे हल करने के लिए, आप DELTE स्टेटमेंट के साथ IF EXISTS क्लॉज का उपयोग कर सकते हैं। यह तालिका को हटा देता है यदि यह मौजूद है तो DLETE ऑपरेशन को छोड़ देता है।

postgres=# DROP table IF EXISTS employee;
NOTICE: table "employee" does not exist, skipping
DROP TABLE
postgres=#

पायथन का उपयोग करके एक पूरी तालिका को निकालना

DROP स्टेटमेंट का उपयोग करके आपको जब भी जरूरत हो एक टेबल ड्रॉप कर सकते हैं। लेकिन आपको किसी भी मौजूदा तालिका को हटाते समय बहुत सावधानी बरतने की आवश्यकता है क्योंकि किसी तालिका को हटाने के बाद खोए गए डेटा को पुनर्प्राप्त नहीं किया जाएगा।

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

#Table dropped...

PostgreSQL सेलेक्ट स्टेटमेंट को निष्पादित करते समय आप लिमट क्लॉज का उपयोग करके इसके परिणाम में रिकॉर्ड की संख्या को सीमित कर सकते हैं।

वाक्य - विन्यास

PostgreSQL में LMIT क्लॉज का वाक्य विन्यास निम्नलिखित है -

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

उदाहरण

postgres=# CREATE TABLE CRICKETERS ( 
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
CREATE TABLE
postgres=#

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

postgres=# insert into CRICKETERS values ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Virat', 'Kohli', 30, 'Delhi', 'India');
INSERT 0 1
postgres=# insert into CRICKETERS values ('Rohit', 'Sharma', 32, 'Nagpur', 'India');
INSERT 0 1

निम्नलिखित कथन लिमिट क्लॉज का उपयोग करके क्रिकेटरों की तालिका के पहले 3 रिकॉर्डों को पुनः प्राप्त करता है -

postgres=# SELECT * FROM CRICKETERS LIMIT 3;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+-------------
Shikhar     | Dhawan     | 33  | Delhi          | India
Jonathan    | Trott      | 38  | CapeTown       | SouthAfrica
Kumara      | Sangakkara | 41  | Matale         | Srilanka
(3 rows)

यदि आप एक विशेष रिकॉर्ड (ऑफसेट) से शुरू होने वाले रिकॉर्ड प्राप्त करना चाहते हैं, तो आप ऐसा कर सकते हैं, लिफ़िट के साथ OFFSET क्लॉज़ का उपयोग करके।

postgres=# SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
first_name  | last_name  | age | place_of_birth | country
------------+------------+-----+----------------+----------
Kumara      | Sangakkara | 41  | Matale         | Srilanka
Virat       | Kohli      | 30  | Delhi          | India
Rohit       | Sharma     | 32  | Nagpur         | India
(3 rows)
postgres=#

अजगर का उपयोग करते हुए क्लॉज को सीमित करें

पायथन उदाहरण के बाद EMPLOYEE नाम की एक तालिका की सामग्री प्राप्त होती है, जो 2 के परिणाम में रिकॉर्ड की संख्या को सीमित करती है -

उदाहरण

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 2 OFFSET 2'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Sharukh', 'Sheik', 25, 'M', 8300.0), ('Sarmista', 'Sharma', 26, 'F', 10000.0)]

उदाहरण

मान लें कि हमने CRICKETERS नाम से एक तालिका बनाई है और उसमें 5 रिकॉर्ड डाले हैं, जैसा कि नीचे दिखाया गया है -

postgres=# CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
postgres=# insert into CRICKETERS values (
   'Shikhar', 'Dhawan', 33, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica'
);
postgres=# insert into CRICKETERS values (
   'Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka'
);
postgres=# insert into CRICKETERS values (
   'Virat', 'Kohli', 30, 'Delhi', 'India'
);
postgres=# insert into CRICKETERS values (
   'Rohit', 'Sharma', 32, 'Nagpur', 'India'
);

और, अगर हमने OdiStats नाम से एक और तालिका बनाई है और उसमें 5 रिकॉर्ड डाले हैं -

postgres=# CREATE TABLE ODIStats (
   First_Name VARCHAR(255), Matches INT, Runs INT, AVG FLOAT, 
   Centuries INT, HalfCenturies INT
);
postgres=# insert into OdiStats values ('Shikhar', 133, 5518, 44.5, 17, 27);
postgres=# insert into OdiStats values ('Jonathan', 68, 2819, 51.25, 4, 22);
postgres=# insert into OdiStats values ('Kumara', 404, 14234, 41.99, 25, 93);
postgres=# insert into OdiStats values ('Virat', 239, 11520, 60.31, 43, 54);
postgres=# insert into OdiStats values ('Rohit', 218, 8686, 48.53, 24, 42);

निम्न कथन इन दो तालिकाओं में मूल्यों के संयोजन डेटा को पुनः प्राप्त करता है -

postgres=# SELECT
Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
first_name  | last_name  | country     | matches | runs  | centuries | halfcenturies
------------+------------+-------------+---------+-------+-----------+---------------
Shikhar     | Dhawan     | India       | 133     | 5518  | 17        | 27
Jonathan    | Trott      | SouthAfrica | 68      | 2819  | 4         | 22
Kumara      | Sangakkara | Srilanka    | 404     | 14234 | 25        | 93
Virat       | Kohli      | India       | 239     | 11520 | 43        | 54
Rohit       | Sharma     | India       | 218     | 8686  | 24        | 42
(5 rows)
postgres=#

अजगर का उपयोग कर जुड़ता है

उदाहरण

अजगर कार्यक्रम के बाद जॉय खंड के उपयोग को दर्शाता है -

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102, '[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected] ', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]

Psycopg लाइब्रेरी के कर्सर वर्ग को अजगर कोड का उपयोग करके डेटाबेस में PostgreSQL कमांड को निष्पादित करने के तरीके प्रदान करते हैं।

उदाहरण

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)

#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

तरीकों

निम्नलिखित विभिन्न तरीके Cursor वर्ग / वस्तु द्वारा प्रदान किए गए हैं।

अनु क्रमांक	विधि और विवरण
1	callproc() इस विधि का उपयोग मौजूदा प्रक्रियाओं PostgreSQL डेटाबेस को कॉल करने के लिए किया जाता है।
2	close() वर्तमान कर्सर ऑब्जेक्ट को बंद करने के लिए इस विधि का उपयोग किया जाता है।
3	executemany() यह विधि पैरामीटर सूची की सूची श्रृंखला को स्वीकार करती है। एक MySQL क्वेरी तैयार करता है और इसे सभी मापदंडों के साथ निष्पादित करता है।
4	execute() यह विधि एक पैरामीटर के रूप में MySQL क्वेरी को स्वीकार करती है और दिए गए क्वेरी को निष्पादित करती है।
5	fetchall() यह विधि किसी क्वेरी के परिणाम सेट में सभी पंक्तियों को पुनर्प्राप्त करती है और उन्हें टुपल्स की सूची के रूप में वापस करती है। (यदि हम इसे कुछ पंक्तियों को प्राप्त करने के बाद निष्पादित करते हैं तो यह शेष लोगों को वापस कर देता है)
6	fetchone() यह विधि क्वेरी के परिणाम में अगली पंक्ति लाती है और इसे टुप के रूप में लौटाती है।
7	fetchmany() यह विधि भ्रूण के समान है (), लेकिन यह एक पंक्ति के बजाय, क्वेरी के परिणाम सेट में पंक्तियों के अगले सेट को पुनः प्राप्त करता है।

गुण

निम्नलिखित कर्सर श्रेणी के गुण हैं -

अनु क्रमांक	संपत्ति विवरण
1	description यह एक रीड ओनली प्रॉपर्टी है, जो रिजल्ट-सेट में कॉलम के विवरण वाली सूची लौटाती है।
2	astrowid यह एक रीड ओनली प्रॉपर्टी है, यदि टेबल में कोई ऑटो-इन्क्रिमेटेड कॉलम हैं, तो यह उस कॉलम के लिए उत्पन्न मूल्य को पिछले INSERT या, UPDATE ऑपरेशन में लौटाता है।
3	rowcount यह SELECT और UPDATE ऑपरेशन की स्थिति में लौटी / अपडेट की गई पंक्तियों की संख्या लौटाता है।
4	closed यह गुण निर्दिष्ट करता है कि कोई कर्सर बंद है या नहीं, यदि ऐसा है तो यह सही है, अन्यथा गलत है।
5	connection यह कनेक्शन ऑब्जेक्ट का संदर्भ देता है जिसके उपयोग से यह कर्सर बनाया गया था।
6	name यह संपत्ति कर्सर का नाम लौटाती है।
7	scrollable यह गुण निर्दिष्ट करता है कि क्या कोई विशेष कर्सर स्क्रॉल करने योग्य है।

इंस्टालेशन

SQLite3 को sqlite3 मॉड्यूल का उपयोग करके पायथन के साथ एकीकृत किया जा सकता है, जिसे गेरहार्ड हारिंग ने लिखा था। यह PEP 249 द्वारा वर्णित DB-API 2.0 विनिर्देश के साथ एक SQL इंटरफ़ेस अनुपालन प्रदान करता है। आपको इस मॉड्यूल को अलग से स्थापित करने की आवश्यकता नहीं है क्योंकि यह डिफ़ॉल्ट रूप से Python संस्करण 2.5.x के साथ भेज दिया गया है।

Sqlite3 मॉड्यूल का उपयोग करने के लिए, आपको पहले एक कनेक्शन ऑब्जेक्ट बनाना होगा जो डेटाबेस का प्रतिनिधित्व करता है और फिर वैकल्पिक रूप से आप एक कर्सर ऑब्जेक्ट बना सकते हैं, जो आपको सभी SQL स्टेटमेंट को निष्पादित करने में मदद करेगा।

पायथन sqlite3 मॉड्यूल एपीआई

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

अनु क्रमांक।	एपीआई और विवरण
1	sqlite3.connect(database [,timeout ,other optional arguments]) यह एपीआई SQLite डेटाबेस फ़ाइल के लिए एक कनेक्शन खोलता है। आप एक डेटाबेस से डेटाबेस कनेक्शन खोलने के लिए ": मेमोरी:" का उपयोग कर सकते हैं जो डिस्क पर ऑन करने के बजाय रैम में रहता है। यदि डेटाबेस सफलतापूर्वक खोला गया है, तो यह कनेक्शन ऑब्जेक्ट लौटाता है।
2	connection.cursor([cursorClass]) यह रूटीन बनाता है cursorजिसे आपके डेटाबेस प्रोग्रामिंग में पायथन के साथ उपयोग किया जाएगा। यह विधि एकल वैकल्पिक पैरामीटर कर्सरक्लास को स्वीकार करती है। यदि आपूर्ति की जाती है, तो यह एक कस्टम कर्सर क्लास होना चाहिए जो sqlite3.Cursor का विस्तार करता है।
3	cursor.execute(sql [, optional parameters]) यह रूटीन SQL कथन निष्पादित करता है। SQL स्टेटमेंट को पैरामीटराइज़ किया जा सकता है (यानी SQL लीटर के बजाय प्लेसहोल्डर)। Sqlite3 मॉड्यूल दो प्रकार के प्लेसहोल्डर्स का समर्थन करता है: प्रश्न चिह्न और नामित प्लेसहोल्डर (नाम शैली)। For example - RPG.execute ("लोगों के मानों में डालें (?)?", (कौन, उम्र)
4	connection.execute(sql [, optional parameters]) यह दिनचर्या कर्सर ऑब्जेक्ट द्वारा प्रदान की गई उपरोक्त निष्पादित विधि का एक शॉर्टकट है और यह कर्सर विधि को कॉल करके एक मध्यवर्ती कर्सर ऑब्जेक्ट बनाता है, फिर कर्सर के निष्पादित विधि को दिए गए मापदंडों के साथ कॉल करता है।
5	cursor.executemany(sql, seq_of_parameters) यह दिनचर्या अनुक्रम sql में पाए जाने वाले सभी पैरामीटर अनुक्रमों या मैपिंग के विरुद्ध SQL कमांड निष्पादित करता है।
6	connection.executemany(sql[, parameters]) यह दिनचर्या एक शॉर्टकट है जो कर्सर विधि को कॉल करके एक इंटरमीडिएट कर्सर ऑब्जेक्ट बनाता है, फिर दिए गए मापदंडों के साथ कर्सर को निष्पादन विधि कहता है।
7	cursor.executescript(sql_script) यह दिनचर्या स्क्रिप्ट के रूप में एक बार में कई SQL कथनों को निष्पादित करती है। यह एक COMMIT स्टेटमेंट पहले जारी करता है, फिर SQL स्क्रिप्ट को एक पैरामीटर के रूप में निष्पादित करता है। सभी एसक्यूएल बयानों को एक अर्ध उपनिवेश (;) द्वारा अलग किया जाना चाहिए।
8	connection.executescript(sql_script) यह दिनचर्या एक शॉर्टकट है जो कर्सर विधि को कॉल करके एक मध्यवर्ती कर्सर ऑब्जेक्ट बनाता है, फिर दिए गए मापदंडों के साथ कर्सर के निष्पादन विधि को कॉल करता है।
9	connection.total_changes() यह रूटीन डेटाबेस कनेक्शन खोले जाने के बाद, संशोधित, सम्मिलित, या हटाई गई डेटाबेस पंक्तियों की कुल संख्या लौटाता है।
10	connection.commit() यह विधि वर्तमान लेनदेन को लागू करती है। यदि आप इस विधि को नहीं कहते हैं, तो अंतिम कॉल करने के बाद से आपके द्वारा किया गया कुछ भी (अन्य डेटाबेस कनेक्शन से दिखाई नहीं देता है)।
1 1	connection.rollback() यह विधि अंतिम कॉल के बाद से डेटाबेस में किसी भी परिवर्तन को वापस लाती है।
12	connection.close() यह विधि डेटाबेस कनेक्शन बंद कर देता है। ध्यान दें कि यह स्वचालित रूप से कमिट () नहीं कहता है। यदि आप पहले कॉलिंग कमिट () के बिना अपने डेटाबेस कनेक्शन को बंद करते हैं, तो आपके परिवर्तन खो जाएंगे!
13	cursor.fetchone() यह विधि एक क्वेरी अनुक्रम सेट की अगली पंक्ति लाती है, एक एकल अनुक्रम लौटाती है, या जब कोई अधिक डेटा उपलब्ध नहीं होता है।
14	cursor.fetchmany([size = cursor.arraysize]) यह दिनचर्या एक प्रश्न परिणाम की पंक्तियों के अगले सेट को लाती है, एक सूची लौटाती है। कोई और पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है। विधि आकार पैरामीटर द्वारा इंगित के रूप में कई पंक्तियों को लाने की कोशिश करती है।
15	cursor.fetchall() यह रूटीन एक सूची में, किसी क्वेरी परिणाम की सभी (शेष) पंक्तियों को लाती है। कोई पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है।

SQLite ओपन कमांड प्रॉम्प्ट के साथ कनेक्शन स्थापित करने के लिए, उस स्थान से ब्राउज़ करें जहां आपने SQLite स्थापित किया है और बस कमांड निष्पादित करें sqlite3 जैसा कि नीचे दिखाया गया है -

अजगर का उपयोग करके कनेक्शन स्थापित करना

आप SQLite3 डेटाबेस का उपयोग SQLite3 अजगर मॉड्यूल के साथ संवाद कर सकते हैं। ऐसा करने के लिए, सबसे पहले आपको एक कनेक्शन स्थापित करने (कनेक्शन ऑब्जेक्ट बनाने) की आवश्यकता है।

SQLite3 डेटाबेस के साथ एक कनेक्शन स्थापित करने के लिए आपको अजगर की ज़रूरत है -

आयात कथन का उपयोग कर sqlite3 मॉड्यूल आयात करें।
कनेक्ट () विधि उस डेटाबेस के नाम को स्वीकार करती है जिसे आपको एक पैरामीटर के रूप में कनेक्ट करने की आवश्यकता होती है और, एक कनेक्शन ऑब्जेक्ट देता है।

उदाहरण

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

उत्पादन

print("Connection established ..........")

SQLite CREATE TABLE स्टेटमेंट का उपयोग करके आप डेटाबेस में टेबल बना सकते हैं।

वाक्य - विन्यास

SQLite डेटाबेस में टेबल बनाने के लिए सिंटैक्स निम्नलिखित है -

CREATE TABLE database_name.table_name(
   column1 datatype PRIMARY KEY(one or more columns),
   column2 datatype,
   column3 datatype,
   .....
   columnN datatype
);

उदाहरण

SQLite क्वेरी / स्टेटमेंट के बाद नाम के साथ एक टेबल बनता है CRICKETERS SQLite डेटाबेस में -

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

आइए हम क्रिकेटर तालिका में प्रत्येक खिलाड़ी के वन-डे क्रिकेट आंकड़ों का वर्णन करते हुए एक और तालिका ओडीस्टैट्स बनाएं।

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite

आप SQLite डेटाबेस में डेटाबेस का उपयोग करके तालिकाओं की सूची प्राप्त कर सकते हैं .tablesआदेश। तालिका बनाने के बाद, यदि आप तालिकाओं की सूची को सत्यापित कर सकते हैं, तो आप इसमें नई बनाई गई तालिका का निरीक्षण कर सकते हैं -

sqlite> . tables
CRICKETERS ODIStats
sqlite>

अजगर का उपयोग कर एक तालिका बनाना

Cursor ऑब्जेक्ट में quires और fetch data आदि को निष्पादित करने के सभी तरीके हैं। कनेक्शन क्लास का कर्सर विधि एक कर्सर ऑब्जेक्ट देता है।

इसलिए, अजगर का उपयोग कर SQLite डेटाबेस में एक तालिका बनाने के लिए -

कनेक्ट () विधि का उपयोग करके डेटाबेस के साथ संबंध स्थापित करें।
उपरोक्त बनाई गई कनेक्शन ऑब्जेक्ट पर कर्सर () विधि को लागू करके एक कर्सर ऑब्जेक्ट बनाएं।
अब Cursor वर्ग के निष्पादन () पद्धति का उपयोग करके क्रिएट टेबल स्टेटमेंट को निष्पादित करें।

उदाहरण

पायथन कार्यक्रम के बाद SQLite3 में कर्मचारी नाम की एक तालिका बनाता है -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)
print("Table created successfully........")

# Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

Table created successfully........

आप INSERT INTO कथन का उपयोग करके SQLite की मौजूदा तालिका में नई पंक्तियाँ जोड़ सकते हैं। इसमें, आपको तालिका का नाम, कॉलम के नाम और मान निर्दिष्ट करने की आवश्यकता है (कॉलम नामों के समान क्रम में)।

वाक्य - विन्यास

निम्नलिखित INSERT बयान की सिफारिश की वाक्य रचना है -

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

जहां, column1, column2, column3, .. एक तालिका के स्तंभों के नाम हैं और value1, value2, value3, ... वे मान हैं जिन्हें आपको तालिका में सम्मिलित करने की आवश्यकता है।

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

PostgreSQL स्टेटमेंट के बाद उपरोक्त बनाई गई तालिका में एक पंक्ति सम्मिलित करता है।

sqlite> insert into CRICKETERS 
   (First_Name, Last_Name, Age, Place_Of_Birth, Country) values
   ('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite>

INSERT INTO स्टेटमेंट का उपयोग करके रिकॉर्ड सम्मिलित करते समय, यदि आप किसी भी कॉलम नाम को छोड़ते हैं, तो यह रिकॉर्ड कॉलमों में खाली स्थानों को छोड़कर डाला जाएगा, जिन्हें आपने छोड़ दिया है।

sqlite> insert into CRICKETERS 
   (First_Name, Last_Name, Country) values 
   ('Jonathan', 'Trott', 'SouthAfrica');
sqlite>

sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

sqlite> select * from cricketers;
Shikhar  | Dhawan     | 33 | Delhi  | India
Jonathan | Trott      |    |        | SouthAfrica
Kumara   | Sangakkara | 41 | Matale | Srilanka
Virat    | Kohli      | 30 | Delhi  | India
Rohit    | Sharma     | 32 | Nagpur | India
sqlite>

अजगर का उपयोग कर डेटा सम्मिलित करना

SQLite डेटाबेस में मौजूदा तालिका में रिकॉर्ड जोड़ने के लिए -

Sqlite3 पैकेज आयात करें।
डेटाबेस के नाम को एक पैरामीटर के रूप में पारित करके कनेक्ट () विधि का उपयोग करके एक कनेक्शन ऑब्जेक्ट बनाएं।
cursor()पद्धति एक कर्सर ऑब्जेक्ट लौटाती है जिसका उपयोग करके आप SQLite3 के साथ संवाद कर सकते हैं। (ऊपर बनाई गई) कनेक्शन ऑब्जेक्ट पर कर्सर () ऑब्जेक्ट को आमंत्रित करके एक कर्सर ऑब्जेक्ट बनाएं।
फिर, एक वस्तु के रूप में एक INSERT विवरण पास करके, कर्सर ऑब्जेक्ट पर निष्पादित () विधि को लागू करें।

उदाहरण

अजगर उदाहरण के बाद EMPLOYEE नामक तालिका में रिकॉर्ड सम्मिलित करता है -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

# Preparing SQL queries to INSERT a record into the database.
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama Priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

# Commit your changes in the database
conn.commit()
print("Records inserted........")

# Closing the connection
conn.close()

उत्पादन

Records inserted........

आप SELCT क्वेरी का उपयोग करते हुए SQLite तालिका से डेटा पुनः प्राप्त कर सकते हैं। यह प्रश्न / कथन सारणीबद्ध रूप में निर्दिष्ट संबंध (तालिका) की सामग्री देता है और इसे परिणाम-सेट कहा जाता है।

वाक्य - विन्यास

SQLite में SELECT स्टेटमेंट का सिंटैक्स निम्नलिखित है -

SELECT column1, column2, columnN FROM table_name;

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
Shikhar  |Dhawan     |India
Jonathan |Trott      |SouthAfrica
Kumara   |Sangakkara |Srilanka
Virat    |Kohli      |India
Rohit    |Sharma     |India
sqlite>

जैसा कि आप निरीक्षण करते हैं, SQLite डेटाबेस का सेलेक्ट स्टेटमेंट केवल निर्दिष्ट तालिकाओं के रिकॉर्ड लौटाता है। एक स्वरूपित आउटपुट प्राप्त करने के लिए आपको सेट करने की आवश्यकता हैheader, तथा mode नीचे दिए गए चयन के अनुसार संबंधित आदेशों का उपयोग करते हुए -

sqlite> .header on
sqlite> .mode column
sqlite> SELECT FIRST_NAME, LAST_NAME, COUNTRY FROM CRICKETERS;
First_Name Last_Name            Country
---------- -------------------- ----------
Shikhar    Dhawan               India
Jonathan   Trott                SouthAfric
Kumara     Sangakkara           Srilanka
Virat      Kohli                India
Rohit      Sharma               India
sqlite>

यदि आप प्रत्येक रिकॉर्ड के सभी स्तंभों को पुनः प्राप्त करना चाहते हैं, तो आपको नीचे दिखाए गए अनुसार कॉलम के नाम "*" से बदलने की आवश्यकता है -

sqlite> .header on
sqlite> .mode column
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age        Place_Of_Birth Country
---------- ---------- ---------- -------------- ----------
Shikhar    Dhawan     33         Delhi          India
Jonathan   Trott      38         CapeTown       SouthAfric
Kumara     Sangakkara 41         Matale         Srilanka
Virat      Kohli      30         Delhi          India
Rohit      Sharma     32         Nagpur         India
sqlite>

में SQLite डिफ़ॉल्ट रूप से स्तंभों की चौड़ाई इस चौड़ाई कटा रहे हैं परे 10 मान (2 के देश स्तंभ का पालन है ^nd उपरोक्त तालिका में पंक्ति)। आप प्रत्येक कॉलम की चौड़ाई को आवश्यक मान पर सेट कर सकते हैं.width कमांड, तालिका की सामग्री को प्राप्त करने से पहले जैसा कि नीचे दिखाया गया है -

sqlite> .width 10, 10, 4, 10, 13
sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

अजगर का उपयोग कर डेटा पुनर्प्राप्त कर रहा है

किसी भी डेटाबेस पर पढ़ें ऑपरेशन का मतलब डेटाबेस से कुछ उपयोगी जानकारी प्राप्त करना है। आप sqlite अजगर मॉड्यूल द्वारा प्रदान की गई विधि () विधि का उपयोग करके MYSQL से डेटा प्राप्त कर सकते हैं।

Sqlite3.Cursor वर्ग तीन तरीके प्रदान करता है जैसे कि भ्रूण (), fetchmany () और, fetchone () जहां,

भ्रूण () विधि एक क्वेरी के परिणाम सेट में सभी पंक्तियों को पुनः प्राप्त करती है और उन्हें टुपल्स की सूची के रूप में वापस करती है। (यदि हम कुछ पंक्तियों को प्राप्त करने के बाद इसे निष्पादित करते हैं तो यह शेष लोगों को वापस कर देता है)।
भ्रूण () विधि एक क्वेरी के परिणाम में अगली पंक्ति लाती है और इसे एक टुपल के रूप में वापस करती है।
Fetchmany () विधि fetchone () के समान है, लेकिन, यह एक पंक्ति के बजाय किसी क्वेरी के परिणाम सेट में पंक्तियों के अगले सेट को पुनः प्राप्त करता है।

उदाहरण

पायथन कार्यक्रम के बाद उपरोक्त उदाहरण में बनाई गई कंपनी तालिका से रिकॉर्ड प्राप्त करने और प्रदर्शित करने का तरीका दिखाया गया है।

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
cursor.execute('''SELECT * from EMPLOYEE''')

#Fetching 1st row from the table
result = cursor.fetchone();
print(result)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

('Ramya', 'Rama priya', 27, 'F', 9000.0)
[('Vinay', 'Battacharya', 20, 'M', 6000.0),
   ('Sharukh', 'Sheik', 25, 'M', 8300.0),
   ('Sarmista', 'Sharma', 26, 'F', 10000.0),
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)
]

यदि आप SQLite में किसी तालिका की विशेष पंक्तियों को प्राप्त करना, हटाना या अपडेट करना चाहते हैं, तो आपको ऑपरेशन के लिए तालिका की पंक्तियों को फ़िल्टर करने के लिए शर्त निर्दिष्ट करने के लिए जहां क्लॉज का उपयोग करना होगा।

वाक्य - विन्यास

SQLite में WHERE क्लॉज का वाक्य विन्यास निम्नलिखित है -

SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

sqlite> SELECT * FROM CRICKETERS WHERE AGE > 35;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

जहां अजगर का उपयोग कर खंड

Cursor ऑब्जेक्ट / क्लास में क्वेरीज़ को निष्पादित करने और डेटा को लाने के लिए सभी तरीके हैं, आदि कनेक्शन क्लास का कर्सर विधि एक कर्सर ऑब्जेक्ट देता है।

इसलिए, अजगर का उपयोग कर SQLite डेटाबेस में एक तालिका बनाने के लिए -

कनेक्ट () विधि का उपयोग करके डेटाबेस के साथ संबंध स्थापित करें।
उपरोक्त बनाई गई कनेक्शन ऑब्जेक्ट पर कर्सर () विधि को लागू करके एक कर्सर ऑब्जेक्ट बनाएं।
अब Cursor वर्ग के निष्पादन () पद्धति का उपयोग करके क्रिएट टेबल स्टेटमेंट को निष्पादित करें।

उदाहरण

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")
sql = '''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000)''')

cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Vinay', 'Battacharya', 20, 'M', 6000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sharukh', 'Sheik', 25, 'M', 8300)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Sarmista', 'Sharma', 26, 'F', 10000)''')

cursor.execute('''INSERT INTO EMPLOYEE(
   FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')

#Retrieving specific records using the where clause
cursor.execute("SELECT * from EMPLOYEE WHERE AGE <23")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Vinay', 'Battacharya', 20, 'M', 6000.0)]

SELECT क्वेरी का उपयोग करके डेटा प्राप्त करते समय, आपको उसी क्रम में रिकॉर्ड मिलेंगे जिसमें आपने उन्हें डाला है।

आप वांछित क्रम में परिणामों को क्रमबद्ध कर सकते हैं (आरोही या अवरोही) Order Byखंड। डिफ़ॉल्ट रूप से, यह क्लॉज़ आरोही क्रम में परिणाम देता है, यदि आपको उन्हें अवरोही क्रम में व्यवस्थित करने की आवश्यकता है तो आपको "DESC" का स्पष्ट रूप से उपयोग करने की आवश्यकता है।

वाक्य - विन्यास

SQLite में ORDER BY क्लॉज का वाक्य विन्यास निम्नलिखित है।

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

तालिका के रिकॉर्ड को सॉर्ट करने के लिए आप एक से अधिक कॉलम का उपयोग कर सकते हैं। सेलेक्ट स्टेटमेंट्स के बाद कॉलम AGE और FIRST_NAME के आधार पर CRICKETERS तालिका के रिकॉर्ड को सॉर्ट करें ।

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE, FIRST_NAME;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

डिफ़ॉल्ट रूप से, ORDER BY खण्ड आरोही क्रम में एक तालिका के अभिलेखों को क्रमबद्ध करता है जैसे आप DESC का उपयोग करके अवरोही क्रम में परिणामों को व्यवस्थित कर सकते हैं -

sqlite> SELECT * FROM CRICKETERS ORDER BY AGE DESC;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Jonathan   Trott      38   CapeTown   SouthAfrica
Shikhar    Dhawan     33   Delhi      India
Rohit      Sharma     32   Nagpur     India
Virat      Kohli      30   Delhi      India
sqlite>

अजगर का उपयोग करके खंड द्वारा आदेश

उदाहरण

import psycopg2

#establishing the connection
conn = psycopg2.connect(
   database="mydb", user='postgres', password='password', host='127.0.0.1', port= '5432'
)
#Setting auto commit false
conn.autocommit = True

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating a table
sql = '''CREATE TABLE EMPLOYEE(
FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT, SEX CHAR(1),
   INCOME INT,
   CONTACT INT
)'''
cursor.execute(sql)

#Populating the table
#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Retrieving specific records using the ORDER BY clause
cursor.execute("SELECT * from EMPLOYEE ORDER BY AGE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Vinay', 'Battacharya', 20, 'M', 6000, None),
   ('Tripthi', 'Mishra', 24, 'F', 6000, None),
   ('Sharukh', 'Sheik', 25, 'M', 8300, None),
   ('Sarmista', 'Sharma', 26, 'F', 10000, None),
   ('Ramya', 'Rama priya', 27, 'F', 9000, None)]

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

विशिष्ट पंक्तियों को अपडेट करने के लिए, आपको इसके साथ WHERE क्लॉज का उपयोग करना होगा।

वाक्य - विन्यास

SQLite में अद्यतन कथन का सिंटैक्स निम्नलिखित है -

UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

निम्नलिखित कथन क्रिकेटर की आयु को संशोधित करता है, जिसका पहला नाम है Shikhar -

sqlite> UPDATE CRICKETERS SET AGE = 45 WHERE FIRST_NAME = 'Shikhar' ;
sqlite>

sqlite> SELECT * FROM CRICKETERS WHERE FIRST_NAME = 'Shikhar';
First_Name Last_Name  Age Place_Of_B  Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     45   Delhi      India
sqlite>

यदि आपने WHERE के सभी खंडों का उपयोग नहीं किया है, तो सभी रिकॉर्ड अपडेट किए जाएंगे। UPDATE के बयान के बाद CRICKETERS तालिका में सभी रिकॉर्डों की आयु 1 से बढ़ जाती है -

sqlite> UPDATE CRICKETERS SET AGE = AGE+1;
sqlite>

sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Kumara     Sangakkara 42   Matale     Srilanka
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

अजगर का उपयोग करके मौजूदा रिकॉर्ड अपडेट करना

SQLite डेटाबेस में मौजूदा तालिका में रिकॉर्ड जोड़ने के लिए -

Sqlite3 पैकेज आयात करें।
डेटाबेस के नाम को एक पैरामीटर के रूप में पारित करके कनेक्ट () विधि का उपयोग करके एक कनेक्शन ऑब्जेक्ट बनाएं ।
cursor()पद्धति एक कर्सर ऑब्जेक्ट लौटाती है जिसका उपयोग करके आप SQLite3 के साथ संवाद कर सकते हैं। (ऊपर बनाई गई) कनेक्शन ऑब्जेक्ट पर कर्सर () ऑब्जेक्ट को आमंत्रित करके एक कर्सर ऑब्जेक्ट बनाएं।
फिर, कर्सर ऑब्जेक्ट पर निष्पादित () विधि को एक पैरामीटर के रूप में एक UPDATE स्टेटमेंट पास करके लागू करें।

उदाहरण

पायथन उदाहरण के बाद, EMPLOYEE नाम से एक तालिका बनाता है, इसमें 5 रिकॉर्ड सम्मिलित करता है और, सभी पुरुष कर्मचारियों की आयु 1 से बढ़ा देता है -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists.
cursor.execute("DROP TABLE IF EXISTS EMPLOYEE")

#Creating table as per requirement
sql ='''CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL,
   LAST_NAME CHAR(20),
   AGE INT,
   SEX CHAR(1),
   INCOME FLOAT
)'''
cursor.execute(sql)

#Inserting data
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

#Fetching all the rows before the update
print("Contents of the Employee table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Updating the records
sql = '''UPDATE EMPLOYEE SET AGE=AGE+1 WHERE SEX = 'M' '''
cursor.execute(sql)
print("Table updated...... ")

#Fetching all the rows after the update
print("Contents of the Employee table after the update operation: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

Contents of the Employee table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Table updated......
Contents of the Employee table after the update operation:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

SQLite तालिका से रिकॉर्ड को हटाने के लिए, आपको DELETE FROM कथन का उपयोग करना होगा। विशिष्ट रिकॉर्ड को निकालने के लिए, आपको इसके साथ WHERE क्लॉज़ का उपयोग करना होगा।

वाक्य - विन्यास

SQLite में DELETE क्वेरी का सिंटैक्स निम्नलिखित है -

DELETE FROM table_name [WHERE Clause]

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

निम्नलिखित कथन से उस क्रिकेटर का रिकॉर्ड नष्ट हो जाता है जिसका अंतिम नाम 'संगकारा' है।

sqlite> DELETE FROM CRICKETERS WHERE LAST_NAME = 'Sangakkara';
sqlite>

sqlite> SELECT * FROM CRICKETERS;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     46   Delhi      India
Jonathan   Trott      39   CapeTown   SouthAfrica
Virat      Kohli      31   Delhi      India
Rohit      Sharma     33   Nagpur     India
sqlite>

यदि आप WHET क्लॉज के बिना DELETE FROM स्टेटमेंट को निष्पादित करते हैं, तो निर्दिष्ट तालिका से सभी रिकॉर्ड हटा दिए जाएंगे।

sqlite> DELETE FROM CRICKETERS;
sqlite>

sqlite> SELECT * FROM CRICKETERS;
sqlite>

अजगर का उपयोग कर डेटा हटाना

SQLite डेटाबेस में मौजूदा तालिका में रिकॉर्ड जोड़ने के लिए -

Sqlite3 पैकेज आयात करें।
डेटाबेस के नाम को एक पैरामीटर के रूप में पारित करके कनेक्ट () विधि का उपयोग करके एक कनेक्शन ऑब्जेक्ट बनाएं ।
cursor()पद्धति एक कर्सर ऑब्जेक्ट लौटाती है जिसका उपयोग करके आप SQLite3 के साथ संवाद कर सकते हैं। (ऊपर बनाई गई) कनेक्शन ऑब्जेक्ट पर कर्सर () ऑब्जेक्ट को आमंत्रित करके एक कर्सर ऑब्जेक्ट बनाएं।
फिर, कर्सर ऑब्जेक्ट पर निष्पादित () विधि को एक पैरामीटर के रूप में एक DELETE स्टेटमेंट पास करके लागू करें।

उदाहरण

पायथन उदाहरण के बाद EMPLOYEE तालिका के रिकॉर्ड को 25 से अधिक आयु मान से हटा दिया जाता है।

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving contents of the table
print("Contents of the table: ")
cursor.execute('''SELECT * from EMPLOYEE''')
print(cursor.fetchall())

#Deleting records
cursor.execute('''DELETE FROM EMPLOYEE WHERE AGE > 25''')

#Retrieving data after delete
print("Contents of the table after delete operation ")
cursor.execute("SELECT * from EMPLOYEE")
print(cursor.fetchall())

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

Contents of the table:
[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]
Contents of the table after delete operation
[('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

आप DROP TABLE स्टेटमेंट का उपयोग करके एक पूरी तालिका निकाल सकते हैं। आपको केवल उस तालिका का नाम निर्दिष्ट करना होगा जिसे आपको हटाने की आवश्यकता है।

वाक्य - विन्यास

PostgreSQL में DROP टेबल स्टेटमेंट का सिंटैक्स निम्नलिखित है -

DROP TABLE table_name;

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255), Last_Name VARCHAR(255), Age int, 
   Place_Of_Birth VARCHAR(255), Country VARCHAR(255)
);
sqlite> CREATE TABLE EMPLOYEE(
   FIRST_NAME CHAR(20) NOT NULL, LAST_NAME CHAR(20), AGE INT, 
   SEX CHAR(1), INCOME FLOAT
);
sqlite>

अब यदि आप तालिकाओं की सूची का उपयोग करके सत्यापित करते हैं .tables कमांड, आप ऊपर दी गई तालिकाओं को इस रूप में देख सकते हैं (सूची) -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

निम्नलिखित कथन डेटाबेस से कर्मचारी नाम की तालिका को हटाता है -

sqlite> DROP table employee;
sqlite>

sqlite> .tables
CRICKETERS
sqlite>

यदि आप कर्मचारी तालिका को फिर से हटाने की कोशिश करते हैं, क्योंकि आपने पहले ही इसे हटा दिया है, तो आपको यह कहते हुए एक त्रुटि मिलेगी कि "ऐसी कोई तालिका" नहीं दिखाई गई है -

sqlite> DROP table employee;
Error: no such table: employee
sqlite>

sqlite> DROP table IF EXISTS employee;
sqlite>

पायथन का उपयोग करके एक तालिका को गिरा देना

उदाहरण

अजगर का उपयोग कर SQLite3 डेटाबेस से एक तालिका ड्रॉप करने के लिए execute() कर्सर ऑब्जेक्ट पर विधि और ड्रॉप स्टेटमेंट को एक पैरामीटर के रूप में पास करें।

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Doping EMPLOYEE table if already exists
cursor.execute("DROP TABLE emp")
print("Table dropped... ")

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

Table dropped...

रिकॉर्ड प्राप्त करते समय यदि आप उन्हें किसी विशेष संख्या द्वारा सीमित करना चाहते हैं, तो आप ऐसा कर सकते हैं, SQLite के लिमट क्लॉज का उपयोग करके।

वाक्य - विन्यास

निम्नलिखित SQLite में सीमा खंड का सिंटैक्स है -

SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

और अगर हमने INSERT कथनों का उपयोग करते हुए इसमें 5 रिकॉर्ड डाले हैं -

sqlite> insert into CRICKETERS values('Shikhar', 'Dhawan', 33, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Jonathan', 'Trott', 38, 'CapeTown', 'SouthAfrica');
sqlite> insert into CRICKETERS values('Kumara', 'Sangakkara', 41, 'Matale', 'Srilanka');
sqlite> insert into CRICKETERS values('Virat', 'Kohli', 30, 'Delhi', 'India');
sqlite> insert into CRICKETERS values('Rohit', 'Sharma', 32, 'Nagpur', 'India');
sqlite>

sqlite> SELECT * FROM CRICKETERS LIMIT 3;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Shikhar    Dhawan     33   Delhi      India
Jonathan   Trott      38   CapeTown   SouthAfrica
Kumara     Sangakkara 41   Matale     Srilanka
sqlite>

यदि आपको nth रिकॉर्ड (1 नहीं) से शुरू होने वाले रिकॉर्ड को सीमित करने की आवश्यकता है, तो आप ऐसा कर सकते हैं, लिफ़िट के साथ OFFSET का उपयोग कर सकते हैं।

sqlite> SELECT * FROM CRICKETERS LIMIT 3 OFFSET 2;
First_Name Last_Name  Age  Place_Of_B Country
---------- ---------- ---- ---------- -------------
Kumara     Sangakkara 41   Matale     Srilanka
Virat      Kohli      30   Delhi      India
Rohit      Sharma     32   Nagpur     India
sqlite>

पायथन का उपयोग करके परिवाद खंड

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

उदाहरण

पायथन उदाहरण के बाद लिमाट क्लॉज का उपयोग करते हुए EMPLOYEE तालिका के पहले दो रिकॉर्ड प्राप्त होते हैं।

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving single row
sql = '''SELECT * from EMPLOYEE LIMIT 3'''

#Executing the query
cursor.execute(sql)

#Fetching the data
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Ramya', 'Rama priya', 27, 'F', 9000.0), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0)]

उदाहरण

sqlite> CREATE TABLE CRICKETERS (
   First_Name VARCHAR(255),
   Last_Name VARCHAR(255),
   Age int,
   Place_Of_Birth VARCHAR(255),
   Country VARCHAR(255)
);
sqlite>

sqlite> CREATE TABLE ODIStats (
   First_Name VARCHAR(255),
   Matches INT,
   Runs INT,
   AVG FLOAT,
   Centuries INT,
   HalfCenturies INT
);
sqlite>

निम्न कथन इन दो तालिकाओं में मूल्यों के संयोजन डेटा को पुनः प्राप्त करता है -

sqlite> SELECT
   Cricketers.First_Name, Cricketers.Last_Name, Cricketers.Country,
   OdiStats.matches, OdiStats.runs, OdiStats.centuries, OdiStats.halfcenturies
   from Cricketers INNER JOIN OdiStats ON Cricketers.First_Name = OdiStats.First_Name;
First_Name Last_Name    Country  Matches    Runs          Centuries  HalfCenturies
---------- ----------   -------  ---------- ------------- ---------- ----------
Shikhar    Dhawan       Indi     133        5518          17         27
Jonathan   Trott        Sout     68         2819          4          22
Kumara     Sangakkara   Sril     404        14234         25         93
Virat      Kohli        Indi     239        11520         43         54
Rohit      Sharma       Indi     218        8686          24         42
sqlite>

अजगर का उपयोग करते हुए क्लॉज में शामिल हों

SQLite उदाहरण के बाद, अजगर का उपयोग करते हुए JOIN क्लॉज प्रदर्शित करता है -

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

#Retrieving data
sql = '''SELECT * from EMP INNER JOIN CONTACT ON EMP.CONTACT = CONTACT.ID'''

#Executing the query
cursor.execute(sql)

#Fetching 1st row from the table
result = cursor.fetchall();
print(result)

#Commit your changes in the database
conn.commit()

#Closing the connection
conn.close()

उत्पादन

[('Ramya', 'Rama priya', 27, 'F', 9000.0, 101, 101, '[email protected]', 'Hyderabad'), 
   ('Vinay', 'Battacharya', 20, 'M', 6000.0, 102, 102,'[email protected]', 'Vishakhapatnam'), 
   ('Sharukh', 'Sheik', 25, 'M', 8300.0, 103, 103, '[email protected]', 'Pune'), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0, 104, 104, '[email protected]', 'Mumbai')]

Sqlite3.Cursor वर्ग एक उदाहरण है जिसके उपयोग से आप SQLite कथनों को निष्पादित करने वाले तरीकों को लागू कर सकते हैं, प्रश्नों के परिणाम सेट से डेटा प्राप्त कर सकते हैं। आप बना सकते हैंCursor कनेक्शन ऑब्जेक्ट / क्लास के कर्सर () पद्धति का उपयोग करके ऑब्जेक्ट।

उदाहरण

import sqlite3

#Connecting to sqlite
conn = sqlite3.connect('example.db')

#Creating a cursor object using the cursor() method
cursor = conn.cursor()

तरीकों

निम्नलिखित विभिन्न तरीके Cursor वर्ग / वस्तु द्वारा प्रदान किए गए हैं।

अनु क्रमांक	विधि और विवरण
1	execute() यह रूटीन SQL कथन निष्पादित करता है। SQL स्टेटमेंट को पैरामीटरेट किया जा सकता है (यानी, एसक्यूएल शाब्दिक के बजाय प्लेसहोल्डर)। Psycopg2 मॉड्यूल% s साइन का उपयोग करके प्लेसहोल्डर का समर्थन करता है उदाहरण के लिए: RPG.execute ("लोगों के मानों में डालें (% s,% s)", (जो, आयु)
2	executemany() यह दिनचर्या अनुक्रम sql में पाए जाने वाले सभी पैरामीटर अनुक्रमों या मैपिंग के विरुद्ध SQL कमांड निष्पादित करता है।
3	fetchone() यह विधि एक क्वेरी अनुक्रम सेट की अगली पंक्ति लाती है, एक एकल अनुक्रम लौटाती है, या जब कोई अधिक डेटा उपलब्ध नहीं होता है।
4	fetchmany() यह दिनचर्या एक प्रश्न परिणाम की पंक्तियों के अगले सेट को लाती है, एक सूची लौटाती है। कोई और पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है। विधि आकार पैरामीटर द्वारा इंगित के रूप में कई पंक्तियों को लाने की कोशिश करती है।
5	fetchall() यह रूटीन एक सूची में, किसी क्वेरी परिणाम की सभी (शेष) पंक्तियों को लाती है। कोई पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है।

गुण

निम्नलिखित कर्सर श्रेणी के गुण हैं -

अनु क्रमांक	विधि और विवरण
1	arraySize यह एक पढ़ने / लिखने की संपत्ति है आप भ्रूण () विधि द्वारा लौटी पंक्तियों की संख्या निर्धारित कर सकते हैं।
2	description यह एक रीड ओनली प्रॉपर्टी है, जो रिजल्ट-सेट में कॉलम के विवरण वाली सूची लौटाती है।
3	lastrowid यह एक रीड ओनली प्रॉपर्टी है, यदि टेबल में कोई ऑटो-इन्क्रिमेटेड कॉलम हैं, तो यह उस कॉलम के लिए उत्पन्न मूल्य को पिछले INSERT या, UPDATE ऑपरेशन में लौटाता है।
4	rowcount यह SELECT और UPDATE ऑपरेशन की स्थिति में लौटी / अपडेट की गई पंक्तियों की संख्या लौटाता है।
5	connection यह रीड-ओनली विशेषता कर्सर ऑब्जेक्ट द्वारा उपयोग किए गए SQLite डेटाबेस कनेक्शन प्रदान करता है।

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

इंस्टालेशन

सब से पहले pymongo स्थापित करने के लिए सुनिश्चित करें कि आपने python3 (PIP के साथ) और MongoDB को ठीक से स्थापित किया है। फिर निम्नलिखित कमांड निष्पादित करें।

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

सत्यापन

एक बार जब आपने pymongo इंस्टॉल कर लिया है, तो एक नया टेक्स्ट डॉक्यूमेंट खोलें, उसमें निम्न लाइन पेस्ट करें और, इसे test.py के रूप में सहेजें।

import pymongo

यदि आपने pymongo को ठीक से स्थापित किया है, यदि आप नीचे दिखाए गए अनुसार test.py निष्पादित करते हैं, तो आपको कोई समस्या नहीं मिलनी चाहिए।

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

अन्य डेटाबेस के विपरीत, MongoDB एक डेटाबेस बनाने के लिए अलग कमांड प्रदान नहीं करता है।

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

इसलिए, आप का उपयोग करके MongoDB में एक डेटाबेस बना सकते हैं Use आदेश।

वाक्य - विन्यास

का मूल सिंटैक्स use DATABASE कथन इस प्रकार है -

use DATABASE_NAME

उदाहरण

निम्नलिखित कमांड mydb में एक डेटाबेस बनाता है।

>use mydb
switched to db mydb

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

>db
mydb

अजगर का उपयोग कर डेटाबेस बनाना

Pongongo का उपयोग करके MongoDB से कनेक्ट करने के लिए, आपको एक MongoClient आयात करना और बनाना होगा, फिर आप उस डेटाबेस तक सीधे पहुंच सकते हैं जिसे आपको विशेषता जुनून में बनाने की आवश्यकता है।

उदाहरण

निम्न उदाहरण MangoDB में एक डेटाबेस बनाता है।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

उत्पादन

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

आप MongoClient बनाते समय पोर्ट और होस्ट नामों को भी निर्दिष्ट कर सकते हैं और शब्दकोश शैली में डेटाबेस तक पहुंच सकते हैं।

उदाहरण

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

उत्पादन

Database created........

MongoDB में एक संग्रह दस्तावेजों का एक समूह रखता है, यह संबंधपरक डेटाबेस में एक तालिका के अनुरूप है।

आप का उपयोग कर एक संग्रह बना सकते हैं createCollection()तरीका। यह विधि बनाए जाने वाले संग्रह के नाम और एक विकल्प (वैकल्पिक) पैरामीटर का प्रतिनिधित्व करने वाले स्ट्रिंग मान को स्वीकार करता है।

इसका उपयोग करके आप निम्नलिखित निर्दिष्ट कर सकते हैं -

संग्रह का आकार।
कैप्ड संग्रह में दस्तावेज़ों की अधिकतम संख्या की अनुमति है।
क्या हमारे द्वारा बनाया गया संग्रह छायांकित संग्रह (निश्चित आकार संग्रह) होना चाहिए।
क्या हमारे द्वारा बनाया गया संग्रह स्वतः-अनुक्रमित होना चाहिए।

वाक्य - विन्यास

MongoDB में एक संग्रह बनाने के लिए निम्नलिखित सिंटैक्स है।

db.createCollection("CollectionName")

उदाहरण

निम्नलिखित विधि एक संग्रह बनाती है जिसका नाम ExampleCollection है।

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

इसी तरह, निम्नलिखित एक क्वेरी है जो createCollection () विधि के विकल्पों का उपयोग करके एक संग्रह बनाता है।

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

अजगर का उपयोग कर एक संग्रह बनाना

अजगर उदाहरण के बाद MongoDB (mydb) में एक डेटाबेस से जुड़ता है और, इसमें एक संग्रह बनाता है।

उदाहरण

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
collection = db['example']
print("Collection created........")

उत्पादन

Collection created........

आप सम्मिलित करें () विधि का उपयोग करके दस्तावेजों को MongoDB में संग्रहीत कर सकते हैं । यह विधि एक JSON दस्तावेज़ को एक पैरामीटर के रूप में स्वीकार करती है।

वाक्य - विन्यास

निम्नलिखित सम्मिलित विधि का वाक्य विन्यास है।

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

उदाहरण

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

इसी तरह, आप भी कई दस्तावेजों का उपयोग कर सम्मिलित कर सकते हैं insert() तरीका।

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = 
[
   {
      "_id": "1001", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   }, 
   {
      "_id": "1002", 
      "name" : "Rahim", 
      "age" : 27, 
      "city" : "Bangalore" 
   }, 
   {
      "_id": "1003", 
      "name" : "Robert", 
      "age" : 28, 
      "city" : "Mumbai" 
   }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.sample.insert(data)
BulkWriteResult
({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

अजगर का उपयोग कर एक संग्रह बनाना

मैंगोबीड में एक दस्तावेज़ सम्मिलित करने के लिए Pymongo Insert_one () नामक एक विधि प्रदान करता है। इस पद्धति के लिए, हमें दस्तावेज़ को शब्दकोश प्रारूप में पास करना होगा।

उदाहरण

उदाहरण के बाद संग्रह में उदाहरण के नाम पर एक दस्तावेज़ सम्मिलित है।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

उत्पादन

{
   '_id': ObjectId('5d63ad6ce043e2a93885858b'), 
   'name': 'Ram', 
   'age': '26', 
   'city': 'Hyderabad'
}

Pymongo का उपयोग करते हुए MongoDB में कई दस्तावेज़ सम्मिलित करने के लिए, आपको insert_many () विधि को लागू करना होगा।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = 
[
   {
      "_id": "101", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   },
   {
      "_id": "102", 
      "name": "Rahim", 
      "age": "27", 
      "city": "Bangalore"
   },
   {
      "_id": "103", 
      "name": "Robert", 
      "age": "28", 
      "city": "Mumbai"
   }
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

उत्पादन

Data inserted ......
['101', '102', '103']

आप MongoDB से संग्रहीत दस्तावेज़ों को पढ़ / प्राप्त कर सकते हैं find()तरीका। यह विधि गैर-संरचित तरीके से MongoDB में सभी दस्तावेजों को पुनर्प्राप्त और प्रदर्शित करती है।

वाक्य - विन्यास

निम्नलिखित का सिंटैक्स है find() तरीका।

>db.CollectionName.find()

उदाहरण

मान लें कि हमने निम्नलिखित प्रश्नों का उपयोग करते हुए नमूने नाम के एक संग्रह में testDB नामक डेटाबेस में 3 दस्तावेज़ सम्मिलित किए हैं -

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

आप खोजे गए () विधि का उपयोग करके सम्मिलित किए गए दस्तावेजों को पुनः प्राप्त कर सकते हैं -

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

आप संग्रह में पहले दस्तावेज़ को पुनः प्राप्त कर सकते हैं (जैसे) विधि का उपयोग करके -

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

अजगर का उपयोग कर डेटा (पुनर्प्राप्त) प्राप्त करना

find_One() pymongo की विधि का उपयोग आपकी क्वेरी के आधार पर एक एकल दस्तावेज़ को पुनः प्राप्त करने के लिए किया जाता है, कोई भी मैच के मामले में यह विधि कुछ भी नहीं लौटाती है और यदि आप किसी भी क्वेरी का उपयोग नहीं करते हैं तो यह संग्रह का पहला दस्तावेज़ लौटाता है।

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

उदाहरण

अजगर उदाहरण के बाद एक संग्रह का पहला दस्तावेज प्राप्त होता है -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydatabase']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

उत्पादन

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

एक ही क्वेरी में कई दस्तावेज़ प्राप्त करने के लिए (एकल कॉल ऑड फ़ाइंड विधि), आप इसका उपयोग कर सकते हैं find()पाइमोन्गो की विधि। यदि आपने कोई क्वेरी पारित नहीं की है, तो यह एक संग्रह के सभी दस्तावेजों को लौटाता है और, यदि आपने इस पद्धति से कोई क्वेरी पारित की है, तो यह सभी मिलान दस्तावेजों को लौटाता है।

उदाहरण

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)

उत्पादन

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

उपयोग करते हुए पुनः प्राप्त करें find()विधि, आप क्वेरी ऑब्जेक्ट का उपयोग करके दस्तावेज़ों को फ़िल्टर कर सकते हैं। आप इस विधि के लिए एक पैरामीटर के रूप में आवश्यक दस्तावेजों के लिए शर्त निर्दिष्ट करने वाली क्वेरी को पास कर सकते हैं।

ऑपरेटर्स

निम्नलिखित MongoDB में प्रश्नों में प्रयुक्त ऑपरेटरों की सूची है।

ऑपरेशन	वाक्य - विन्यास	उदाहरण
समानता	{"मौलिक मूल्य"}	db.mycol.find ({"by": "ट्यूटोरियल्स पॉइंट"})
से कम	{"कुंजी": {$ lt: "value"}}	db.mycol.find ({ "पसंद": {$ lt: 50}})
बराबरी से कम	{"कुंजी": {$ lte: "मूल्य"}}	db.mycol.find ({ "पसंद": {$ एलटीई: 50}})
से अधिक	{"कुंजी": {$ gt: "मान"}}	db.mycol.find ({ "पसंद": {$ जीटी: 50}})
ग्रेटर थान बराबर	{"कुंजी" {$ gte: "मूल्य"}}	db.mycol.find ({ "पसंद": {$ gte: 50}})
न के बराबर	{"कुंजी": {$ ne: "मान"}}	db.mycol.find ({ "पसंद": {$ ne: 50}})

उदाहरण 1

निम्नलिखित उदाहरण एक संग्रह में दस्तावेज़ को पुनः प्राप्त करता है जिसका नाम सरिस्ता है।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sdsegf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

उत्पादन

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

example2

निम्नलिखित उदाहरण एक संग्रह में दस्तावेज़ को पुनः प्राप्त करता है, जिसकी आयु मूल्य 26 से अधिक है।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['ghhj']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

उत्पादन

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

किसी संग्रह की सामग्री को पुनर्प्राप्त करते समय, आप उन्हें उपयोग करके आरोही या अवरोही क्रम में क्रमबद्ध और व्यवस्थित कर सकते हैं sort() तरीका।

इस पद्धति के लिए, आप फ़ील्ड (एस) और सॉर्टिंग क्रम जो 1 या -1 पास कर सकते हैं। जहां, 1 आरोही क्रम के लिए है और -1 अवरोही क्रम है।

वाक्य - विन्यास

निम्नलिखित प्रकार () विधि का वाक्यविन्यास है ।

>db.COLLECTION_NAME.find().sort({KEY:1})

उदाहरण

मान लें कि हमने एक संग्रह बनाया है और उसमें 5 दस्तावेज डाले हैं जैसा कि नीचे दिखाया गया है -

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

निम्नलिखित पंक्ति संग्रह के सभी दस्तावेजों को पुनः प्राप्त करती है जो आयु के आधार पर आरोही क्रम में क्रमबद्ध होते हैं।

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

अजगर का उपयोग कर दस्तावेजों को छाँटना

आरोही में किसी क्वेरी के परिणामों को क्रमबद्ध करने के लिए, अवरोही क्रम pymongo प्रदान करता है sort()तरीका। इस पद्धति के लिए, परिणाम में आपके द्वारा आवश्यक दस्तावेजों की संख्या का प्रतिनिधित्व करने वाला एक संख्या मान पास करें।

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

coll.find().sort("age",-1)

उदाहरण

निम्नलिखित उदाहरण संग्रह के सभी दस्तावेजों को आरोही क्रम में आयु मानों के अनुसार व्यवस्थित करते हैं -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['b_mydb']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")

for doc1 in coll.find().sort("age"):
   print(doc1)

उत्पादन

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

आप किसी संग्रह में दस्तावेज़ों का उपयोग करके हटा सकते हैं remove()MongoDB की विधि। यह विधि दो वैकल्पिक मापदंडों को स्वीकार करती है -

दस्तावेज़ हटाने के लिए शर्त निर्दिष्ट करने वाले विलोपन मानदंड।
सिर्फ एक, यदि आप दूसरे पैरामीटर के रूप में सही या 1 पास करते हैं, तो केवल एक दस्तावेज हटा दिया जाएगा।

वाक्य - विन्यास

निम्नलिखित निकालें () विधि का वाक्य विन्यास है -

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

उदाहरण

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

निम्नलिखित क्वेरी उस संग्रह के दस्तावेज़ (दस्तावेजों) को हटा देती है, जिनका नाम Sarmista है।

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

यदि आप आह्वान करते हैं remove() विलोपन मानदंड पारित किए बिना विधि, संग्रह में सभी दस्तावेजों को हटा दिया जाएगा।

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

अजगर का उपयोग कर दस्तावेजों को हटाना

MangoDB के संग्रह से दस्तावेज़ों को हटाने के लिए, आप विधियों का उपयोग करके संग्रह से दस्तावेज़ों को हटा सकते हैं delete_one() तथा delete_many() तरीकों।

ये विधियाँ दस्तावेजों को हटाने के लिए शर्त निर्दिष्ट करने वाली एक क्वेरी ऑब्जेक्ट को स्वीकार करती हैं।

एक मेल के मामले में, detele_one () विधि एकल दस्तावेज़ को हटा देती है। यदि कोई क्वेरी निर्दिष्ट नहीं है, तो यह विधि संग्रह में पहला दस्तावेज़ हटा देती है।

उदाहरण

अजगर उदाहरण के बाद संग्रह में दस्तावेज़ को हटाता है जिसका आईडी मूल्य 1006 है।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['lpaksgf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

उत्पादन

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

इसी तरह, delete_many() pymongo की विधि उन सभी दस्तावेजों को हटा देती है जो निर्दिष्ट स्थिति को संतुष्ट करते हैं।

उदाहरण

निम्नलिखित उदाहरण संग्रह में सभी दस्तावेजों को हटा देता है जिनकी आयु का मूल्य 26 से अधिक है -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sampleDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

उत्पादन

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

यदि आप डिलीट_मनी () विधि को बिना किसी प्रश्न के पास करते हैं, तो यह विधि संग्रह के सभी दस्तावेजों को हटा देती है।

coll.delete_many({})

आप संग्रह का उपयोग करके हटा सकते हैं drop() MongoDB की विधि।

वाक्य - विन्यास

निम्नलिखित ड्रॉप () विधि का वाक्य विन्यास है -

db.COLLECTION_NAME.drop()

उदाहरण

नाम नमूने के साथ उदाहरण के बाद की बूंदें संग्रह -

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

अजगर का उपयोग कर संग्रह को गिराना

आप ड्रॉप () विधि द्वारा वर्तमान डेटाबेस से एक संग्रह को गिरा / हटा सकते हैं।

उदाहरण

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['example2']

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()

for coll in collections:
   print(coll)

उत्पादन

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

आप किसी मौजूदा दस्तावेज़ की सामग्री को अपडेट कर सकते हैं update() विधि या save() तरीका।

अद्यतन विधि मौजूदा दस्तावेज़ को संशोधित करती है जबकि सहेजने का तरीका मौजूदा दस्तावेज़ को नए के साथ बदल देता है।

वाक्य - विन्यास

निम्नलिखित अद्यतन का सिंटैक्स है () और मैंगो के तरीकों को बचाओ () -

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

उदाहरण

मान लें कि हमने एक डेटाबेस में एक संग्रह बनाया है और उसमें 3 रिकॉर्ड डाले हैं जैसा कि नीचे दिखाया गया है -

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

निम्नलिखित विधि आईडी 1002 के साथ दस्तावेज़ के शहर मूल्य को अपडेट करती है।

> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

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

> db.sample.save(
   { "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

अजगर का उपयोग कर दस्तावेजों को अद्यतन करना

Find_one () पद्धति के समान जो एकल दस्तावेज़ को पुनः प्राप्त करता है, pymongo का update_one () विधि एकल दस्तावेज़ को अद्यतन करता है।

यह विधि एक क्वेरी को निर्दिष्ट करती है जो यह निर्दिष्ट करती है कि किस दस्तावेज़ को अपडेट करना है और अपडेट ऑपरेशन।

उदाहरण

अजगर उदाहरण के बाद एक संग्रह में एक दस्तावेज़ के स्थान मूल्य को अद्यतन करता है।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

उत्पादन

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

इसी तरह, update_many() pymongo की विधि उन सभी दस्तावेजों को अपडेट करती है जो निर्दिष्ट स्थिति को संतुष्ट करते हैं।

उदाहरण

उदाहरण के बाद एक संग्रह में सभी दस्तावेजों में स्थान का मूल्य अद्यतन (खाली स्थिति) -

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

उत्पादन

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

एक संग्रह की सामग्री को पुनर्प्राप्त करते समय आप परिणाम () विधि का उपयोग करके दस्तावेजों की संख्या को सीमित कर सकते हैं। यह विधि कई मानों को स्वीकार करती है जो परिणाम में आपके वांछित दस्तावेजों की संख्या का प्रतिनिधित्व करते हैं।

वाक्य - विन्यास

निम्नलिखित सीमा का सिंटैक्स है () विधि -

>db.COLLECTION_NAME.find().limit(NUMBER)

उदाहरण

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

निम्नलिखित पंक्ति संग्रह के पहले 3 दस्तावेजों को पुनः प्राप्त करती है।

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

अजगर का उपयोग कर दस्तावेजों को सीमित करना

एक प्रश्न के परिणामों को प्रतिबंधित करने के लिए एक विशेष संख्या में दस्तावेजों के लिए pymongo प्रदान करता है limit()तरीका। इस पद्धति के लिए आपको परिणाम में आवश्यक दस्तावेजों की संख्या का प्रतिनिधित्व करते हुए एक संख्या मान पास करना होगा।

उदाहरण

निम्न उदाहरण संग्रह में पहले तीन दस्तावेज़ों को पुनः प्राप्त करते हैं।

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['l']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")

for doc1 in coll.find().limit(3):
   print(doc1)

उत्पादन

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}