Python PostgreSQL - Guia rápido

PostgreSQL é um poderoso sistema de banco de dados objeto-relacional de código aberto. Ele tem mais de 15 anos de fase de desenvolvimento ativo e uma arquitetura comprovada que lhe rendeu uma forte reputação de confiabilidade, integridade de dados e correção.

Para se comunicar com o PostgreSQL usando Python, você precisa instalar o psycopg, um adaptador fornecido para programação em Python, a versão atual deste é psycog2.

psycopg2 foi escrito com o objetivo de ser muito pequeno, rápido e estável como uma rocha. Ele está disponível em PIP (gerenciador de pacotes de python)

Instalando Psycog2 usando PIP

Em primeiro lugar, certifique-se de que o python e o PIP estejam instalados em seu sistema corretamente e o PIP esteja atualizado.

Para atualizar o PIP, abra o prompt de comando e execute o seguinte 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

Em seguida, abra o prompt de comando no modo admin e execute o pip install psycopg2-binary comando como mostrado abaixo -

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ção

Para verificar a instalação, crie um script Python de amostra com a seguinte linha.

import mysql.connector

Se a instalação for bem-sucedida, quando você executá-la, você não deverá obter nenhum erro -

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

PostgreSQL fornece seu próprio shell para executar consultas. Para estabelecer conexão com o banco de dados PostgreSQL, certifique-se de instalá-lo corretamente em seu sistema. Abra o prompt de shell do PostgreSQL e passe detalhes como servidor, banco de dados, nome de usuário e senha. Se todos os detalhes fornecidos forem apropriados, uma conexão é estabelecida com o banco de dados PostgreSQL.

Ao passar os detalhes, você pode ir com o servidor padrão, banco de dados, porta e nome de usuário sugerido pelo shell.

Estabelecendo conexão usando Python

A classe de conexão do psycopg2representa / trata uma instância de uma conexão. Você pode criar novas conexões usando oconnect()função. Isso aceita os parâmetros básicos de conexão, como dbname, usuário, senha, host, porta e retorna um objeto de conexão. Usando esta função, você pode estabelecer uma conexão com o PostgreSQL.

Exemplo

O código Python a seguir mostra como se conectar a um banco de dados existente. Se o banco de dados não existir, ele será criado e, finalmente, um objeto de banco de dados será retornado. O nome do banco de dados padrão do PostgreSQL é postrgre. Portanto, estamos fornecendo-o como o nome do banco de dados.

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

Resultado

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

Você pode criar um banco de dados no PostgreSQL usando a instrução CREATE DATABASE. Você pode executar esta instrução no prompt do shell PostgreSQL especificando o nome do banco de dados a ser criado após o comando.

Sintaxe

A seguir está a sintaxe da instrução CREATE DATABASE.

CREATE DATABASE dbname;

Exemplo

A instrução a seguir cria um banco de dados denominado testdb em PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Você pode listar o banco de dados no PostgreSQL usando o comando \ l. Se você verificar a lista de bancos de dados, poderá encontrar o banco de dados recém-criado da seguinte forma -

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)

Você também pode criar um banco de dados no PostgreSQL a partir do prompt de comando usando o comando createdb , um wrapper em torno da instrução SQL CREATE DATABASE.

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

Criação de um banco de dados usando Python

A classe cursor do psycopg2 fornece vários métodos para executar vários comandos PostgreSQL, buscar registros e copiar dados. Você pode criar um objeto cursor usando o método cursor () da classe Connection.

O método execute () desta classe aceita uma consulta PostgreSQL como parâmetro e a executa.

Portanto, para criar um banco de dados em PostgreSQL, execute a consulta CREATE DATABASE usando este método.

Exemplo

O exemplo de python a seguir cria um banco de dados denominado mydb no banco de dados 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()

Resultado

Database created successfully........

Você pode criar uma nova tabela em um banco de dados no PostgreSQL usando a instrução CREATE TABLE. Ao executar isso, você precisa especificar o nome da tabela, os nomes das colunas e seus tipos de dados.

