Python PostgreSQL - Guida rapida

PostgreSQL è un potente sistema di database relazionale a oggetti open source. Ha più di 15 anni di fase di sviluppo attivo e un'architettura collaudata che le hanno guadagnato una solida reputazione per affidabilità, integrità dei dati e correttezza.

Per comunicare con PostgreSQL usando Python è necessario installare psycopg, un adattatore fornito per la programmazione python, la versione corrente di questo è psycog2.

psycopg2 è stato scritto con l'obiettivo di essere molto piccolo e veloce e stabile come una roccia. È disponibile sotto PIP (gestore di pacchetti di python)

Installazione di Psycog2 utilizzando PIP

Prima di tutto, assicurati che python e PIP siano installati correttamente nel tuo sistema e che PIP sia aggiornato.

Per aggiornare PIP, apri il prompt dei comandi ed esegui il seguente comando:

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

Quindi, apri il prompt dei comandi in modalità amministratore ed esegui il file pip install psycopg2-binary comando come mostrato di seguito -

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

Verifica

Per verificare l'installazione, creare uno script Python di esempio con la seguente riga.

import mysql.connector

Se l'installazione ha successo, quando la esegui, non dovresti ricevere alcun errore -

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

PostgreSQL fornisce la propria shell per eseguire le query. Per stabilire la connessione con il database PostgreSQL, assicurati di averlo installato correttamente nel tuo sistema. Apri il prompt della shell di PostgreSQL e passa i dettagli come server, database, nome utente e password. Se tutti i dettagli che hai fornito sono appropriati, viene stabilita una connessione con il database PostgreSQL.

Durante il passaggio dei dettagli puoi andare con il server predefinito, il database, la porta e il nome utente suggerito dalla shell.

Stabilire una connessione usando Python

La classe di connessione di psycopg2rappresenta / gestisce un'istanza di una connessione. È possibile creare nuove connessioni utilizzando ilconnect()funzione. Accetta i parametri di connessione di base come nome db, utente, password, host, porta e restituisce un oggetto di connessione. Usando questa funzione, puoi stabilire una connessione con PostgreSQL.

Esempio

Il seguente codice Python mostra come connettersi a un database esistente. Se il database non esiste, verrà creato e infine verrà restituito un oggetto database. Il nome del database predefinito di PostgreSQL è postrgre. Pertanto, lo stiamo fornendo come nome del database.

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

Produzione

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

Puoi creare un database in PostgreSQL utilizzando l'istruzione CREATE DATABASE. È possibile eseguire questa istruzione nel prompt della shell di PostgreSQL specificando il nome del database da creare dopo il comando.

Sintassi

Di seguito è riportata la sintassi dell'istruzione CREATE DATABASE.

CREATE DATABASE dbname;

Esempio

La seguente istruzione crea un database denominato testdb in PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Puoi elencare il database in PostgreSQL usando il comando \ l. Se verifichi l'elenco dei database, puoi trovare il database appena creato come segue:

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)

Puoi anche creare un database in PostgreSQL dal prompt dei comandi utilizzando il comando createdb , un wrapper attorno all'istruzione SQL CREATE DATABASE.

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

Creazione di un database utilizzando Python

La classe del cursore di psycopg2 fornisce vari metodi per eseguire vari comandi PostgreSQL, recuperare record e copiare dati. È possibile creare un oggetto cursore utilizzando il metodo cursor () della classe Connection.

Il metodo execute () di questa classe accetta una query PostgreSQL come parametro e la esegue.

Pertanto, per creare un database in PostgreSQL, eseguire la query CREATE DATABASE utilizzando questo metodo.

Esempio

L'esempio seguente di Python crea un database denominato mydb nel database 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()

Produzione

Database created successfully........

Puoi creare una nuova tabella in un database in PostgreSQL utilizzando l'istruzione CREATE TABLE. Durante l'esecuzione è necessario specificare il nome della tabella, i nomi delle colonne e i loro tipi di dati.

