Python PostgreSQL - Guide rapide

PostgreSQL est un puissant système de base de données relationnelle objet et open source. Il a plus de 15 ans de phase de développement actif et une architecture éprouvée qui lui a valu une solide réputation de fiabilité, d'intégrité des données et d'exactitude.

Pour communiquer avec PostgreSQL en utilisant Python, vous devez installer psycopg, un adaptateur fourni pour la programmation python, la version actuelle de ceci est psycog2.

psycopg2 a été écrit dans le but d'être très petit et rapide, et stable comme un rocher. Il est disponible sous PIP (gestionnaire de paquets de python)

Installer Psycog2 à l'aide de PIP

Tout d'abord, assurez-vous que python et PIP sont correctement installés sur votre système et que PIP est à jour.

Pour mettre à niveau PIP, ouvrez l'invite de commande et exécutez la commande suivante -

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

Ensuite, ouvrez l'invite de commande en mode administrateur et exécutez le pip install psycopg2-binary commande comme indiqué ci-dessous -

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

Vérification

Pour vérifier l'installation, créez un exemple de script python contenant la ligne suivante.

import mysql.connector

Si l'installation réussit, lorsque vous l'exécutez, vous ne devriez obtenir aucune erreur -

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

PostgreSQL fournit son propre shell pour exécuter des requêtes. Pour établir la connexion avec la base de données PostgreSQL, assurez-vous de l'avoir correctement installée dans votre système. Ouvrez l'invite du shell PostgreSQL et transmettez des détails tels que le serveur, la base de données, le nom d'utilisateur et le mot de passe. Si tous les détails que vous avez donnés sont appropriés, une connexion est établie avec la base de données PostgreSQL.

Tout en passant les détails, vous pouvez utiliser le serveur, la base de données, le port et le nom d'utilisateur par défaut suggérés par le shell.

Établir une connexion à l'aide de Python

La classe de connexion du psycopg2représente / gère une instance d'une connexion. Vous pouvez créer de nouvelles connexions à l'aide duconnect()fonction. Cela accepte les paramètres de connexion de base tels que nom de base de données, utilisateur, mot de passe, hôte, port et renvoie un objet de connexion. En utilisant cette fonction, vous pouvez établir une connexion avec PostgreSQL.

Exemple

Le code Python suivant montre comment se connecter à une base de données existante. Si la base de données n'existe pas, elle sera créée et finalement un objet de base de données sera renvoyé. Le nom de la base de données par défaut de PostgreSQL est postrgre. Par conséquent, nous le fournissons comme nom de base de données.

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

Production

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

Vous pouvez créer une base de données dans PostgreSQL à l'aide de l'instruction CREATE DATABASE. Vous pouvez exécuter cette instruction dans l'invite du shell PostgreSQL en spécifiant le nom de la base de données à créer après la commande.

Syntaxe

Voici la syntaxe de l'instruction CREATE DATABASE.

CREATE DATABASE dbname;

Exemple

L'instruction suivante crée une base de données nommée testdb dans PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Vous pouvez lister la base de données dans PostgreSQL en utilisant la commande \ l. Si vous vérifiez la liste des bases de données, vous pouvez trouver la base de données nouvellement créée comme suit -

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)

Vous pouvez également créer une base de données dans PostgreSQL à partir de l'invite de commande en utilisant la commande createdb , un wrapper autour de l'instruction SQL CREATE DATABASE.

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

Créer une base de données à l'aide de Python

La classe de curseur de psycopg2 fournit diverses méthodes pour exécuter diverses commandes PostgreSQL, récupérer des enregistrements et copier des données. Vous pouvez créer un objet curseur à l'aide de la méthode cursor () de la classe Connection.

La méthode execute () de cette classe accepte une requête PostgreSQL en tant que paramètre et l'exécute.

Par conséquent, pour créer une base de données dans PostgreSQL, exécutez la requête CREATE DATABASE à l'aide de cette méthode.

Exemple

L'exemple python suivant crée une base de données nommée mydb dans la base de données PostgreSQL.

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

Production

Database created successfully........

Vous pouvez créer une nouvelle table dans une base de données dans PostgreSQL à l'aide de l'instruction CREATE TABLE. Lors de l'exécution de cette opération, vous devez spécifier le nom de la table, les noms des colonnes et leurs types de données.