Sintaxe

A seguir está a sintaxe da instrução CREATE TABLE no PostgreSQL.

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

Exemplo

O exemplo a seguir cria uma tabela com o nome CRICKETERS no 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=#

Você pode obter a lista de tabelas em um banco de dados no PostgreSQL usando o comando \ dt. Depois de criar uma tabela, se você pode verificar a lista de tabelas, você pode observar a tabela recém-criada nela da seguinte forma -

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

Da mesma forma, você pode obter a descrição da tabela criada usando \ d conforme mostrado abaixo -

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

Criação de uma tabela usando Python

Para criar uma tabela usando python, você precisa executar a instrução CREATE TABLE usando o método execute () do Cursor de pyscopg2 .

Exemplo

O exemplo a seguir em Python cria uma tabela com o nome funcionário.

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

Resultado

Table created successfully........

Você pode inserir o registro em uma tabela existente no PostgreSQL usando o INSERT INTOdeclaração. Ao executar isso, você precisa especificar o nome da tabela e os valores das colunas nela.

Sintaxe

A seguir está a sintaxe recomendada da instrução INSERT -

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

Onde, coluna1, coluna2, coluna3, .. são os nomes das colunas de uma tabela e valor1, valor2, valor3, ... são os valores que você precisa inserir na tabela.

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a instrução CREATE TABLE conforme mostrado abaixo -

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

A instrução PostgreSQL seguinte insere uma linha na tabela criada acima -

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

Ao inserir registros usando a instrução INSERT INTO, se você pular quaisquer nomes de colunas, o registro será inserido deixando espaços vazios nas colunas que você pulou.

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

Você também pode inserir registros em uma tabela sem especificar os nomes das colunas, se a ordem dos valores transmitidos for a mesma dos respectivos nomes das colunas na tabela.

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

Depois de inserir os registros em uma tabela, você pode verificar seu conteúdo usando a instrução SELECT conforme mostrado abaixo -

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)

Inserindo dados usando Python

A classe cursor de psycopg2 fornece um método com o nome método execute (). Este método aceita a consulta como parâmetro e a executa.

Portanto, para inserir dados em uma tabela no PostgreSQL usando python -

• Importar psycopg2 pacote.

• Crie um objeto de conexão usando o connect() , passando o nome de usuário, senha, host (padrão opcional: localhost) e banco de dados (opcional) como parâmetros para ele.

• Desligue o modo auto-commit definindo false como valor para o atributo autocommit.

• o cursor() método do Connectionclasse da biblioteca psycopg2 retorna um objeto cursor. Crie um objeto cursor usando este método.

• Em seguida, execute a (s) instrução (ões) INSERT passando-a (s) como parâmetro para o método execute ().

Exemplo

O programa Python seguinte cria uma tabela com o nome EMPLOYEE no banco de dados PostgreSQL e insere registros nela usando o método 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()

Resultado

Records inserted........

Você pode recuperar o conteúdo de uma tabela existente no PostgreSQL usando a instrução SELECT. Nesta instrução, você precisa especificar o nome da tabela e ela retorna seu conteúdo em formato tabular, que é conhecido como conjunto de resultados.

Sintaxe

A seguir está a sintaxe da instrução SELECT no PostgreSQL -

SELECT column1, column2, columnN FROM table_name;

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

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 tivermos inserido 5 registros nele usando instruções INSERT como -

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

A consulta SELECT seguinte recupera os valores das colunas FIRST_NAME, LAST_NAME e, COUNTRY da tabela 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 você deseja recuperar todas as colunas de cada registro, você precisa substituir os nomes das colunas por "⚹" como mostrado abaixo -

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

Recuperando dados usando Python

A operação READ em qualquer banco de dados significa buscar algumas informações úteis do banco de dados. Você pode buscar dados do PostgreSQL usando o método fetch () fornecido pelo psycopg2.