Sintassi

Di seguito è riportata la sintassi dell'istruzione CREATE TABLE in PostgreSQL.

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

Esempio

L'esempio seguente crea una tabella con il nome CRICKETERS in 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=#

Puoi ottenere l'elenco delle tabelle in un database in PostgreSQL utilizzando il comando \ dt. Dopo aver creato una tabella, se puoi verificare l'elenco delle tabelle puoi osservare la tabella appena creata al suo interno come segue:

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

Allo stesso modo, puoi ottenere la descrizione della tabella creata usando \ d come mostrato di seguito -

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

Creazione di una tabella utilizzando Python

Per creare una tabella utilizzando python è necessario eseguire l'istruzione CREATE TABLE utilizzando il metodo execute () del cursore di pyscopg2 .

Esempio

Il seguente esempio di Python crea una tabella con il nome dipendente.

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

Produzione

Table created successfully........

Puoi inserire record in una tabella esistente in PostgreSQL usando il INSERT INTOdichiarazione. Durante l'esecuzione, è necessario specificare il nome della tabella e i valori per le colonne in essa contenute.

Sintassi

Di seguito è riportata la sintassi consigliata dell'istruzione INSERT:

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

Dove, colonna1, colonna2, colonna3, .. sono i nomi delle colonne di una tabella e valore1, valore2, valore3, ... sono i valori che devi inserire nella tabella.

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando l'istruzione CREATE TABLE come mostrato di seguito -

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

La seguente istruzione PostgreSQL inserisce una riga nella tabella creata sopra -

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

Durante l'inserimento di record utilizzando l'istruzione INSERT INTO, se si salta qualsiasi nome di colonna, il record verrà inserito lasciando spazi vuoti nelle colonne che sono state ignorate.

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

Puoi anche inserire record in una tabella senza specificare i nomi delle colonne, se l'ordine dei valori passati è lo stesso dei rispettivi nomi delle colonne nella tabella.

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

Dopo aver inserito i record in una tabella è possibile verificarne il contenuto utilizzando l'istruzione SELECT come mostrato di seguito -

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)

Inserimento di dati utilizzando Python

La classe del cursore di psycopg2 fornisce un metodo con nome metodo execute (). Questo metodo accetta la query come parametro e la esegue.

Pertanto, per inserire dati in una tabella in PostgreSQL usando python -

• Importare psycopg2 pacchetto.

• Crea un oggetto connessione usando il connect() metodo, passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Disattiva la modalità di commit automatico impostando false come valore nell'attributo autocommit.

• Il cursor() metodo del Connectionclass della libreria psycopg2 restituisce un oggetto cursore. Crea un oggetto cursore utilizzando questo metodo.

• Quindi, esegui le istruzioni INSERT passandole come parametro al metodo execute ().

Esempio

Il seguente programma Python crea una tabella con il nome EMPLOYEE nel database PostgreSQL e inserisce i record al suo interno usando il metodo 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()

Produzione

Records inserted........

Puoi recuperare il contenuto di una tabella esistente in PostgreSQL utilizzando l'istruzione SELECT. In questa istruzione, è necessario specificare il nome della tabella e restituisce il suo contenuto in formato tabulare noto come set di risultati.

Sintassi

Di seguito è riportata la sintassi dell'istruzione SELECT in PostgreSQL:

SELECT column1, column2, columnN FROM table_name;

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente query SELECT recupera i valori delle colonne FIRST_NAME, LAST_NAME e COUNTRY dalla tabella 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)

Se vuoi recuperare tutte le colonne di ogni record devi sostituire i nomi delle colonne con "⚹" come mostrato di seguito -

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

Recupero dei dati utilizzando Python

READ Operare su qualsiasi database significa prelevare alcune informazioni utili dal database. Puoi recuperare i dati da PostgreSQL usando il metodo fetch () fornito da psycopg2.

La classe Cursor fornisce tre metodi e cioè fetchall (), fetchmany () e fetchone () dove,