Syntaxe

Voici la syntaxe de l'instruction CREATE TABLE dans PostgreSQL.

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

Exemple

L'exemple suivant crée une table avec le nom CRICKETERS dans PostgreSQL.

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=#

Vous pouvez obtenir la liste des tables d'une base de données dans PostgreSQL à l'aide de la commande \ dt. Après avoir créé une table, si vous pouvez vérifier la liste des tables, vous pouvez y observer la table nouvellement créée comme suit -

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

De la même manière, vous pouvez obtenir la description de la table créée en utilisant \ d comme indiqué ci-dessous -

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=#

Créer une table à l'aide de Python

Pour créer une table à l'aide de python, vous devez exécuter l'instruction CREATE TABLE en utilisant la méthode execute () du curseur de pyscopg2 .

Exemple

L'exemple Python suivant crée une table avec le nom employé.

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

Production

Table created successfully........

Vous pouvez insérer un enregistrement dans une table existante dans PostgreSQL en utilisant le INSERT INTOdéclaration. Lors de son exécution, vous devez spécifier le nom de la table et les valeurs des colonnes qu'elle contient.

Syntaxe

Voici la syntaxe recommandée de l'instruction INSERT -

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

Où, colonne1, colonne2, colonne3, .. sont les noms des colonnes d'une table, et valeur1, valeur2, valeur3, ... sont les valeurs que vous devez insérer dans la table.

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant l'instruction CREATE TABLE comme indiqué ci-dessous -

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=#

L'instruction PostgreSQL suivante insère une ligne dans la table créée ci-dessus -

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

Lors de l'insertion d'enregistrements à l'aide de l'instruction INSERT INTO, si vous ignorez les noms de colonnes, l'enregistrement sera inséré en laissant des espaces vides dans les colonnes que vous avez ignorées.

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

Vous pouvez également insérer des enregistrements dans une table sans spécifier les noms de colonne, si l'ordre des valeurs que vous passez est le même que leurs noms de colonne respectifs dans la table.

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=#

Après avoir inséré les enregistrements dans une table, vous pouvez vérifier son contenu à l'aide de l'instruction SELECT comme indiqué ci-dessous -

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)

Insertion de données à l'aide de Python

La classe de curseur de psycopg2 fournit une méthode avec le nom de méthode execute (). Cette méthode accepte la requête en tant que paramètre et l'exécute.

Par conséquent, pour insérer des données dans une table dans PostgreSQL en utilisant python -

• Importer psycopg2 paquet.

• Créez un objet de connexion à l'aide de connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Désactivez le mode de validation automatique en définissant false comme valeur de l'attribut autocommit.

• le cursor() méthode de la ConnectionLa classe de la bibliothèque psycopg2 renvoie un objet curseur. Créez un objet curseur à l'aide de cette méthode.

• Ensuite, exécutez la ou les instructions INSERT en les passant en tant que paramètre à la méthode execute ().

Exemple

Le programme Python suivant crée une table avec le nom EMPLOYEE dans la base de données PostgreSQL et y insère des enregistrements à l'aide de la méthode execute () -

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

Production

Records inserted........

Vous pouvez récupérer le contenu d'une table existante dans PostgreSQL à l'aide de l'instruction SELECT. À cette instruction, vous devez spécifier le nom de la table et, elle renvoie son contenu au format tabulaire qui est connu sous le nom de jeu de résultats.

Syntaxe

Voici la syntaxe de l'instruction SELECT dans PostgreSQL -

SELECT column1, column2, columnN FROM table_name;

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -

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=#

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

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

La requête SELECT suivante récupère les valeurs des colonnes FIRST_NAME, LAST_NAME et COUNTRY de la table CRICKETERS.

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)

Si vous souhaitez récupérer toutes les colonnes de chaque enregistrement, vous devez remplacer les noms des colonnes par "⚹" comme indiqué ci-dessous -

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=#

Récupération de données à l'aide de Python

LIRE L'opération sur n'importe quelle base de données signifie récupérer des informations utiles dans la base de données. Vous pouvez récupérer des données depuis PostgreSQL en utilisant la méthode fetch () fournie par le psycopg2.

La classe Cursor fournit trois méthodes à savoir fetchall (), fetchmany () et, fetchone () où,