A classe Cursor fornece três métodos: fetchall (), fetchmany () e fetchone (), onde,

• O método fetchall () recupera todas as linhas no conjunto de resultados de uma consulta e as retorna como uma lista de tuplas. (Se executarmos isso depois de recuperar algumas linhas, ele retornará as restantes).

• O método fetchone () busca a próxima linha no resultado de uma consulta e a retorna como uma tupla.

Note - Um conjunto de resultados é um objeto que é retornado quando um objeto cursor é usado para consultar uma tabela.

Exemplo

O programa Python a seguir se conecta a um banco de dados chamado mydb do PostgreSQL e recupera todos os registros de uma tabela chamada 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()

Resultado

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

Ao executar as operações SELECT, UPDATE ou DELETE, você pode especificar a condição para filtrar os registros usando a cláusula WHERE. A operação será realizada nos registros que satisfaçam a condição dada.

Sintaxe

A seguir está a sintaxe da cláusula WHERE no PostgreSQL -

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

Você pode especificar um search_condition usando comparação ou operadores lógicos. like>, <, =, LIKE, NOT, etc. Os exemplos a seguir tornariam esse conceito claro.

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

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 tivermos inserido 5 registros nele usando instruções INSERT como -

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

A seguinte instrução SELECT recupera os registros cuja idade é maior que 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=#

Cláusula Where usando Python

Para buscar registros específicos de uma tabela usando o programa python, execute a instrução SELECT com a cláusula WHERE , passando-a como um parâmetro para oexecute() método.

Exemplo

O exemplo de python a seguir demonstra o uso do 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()

Resultado

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

Normalmente, se você tentar recuperar dados de uma tabela, obterá os registros na mesma ordem em que os inseriu.

Usando o ORDER BY , ao recuperar os registros de uma tabela, você pode classificar os registros resultantes em ordem crescente ou decrescente com base na coluna desejada.

Sintaxe

A seguir está a sintaxe da cláusula ORDER BY no PostgreSQL.

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

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

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 tivermos inserido 5 registros nele usando instruções INSERT como -

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

A instrução SELECT seguinte recupera as linhas da tabela CRICKETERS na ordem crescente de sua idade -

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:

Você pode usar mais de uma coluna para classificar os registros de uma tabela. As seguintes instruções SELECT classificam os registros da tabela CRICKETERS com base nas colunas age 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)

Por padrão, o ORDER BYcláusula classifica os registros de uma tabela em ordem crescente. Você pode organizar os resultados em ordem decrescente usando DESC como -

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)

Cláusula ORDER BY usando Python

Para recuperar o conteúdo de uma tabela em uma ordem específica, invoque o método execute () no objeto cursor e passe a instrução SELECT junto com a cláusula ORDER BY como um parâmetro para ela.

Exemplo

No exemplo a seguir, estamos criando uma tabela com nome e Funcionário, preenchendo-a e recuperando seus registros na ordem (crescente) de sua idade, usando a cláusula 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()

Resultado

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

Você pode modificar o conteúdo dos registros existentes de uma tabela no PostgreSQL usando a instrução UPDATE. Para atualizar linhas específicas, você precisa usar a cláusula WHERE junto com ela.

Sintaxe

A seguir está a sintaxe da instrução UPDATE no PostgreSQL -

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

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

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 tivermos inserido 5 registros nele usando instruções INSERT como -

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

A declaração a seguir modifica a idade do jogador de críquete, cujo primeiro nome é Shikhar -

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

Se você recuperar o registro cujo FIRST_NAME é Shikhar, você observará que o valor da idade foi alterado para 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 você não usou a cláusula WHERE, os valores de todos os registros serão atualizados. A instrução UPDATE seguinte aumenta a idade de todos os registros na tabela CRICKETERS em 1 -

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

Se você recuperar o conteúdo da tabela usando o comando SELECT, poderá ver os valores atualizados como -

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)