• Il metodo fetchall () recupera tutte le righe nel set di risultati di una query e le restituisce come elenco di tuple. (Se lo eseguiamo dopo aver recuperato poche righe, restituisce quelle rimanenti).

• Il metodo fetchone () recupera la riga successiva nel risultato di una query e la restituisce come una tupla.

Note - Un set di risultati è un oggetto restituito quando un oggetto cursore viene utilizzato per interrogare una tabella.

Esempio

Il seguente programma Python si connette a un database chiamato mydb di PostgreSQL e recupera tutti i record da una tabella chiamata 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()

Produzione

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

Durante l'esecuzione di operazioni SELECT, UPDATE o, DELETE, è possibile specificare la condizione per filtrare i record utilizzando la clausola WHERE. L'operazione verrà eseguita sui record che soddisfano la condizione data.

Sintassi

Di seguito è riportata la sintassi della clausola WHERE in PostgreSQL:

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

È possibile specificare una condizione_ricerca utilizzando il confronto o gli operatori logici. come>, <, =, LIKE, NOT, ecc. I seguenti esempi renderebbero chiaro questo concetto.

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente istruzione SELECT recupera i record la cui età è maggiore di 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=#

Clausola Where utilizzando Python

Per recuperare record specifici da una tabella utilizzando il programma python eseguire l' istruzione SELECT con la clausola WHERE , passandola come parametro alexecute() metodo.

Esempio

Il seguente esempio di python dimostra l'uso del comando WHERE usando 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()

Produzione

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

Di solito se provi a recuperare i dati da una tabella, otterrai i record nello stesso ordine in cui li hai inseriti.

Usando il ORDER BY , durante il recupero dei record di una tabella è possibile ordinare i record risultanti in ordine crescente o decrescente in base alla colonna desiderata.

Sintassi

Di seguito è riportata la sintassi della clausola ORDER BY in PostgreSQL.

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

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente istruzione SELECT recupera le righe della tabella CRICKETERS in ordine crescente in base alla loro età -

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:

È possibile utilizzare più di una colonna per ordinare i record di una tabella. Le seguenti istruzioni SELECT ordinano i record della tabella CRICKETERS in base alle colonne età e 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)

Per impostazione predefinita, il ORDER BYla clausola ordina i record di una tabella in ordine crescente. Puoi disporre i risultati in ordine decrescente utilizzando DESC come -

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)

Clausola ORDER BY utilizzando Python

Per recuperare il contenuto di una tabella in un ordine specifico, richiamare il metodo execute () sull'oggetto cursore e passare l'istruzione SELECT insieme alla clausola ORDER BY, come parametro ad esso.

Esempio

Nell'esempio seguente, creiamo una tabella con nome e Employee, la popoliamo e ne recuperiamo i record nell'ordine (crescente) della loro età, utilizzando la clausola 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()

Produzione

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

Puoi modificare il contenuto dei record esistenti di una tabella in PostgreSQL utilizzando l'istruzione UPDATE. Per aggiornare righe specifiche, è necessario utilizzare la clausola WHERE insieme ad essa.

Sintassi

Di seguito è riportata la sintassi dell'istruzione UPDATE in PostgreSQL:

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

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente dichiarazione modifica l'età del giocatore di cricket, il cui nome è Shikhar -

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

Se recuperi il record il cui FIRST_NAME è Shikhar, osservi che il valore dell'età è stato modificato in 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=#

Se non hai utilizzato la clausola WHERE, i valori di tutti i record verranno aggiornati. La seguente istruzione UPDATE aumenta l'età di tutti i record nella tabella CRICKETERS di 1 -

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

Se recuperi il contenuto della tabella utilizzando il comando SELEZIONA, puoi vedere i valori aggiornati come -

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)

Aggiornare i record usando Python

La classe del cursore di psycopg2 fornisce un metodo con nome metodo execute (). Questo metodo accetta la query come parametro e la esegue.