• La méthode fetchall () récupère toutes les lignes du jeu de résultats d'une requête et les renvoie sous forme de liste de tuples. (Si nous l'exécutons après avoir récupéré quelques lignes, cela renvoie les autres).

• La méthode fetchone () récupère la ligne suivante dans le résultat d'une requête et la renvoie sous forme de tuple.

Note - Un jeu de résultats est un objet renvoyé lorsqu'un objet curseur est utilisé pour interroger une table.

Exemple

Le programme Python suivant se connecte à une base de données nommée mydb de PostgreSQL et récupère tous les enregistrements d'une table nommée 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()

Production

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

Lors de l'exécution des opérations SELECT, UPDATE ou DELETE, vous pouvez spécifier une condition pour filtrer les enregistrements à l'aide de la clause WHERE. L'opération sera effectuée sur les enregistrements qui remplissent la condition donnée.

Syntaxe

Voici la syntaxe de la clause WHERE dans PostgreSQL -

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

Vous pouvez spécifier une condition de recherche à l'aide de comparaison ou d'opérateurs logiques. comme>, <, =, LIKE, NOT, etc. Les exemples suivants clarifieraient ce concept.

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -

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=#

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

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

L'instruction SELECT suivante récupère les enregistrements dont l'âge est supérieur à 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=#

Clause Where utilisant Python

Pour extraire des enregistrements spécifiques d'une table à l'aide du programme python, exécutez l' instruction SELECT avec la clause WHERE , en la passant en paramètre auexecute() méthode.

Exemple

L'exemple python suivant montre l'utilisation de la commande WHERE à l'aide de python.

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

Production

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

Habituellement, si vous essayez de récupérer des données à partir d'une table, vous obtiendrez les enregistrements dans le même ordre dans lequel vous les avez insérés.

En utilisant le ORDER BY , lors de la récupération des enregistrements d'une table, vous pouvez trier les enregistrements résultants dans l'ordre croissant ou décroissant en fonction de la colonne souhaitée.

Syntaxe

Voici la syntaxe de la clause ORDER BY dans PostgreSQL.

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

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -

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=#

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

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

L'instruction SELECT suivante récupère les lignes de la table CRICKETERS dans l'ordre croissant de leur âge -

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:

Vous pouvez utiliser plusieurs colonnes pour trier les enregistrements d'une table. Les instructions SELECT suivantes trient les enregistrements de la table CRICKETERS en fonction de l'âge des colonnes et de FIRST_NAME.

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)

Par défaut, le ORDER BYclause trie les enregistrements d'une table dans l'ordre croissant. Vous pouvez organiser les résultats par ordre décroissant en utilisant DESC comme -

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)

Clause ORDER BY à l'aide de Python

Pour récupérer le contenu d'une table dans un ordre spécifique, appelez la méthode execute () sur l'objet curseur et passez l'instruction SELECT avec la clause ORDER BY, en tant que paramètre.

Exemple

Dans l'exemple suivant, nous créons une table avec le nom et l'employé, la remplissons et récupérons ses enregistrements dans l'ordre (croissant) de leur âge, à l'aide de la clause 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()

Production

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

Vous pouvez modifier le contenu des enregistrements existants d'une table dans PostgreSQL à l'aide de l'instruction UPDATE. Pour mettre à jour des lignes spécifiques, vous devez utiliser la clause WHERE avec elle.

Syntaxe

Voici la syntaxe de l'instruction UPDATE dans PostgreSQL -

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

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -

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=#

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

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

La déclaration suivante modifie l'âge du joueur de cricket, dont le prénom est Shikhar -

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

Si vous récupérez l'enregistrement dont FIRST_NAME est Shikhar, vous constatez que la valeur d'âge a été modifiée à 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=#

Si vous n'avez pas utilisé la clause WHERE, les valeurs de tous les enregistrements seront mises à jour. L'instruction UPDATE suivante augmente l'âge de tous les enregistrements de la table CRICKETERS de 1 -

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

Si vous récupérez le contenu de la table à l'aide de la commande SELECT, vous pouvez voir les valeurs mises à jour comme -

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)

Mise à jour des enregistrements à l'aide de Python

La classe de curseur de psycopg2 fournit une méthode avec le nom de méthode execute (). Cette méthode accepte la requête en tant que paramètre et l'exécute.