Atualizando registros usando Python

A classe cursor de psycopg2 fornece um método com o nome método execute (). Este método aceita a consulta como parâmetro e a executa.

Portanto, para inserir dados em uma tabela no PostgreSQL usando python -

• Importar psycopg2 pacote.

• Crie um objeto de conexão usando o connect() , passando o nome de usuário, senha, host (padrão opcional: localhost) e banco de dados (opcional) como parâmetros para ele.

• Desligue o modo auto-commit definindo false como valor para o atributo autocommit.

• o cursor() método do Connectionclasse da biblioteca psycopg2 retorna um objeto cursor. Crie um objeto cursor usando este método.

• Em seguida, execute a instrução UPDATE passando-a como um parâmetro para o método execute ().

Exemplo

O código Python seguinte atualiza o conteúdo da tabela Employee e recupera os resultados -

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

Resultado

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

Você pode excluir os registros em uma tabela existente usando o DELETE FROMdeclaração do banco de dados PostgreSQL. Para remover registros específicos, você precisa usar a cláusula WHERE junto com ele.

Sintaxe

A seguir está a sintaxe da consulta DELETE no PostgreSQL -

DELETE FROM table_name [WHERE Clause]

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

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 tivermos inserido 5 registros nele usando instruções INSERT como -

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

A declaração a seguir exclui o registro do jogador de críquete cujo sobrenome é 'Sangakkara'.

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

Se você recuperar o conteúdo da tabela usando a instrução SELECT, poderá ver apenas 4 registros, já que excluímos um.

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 você executar a instrução DELETE FROM sem a cláusula WHERE, todos os registros da tabela especificada serão excluídos.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Uma vez que você excluiu todos os registros, se você tentar recuperar o conteúdo da tabela CRICKETERS, usando a instrução SELECT, você obterá um conjunto de resultados vazio conforme mostrado abaixo -

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

Exclusão de dados usando Python

A classe cursor de psycopg2 fornece um método com o nome método execute (). Este método aceita a consulta como parâmetro e a executa.

Portanto, para inserir dados em uma tabela no PostgreSQL usando python -

• Importar psycopg2 pacote.

• Crie um objeto de conexão usando o connect() , passando o nome de usuário, senha, host (padrão opcional: localhost) e banco de dados (opcional) como parâmetros para ele.

• Desligue o modo auto-commit definindo false como valor para o atributo autocommit.

• o cursor() método do Connectionclasse da biblioteca psycopg2 retorna um objeto cursor. Crie um objeto cursor usando este método.

• Em seguida, execute a instrução DELETE passando-a como um parâmetro para o método execute ().

Exemplo

O código Python seguinte exclui registros da tabela EMPLOYEE com valores de idade maiores que 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()

Resultado

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

Você pode eliminar uma tabela do banco de dados PostgreSQL usando a instrução DROP TABLE.

Sintaxe

A seguir está a sintaxe da instrução DROP TABLE no PostgreSQL -

DROP TABLE table_name;

Exemplo

Suponha que criamos duas tabelas com o nome CRICKETERS e EMPLOYEES usando as seguintes consultas -

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

Agora, se você verificar a lista de tabelas usando o comando “\ dt”, poderá ver as tabelas criadas acima como -

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

A declaração a seguir exclui a tabela chamada Employee do banco de dados -

postgres=# DROP table employee;
DROP TABLE

Visto que você excluiu a tabela Employee, se você recuperar a lista de tabelas novamente, poderá observar apenas uma tabela nela.

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


postgres=#

Se você tentar deletar a tabela Employee novamente, uma vez que você já a deletou, você obterá um erro dizendo “table does not exist” conforme mostrado abaixo -

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

Para resolver isso, você pode usar a cláusula IF EXISTS junto com a instrução DELTE. Isso remove a tabela se ela existir, senão pula a operação DLETE.

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

Removendo uma tabela inteira usando Python