Pertanto, per inserire dati in una tabella in PostgreSQL usando python -

• Importare psycopg2 pacchetto.

• Crea un oggetto connessione usando il connect() metodo, passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Disattiva la modalità di commit automatico impostando false come valore nell'attributo autocommit.

• Il cursor() metodo del Connectionclass della libreria psycopg2 restituisce un oggetto cursore. Crea un oggetto cursore utilizzando questo metodo.

• Quindi, eseguire l'istruzione UPDATE passandola come parametro al metodo execute ().

Esempio

Il codice Python seguente aggiorna il contenuto della tabella Employee e recupera i risultati -

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

Produzione

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

È possibile eliminare i record in una tabella esistente utilizzando il DELETE FROMdichiarazione del database PostgreSQL. Per rimuovere record specifici, è necessario utilizzare la clausola WHERE insieme ad essa.

Sintassi

Di seguito è riportata la sintassi della query DELETE in PostgreSQL:

DELETE FROM table_name [WHERE Clause]

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente dichiarazione cancella il record del giocatore di cricket il cui cognome è "Sangakkara".

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

Se recuperi il contenuto della tabella utilizzando l'istruzione SELECT, puoi vedere solo 4 record poiché ne abbiamo eliminato uno.

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)

Se si esegue l'istruzione DELETE FROM senza la clausola WHERE, tutti i record della tabella specificata verranno eliminati.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Poiché hai cancellato tutti i record, se provi a recuperare il contenuto della tabella CRICKETERS, usando l'istruzione SELECT otterrai un set di risultati vuoto come mostrato di seguito -

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

Eliminazione dei dati utilizzando Python

La classe del cursore di psycopg2 fornisce un metodo con nome metodo execute (). Questo metodo accetta la query come parametro e la esegue.

Pertanto, per inserire dati in una tabella in PostgreSQL usando python -

• Importare psycopg2 pacchetto.

• Crea un oggetto connessione usando il connect() metodo, passando il nome utente, la password, l'host (predefinito opzionale: localhost) e il database (opzionale) come parametri ad esso.

• Disattiva la modalità di commit automatico impostando false come valore nell'attributo autocommit.

• Il cursor() metodo del Connectionclass della libreria psycopg2 restituisce un oggetto cursore. Crea un oggetto cursore utilizzando questo metodo.

• Quindi, eseguite l'istruzione DELETE passandola come parametro al metodo execute ().

Esempio

Il seguente codice Python elimina i record della tabella EMPLOYEE con valori di età maggiori di 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()

Produzione

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

Puoi eliminare una tabella dal database PostgreSQL utilizzando l'istruzione DROP TABLE.

Sintassi

Di seguito è riportata la sintassi dell'istruzione DROP TABLE in PostgreSQL:

DROP TABLE table_name;

Esempio

Supponiamo di aver creato due tabelle con il nome CRICKETERS e EMPLOYEES utilizzando le seguenti query:

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

Ora se verifichi l'elenco delle tabelle utilizzando il comando "\ dt", puoi vedere le tabelle create sopra come -

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

La seguente istruzione elimina la tabella denominata Employee dal database:

postgres=# DROP table employee;
DROP TABLE

Poiché hai eliminato la tabella Employee, se recuperi nuovamente l'elenco delle tabelle, puoi osservare solo una tabella al suo interno.

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


postgres=#

Se provi a eliminare di nuovo la tabella Employee, poiché l'hai già eliminata, riceverai un errore che dice "la tabella non esiste" come mostrato di seguito -

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

Per risolvere questo problema, è possibile utilizzare la clausola IF EXISTS insieme all'istruzione DELTE. Ciò rimuove la tabella se esiste altrimenti salta l'operazione DLETE.

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

Rimozione di un'intera tabella utilizzando Python

È possibile eliminare una tabella ogni volta che è necessario, utilizzando l'istruzione DROP. Ma devi stare molto attento durante l'eliminazione di qualsiasi tabella esistente perché i dati persi non verranno recuperati dopo aver eliminato una tabella.

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