Par conséquent, pour insérer des données dans une table dans PostgreSQL en utilisant python -

• Importer psycopg2 paquet.

• Créez un objet de connexion à l'aide de connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Désactivez le mode de validation automatique en définissant false comme valeur de l'attribut autocommit.

• le cursor() méthode de la ConnectionLa classe de la bibliothèque psycopg2 renvoie un objet curseur. Créez un objet curseur à l'aide de cette méthode.

• Ensuite, exécutez l'instruction UPDATE en la passant en paramètre à la méthode execute ().

Exemple

Le code Python suivant met à jour le contenu de la table Employee et récupère les résultats -

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

Production

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)
]

Vous pouvez supprimer les enregistrements d'une table existante à l'aide du DELETE FROMdéclaration de la base de données PostgreSQL. Pour supprimer des enregistrements spécifiques, vous devez utiliser la clause WHERE avec elle.

Syntaxe

Voici la syntaxe de la requête DELETE dans PostgreSQL -

DELETE FROM table_name [WHERE Clause]

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -

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=#

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

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

La déclaration suivante supprime l'enregistrement du joueur de cricket dont le nom de famille est «Sangakkara».

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

Si vous récupérez le contenu de la table à l'aide de l'instruction SELECT, vous ne pouvez voir que 4 enregistrements puisque nous en avons supprimé un.

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)

Si vous exécutez l'instruction DELETE FROM sans la clause WHERE, tous les enregistrements de la table spécifiée seront supprimés.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Puisque vous avez supprimé tous les enregistrements, si vous essayez de récupérer le contenu de la table CRICKETERS, en utilisant l'instruction SELECT, vous obtiendrez un jeu de résultats vide comme indiqué ci-dessous -

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

Suppression de données à l'aide de Python

La classe de curseur de psycopg2 fournit une méthode avec le nom de méthode execute (). Cette méthode accepte la requête en tant que paramètre et l'exécute.

Par conséquent, pour insérer des données dans une table dans PostgreSQL en utilisant python -

• Importer psycopg2 paquet.

• Créez un objet de connexion à l'aide de connect() méthode, en lui passant le nom d'utilisateur, le mot de passe, l'hôte (par défaut facultatif: localhost) et la base de données (facultatif) en tant que paramètres.

• Désactivez le mode de validation automatique en définissant false comme valeur de l'attribut autocommit.

• le cursor() méthode de la ConnectionLa classe de la bibliothèque psycopg2 renvoie un objet curseur. Créez un objet curseur à l'aide de cette méthode.

• Ensuite, exécutez l'instruction DELETE en la passant en tant que paramètre à la méthode execute ().

Exemple

Le code Python suivant supprime les enregistrements de la table EMPLOYEE avec des valeurs d'âge supérieures à 25 -

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

Production

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)
]

Vous pouvez supprimer une table de la base de données PostgreSQL à l'aide de l'instruction DROP TABLE.

Syntaxe

Voici la syntaxe de l'instruction DROP TABLE dans PostgreSQL -

DROP TABLE table_name;

Exemple

Supposons que nous ayons créé deux tables avec le nom CRICKETERS et EMPLOYEES en utilisant les requêtes suivantes -

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=#

Maintenant, si vous vérifiez la liste des tables à l'aide de la commande «\ dt», vous pouvez voir les tables créées ci-dessus comme -

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

L'instruction suivante supprime la table nommée Employee de la base de données -

postgres=# DROP table employee;
DROP TABLE

Puisque vous avez supprimé la table Employee, si vous récupérez à nouveau la liste des tables, vous ne pouvez y observer qu'une seule table.

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


postgres=#

Si vous essayez de supprimer à nouveau la table des employés, puisque vous l'avez déjà supprimée, vous obtiendrez une erreur indiquant «la table n'existe pas» comme indiqué ci-dessous -

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

Pour résoudre ce problème, vous pouvez utiliser la clause IF EXISTS avec l'instruction DELTE. Cela supprime la table si elle existe sinon ignore l'opération DLETE.

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

Suppression d'une table entière à l'aide de Python

Vous pouvez supprimer une table chaque fois que vous en avez besoin, à l'aide de l'instruction DROP. Mais vous devez être très prudent lors de la suppression d'une table existante car les données perdues ne seront pas récupérées après la suppression d'une table.

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