Você pode descartar uma tabela sempre que precisar, usando a instrução DROP. Mas você precisa ter muito cuidado ao excluir qualquer tabela existente, pois os dados perdidos não serão recuperados após a exclusão de uma tabela.

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

Resultado

#Table dropped...

Ao executar uma instrução SELECT do PostgreSQL, você pode limitar o número de registros em seu resultado usando a cláusula LIMIT.

Sintaxe

A seguir está a sintaxe da cláusula LMIT no PostgreSQL -

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

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS usando a seguinte consulta -

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 tivermos inserido 5 registros nele usando instruções INSERT como -

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

A instrução a seguir recupera os primeiros 3 registros da tabela de Cricketers usando a cláusula 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 você deseja obter registros a partir de um determinado registro (deslocamento), pode fazê-lo, usando a cláusula OFFSET junto com 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=#

Cláusula Limite usando Python

O exemplo de python a seguir recupera o conteúdo de uma tabela chamada EMPLOYEE, limitando o número de registros no resultado 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()

Resultado

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

Depois de dividir os dados em duas tabelas, você pode buscar registros combinados dessas duas tabelas usando Joins.

Exemplo

Suponha que criamos uma tabela com o nome CRICKETERS e inserimos 5 registros nela como mostrado abaixo -

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 tivermos criado outra tabela com o nome OdiStats e inserido 5 registros nela como -

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

A instrução a seguir recupera dados combinando os valores nessas duas tabelas -

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

Associações usando Python

Depois de dividir os dados em duas tabelas, você pode buscar registros combinados dessas duas tabelas usando Joins.

Exemplo

O seguinte programa python demonstra o uso da cláusula 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()

Resultado

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

A classe Cursor da biblioteca psycopg fornece métodos para executar os comandos PostgreSQL no banco de dados usando código python.

Usando seus métodos, você pode executar instruções SQL, buscar dados dos conjuntos de resultados, chamar procedimentos.

Você pode criar Cursor usando o método cursor () do objeto / classe Connection.

Exemplo

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étodos

A seguir estão os vários métodos fornecidos pela classe / objeto Cursor.

Sr. Não.	Métodos e Descrição
1	callproc() Este método é usado para chamar o banco de dados PostgreSQL de procedimentos existentes.
2	close() Este método é usado para fechar o objeto cursor atual.
3	executemany() Este método aceita uma série de lista de lista de parâmetros. Prepara uma consulta MySQL e a executa com todos os parâmetros.
4	execute() Este método aceita uma consulta MySQL como parâmetro e executa a consulta fornecida.
5	fetchall() Este método recupera todas as linhas no conjunto de resultados de uma consulta e as retorna como uma lista de tuplas. (Se executarmos isso depois de recuperar algumas linhas, ele retornará as restantes)
6	fetchone() Este método busca a próxima linha no resultado de uma consulta e a retorna como uma tupla.
7	fetchmany() Este método é semelhante ao fetchone (), mas recupera o próximo conjunto de linhas no conjunto de resultados de uma consulta, em vez de uma única linha.

Propriedades

A seguir estão as propriedades da classe Cursor -

Sr. Não.	Descrição da Propriedade
1	description Esta é uma propriedade somente leitura que retorna a lista contendo a descrição das colunas em um conjunto de resultados.
2	lastrowid Esta é uma propriedade somente leitura; se houver alguma coluna com incremento automático na tabela, ela retornará o valor gerado para aquela coluna na última operação INSERT ou UPDATE.
3	rowcount Isso retorna o número de linhas retornadas / atualizadas no caso de operações SELECT e UPDATE.
4	closed Esta propriedade especifica se um cursor está fechado ou não, em caso afirmativo, retorna verdadeiro, senão falso.
5	connection Isso retorna uma referência ao objeto de conexão usando o qual este cursor foi criado.
6	name Esta propriedade retorna o nome do cursor.
7	scrollable Esta propriedade especifica se um determinado cursor é rolável.