Produzione

#Table dropped...

Durante l'esecuzione di un'istruzione PostgreSQL SELECT è possibile limitare il numero di record nel suo risultato utilizzando la clausola LIMIT.

Sintassi

Di seguito è riportata la sintassi della clausola LMIT in PostgreSQL:

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

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS utilizzando la seguente query:

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

E se abbiamo inserito 5 record in esso utilizzando le istruzioni INSERT come -

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 seguente dichiarazione recupera i primi 3 record della tabella Cricketers utilizzando la clausola 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)

Se vuoi ottenere record a partire da un record particolare (offset) puoi farlo, utilizzando la clausola OFFSET insieme a 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=#

Clausola limite utilizzando Python

L'esempio seguente di Python recupera il contenuto di una tabella denominata EMPLOYEE, limitando il numero di record nel risultato a 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()

Produzione

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

Dopo aver diviso i dati in due tabelle, è possibile recuperare i record combinati da queste due tabelle utilizzando i join.

Esempio

Supponiamo di aver creato una tabella con il nome CRICKETERS e di aver inserito 5 record in essa come mostrato di seguito -

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

E, se abbiamo creato un'altra tabella con il nome OdiStats e inserito 5 record in essa come -

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

La seguente istruzione recupera i dati combinando i valori in queste due tabelle:

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

Si unisce utilizzando Python

Dopo aver diviso i dati in due tabelle, è possibile recuperare i record combinati da queste due tabelle utilizzando i join.

Esempio

Il seguente programma python dimostra l'uso della clausola 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()

Produzione

[
   ('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 della libreria psycopg fornisce metodi per eseguire i comandi PostgreSQL nel database utilizzando codice python.

Usandone i metodi è possibile eseguire istruzioni SQL, prelevare dati dai set di risultati, chiamare procedure.

Puoi creare Cursor oggetto utilizzando il metodo cursor () dell'oggetto / classe Connection.

Esempio

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

Metodi

Di seguito sono riportati i vari metodi forniti dalla classe / oggetto Cursor.

Sr.No.	Metodi e descrizione
1	callproc() Questo metodo viene utilizzato per chiamare le procedure esistenti database PostgreSQL.
2	close() Questo metodo viene utilizzato per chiudere l'oggetto cursore corrente.
3	executemany() Questo metodo accetta una serie di elenchi di elenchi di parametri. Prepara una query MySQL e la esegue con tutti i parametri.
4	execute() Questo metodo accetta una query MySQL come parametro ed esegue la query fornita.
5	fetchall() Questo metodo recupera tutte le righe nel set di risultati di una query e le restituisce come elenco di tuple. (Se lo eseguiamo dopo aver recuperato poche righe, restituisce quelle rimanenti)
6	fetchone() Questo metodo recupera la riga successiva nel risultato di una query e la restituisce come una tupla.
7	fetchmany() Questo metodo è simile a fetchone () ma recupera il successivo set di righe nel set di risultati di una query, invece di una singola riga.

Proprietà

Di seguito sono riportate le proprietà della classe Cursor:

Sr.No.	Proprietà e descrizione
1	description Questa è una proprietà di sola lettura che restituisce l'elenco contenente la descrizione delle colonne in un set di risultati.
2	lastrowid Questa è una proprietà di sola lettura, se nella tabella sono presenti colonne con incremento automatico, restituisce il valore generato per quella colonna nell'ultima operazione INSERT o UPDATE.
3	rowcount Restituisce il numero di righe restituite / aggiornate in caso di operazioni SELECT e UPDATE.
4	closed Questa proprietà specifica se un cursore è chiuso o meno, in tal caso restituisce true, altrimenti false.
5	connection Ciò restituisce un riferimento all'oggetto di connessione utilizzando il quale è stato creato questo cursore.
6	name Questa proprietà restituisce il nome del cursore.
7	scrollable Questa proprietà specifica se un particolare cursore è scorrevole.