Production

#Table dropped...

Lors de l'exécution d'une instruction PostgreSQL SELECT, vous pouvez limiter le nombre d'enregistrements dans son résultat à l'aide de la clause LIMIT.

Syntaxe

Voici la syntaxe de la clause LMIT dans PostgreSQL -

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

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS en utilisant la requête suivante -

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=#

Et si nous y avons inséré 5 enregistrements en utilisant des instructions INSERT comme -

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

L'instruction suivante récupère les 3 premiers enregistrements de la table Cricketers à l'aide de la clause LIMIT -

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)

Si vous souhaitez obtenir des enregistrements à partir d'un enregistrement particulier (offset), vous pouvez le faire, en utilisant la clause OFFSET avec LIMIT.

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=#

Clause de limite à l'aide de Python

L'exemple python suivant récupère le contenu d'une table nommée EMPLOYEE, limitant le nombre d'enregistrements dans le résultat à 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()

Production

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

Lorsque vous avez divisé les données en deux tables, vous pouvez extraire des enregistrements combinés de ces deux tables à l'aide des jointures.

Exemple

Supposons que nous ayons créé une table avec le nom CRICKETERS et y avons inséré 5 enregistrements comme indiqué ci-dessous -

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

Et, si nous avons créé une autre table avec le nom OdiStats et inséré 5 enregistrements en tant que -

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);

L'instruction suivante récupère les données combinant les valeurs de ces deux tables -

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=#

Jointures en utilisant Python

Lorsque vous avez divisé les données en deux tables, vous pouvez extraire des enregistrements combinés de ces deux tables à l'aide des jointures.

Exemple

Le programme python suivant montre l'utilisation de la clause JOIN -

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

Production

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

La classe Cursor de la bibliothèque psycopg fournit des méthodes pour exécuter les commandes PostgreSQL dans la base de données en utilisant du code python.

En utilisant les méthodes de celui-ci, vous pouvez exécuter des instructions SQL, récupérer des données dans les ensembles de résultats, appeler des procédures.

Vous pouvez créer Cursor objet en utilisant la méthode cursor () de l'objet / de la classe Connection.

Exemple

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

Méthodes

Voici les différentes méthodes fournies par la classe / objet Cursor.

N ° Sr.	Méthodes et description
1	callproc() Cette méthode est utilisée pour appeler les procédures existantes de la base de données PostgreSQL.
2	close() Cette méthode est utilisée pour fermer l'objet curseur actuel.
3	executemany() Cette méthode accepte une série de listes de paramètres list. Prépare une requête MySQL et l'exécute avec tous les paramètres.
4	execute() Cette méthode accepte une requête MySQL comme paramètre et exécute la requête donnée.
5	fetchall() Cette méthode récupère toutes les lignes du jeu de résultats d'une requête et les renvoie sous forme de liste de tuples. (Si nous exécutons ceci après avoir récupéré quelques lignes, il renvoie les autres)
6	fetchone() Cette méthode récupère la ligne suivante dans le résultat d'une requête et la renvoie sous forme de tuple.
sept	fetchmany() Cette méthode est similaire à fetchone (), mais elle récupère le jeu de lignes suivant dans le jeu de résultats d'une requête, au lieu d'une seule ligne.

Propriétés

Voici les propriétés de la classe Cursor -

N ° Sr.	Propriété et description
1	description Il s'agit d'une propriété en lecture seule qui renvoie la liste contenant la description des colonnes dans un jeu de résultats.
2	lastrowid Il s'agit d'une propriété en lecture seule, s'il y a des colonnes auto-incrémentées dans la table, cela renvoie la valeur générée pour cette colonne lors de la dernière opération INSERT ou UPDATE.
3	rowcount Cela renvoie le nombre de lignes renvoyées / mises à jour en cas d'opérations SELECT et UPDATE.
4	closed Cette propriété spécifie si un curseur est fermé ou non, si c'est le cas, elle renvoie true, sinon false.
5	connection Cela renvoie une référence à l'objet de connexion à l'aide duquel ce curseur a été créé.
6	name Cette propriété renvoie le nom du curseur.
sept	scrollable Cette propriété spécifie si un curseur particulier peut faire défiler.