Python PostgreSQL - Guía rápida

PostgreSQL es un potente sistema de base de datos relacional de objetos de código abierto. Tiene más de 15 años de fase de desarrollo activo y una arquitectura probada que le ha valido una sólida reputación por su fiabilidad, integridad y corrección de datos.

Para comunicarse con PostgreSQL usando Python, necesita instalar psycopg, un adaptador proporcionado para la programación de Python, la versión actual de este es psycog2.

psycopg2 fue escrito con el objetivo de ser muy pequeño y rápido, y estable como una roca. Está disponible en PIP (administrador de paquetes de python)

Instalación de Psycog2 usando PIP

En primer lugar, asegúrese de que Python y PIP estén instalados correctamente en su sistema y que PIP esté actualizado.

Para actualizar PIP, abra el símbolo del sistema y ejecute el siguiente 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

Luego, abra el símbolo del sistema en modo de administrador y ejecute el pip install psycopg2-binary comando como se muestra a continuación -

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

Verificación

Para verificar la instalación, cree una secuencia de comandos de Python de muestra con la siguiente línea.

import mysql.connector

Si la instalación es exitosa, cuando la ejecute, no debería recibir ningún error:

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

PostgreSQL proporciona su propio shell para ejecutar consultas. Para establecer conexión con la base de datos PostgreSQL, asegúrese de haberla instalado correctamente en su sistema. Abra el indicador de shell de PostgreSQL y pase detalles como servidor, base de datos, nombre de usuario y contraseña. Si todos los detalles que ha proporcionado son apropiados, se establece una conexión con la base de datos PostgreSQL.

Mientras pasa los detalles, puede ir con el servidor predeterminado, la base de datos, el puerto y el nombre de usuario sugerido por el shell.

Estableciendo conexión usando Python

La clase de conexión del psycopg2representa / maneja una instancia de una conexión. Puede crear nuevas conexiones utilizando elconnect()función. Esto acepta los parámetros de conexión básicos como dbname, usuario, contraseña, host, puerto y devuelve un objeto de conexión. Con esta función, puede establecer una conexión con PostgreSQL.

Ejemplo

El siguiente código de Python muestra cómo conectarse a una base de datos existente. Si la base de datos no existe, se creará y finalmente se devolverá un objeto de base de datos. El nombre de la base de datos predeterminada de PostgreSQL es postrgre. Por lo tanto, lo estamos proporcionando como el nombre de la base de datos.

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

Salida

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

Puede crear una base de datos en PostgreSQL usando la instrucción CREATE DATABASE. Puede ejecutar esta declaración en el indicador de shell de PostgreSQL especificando el nombre de la base de datos que se creará después del comando.

Sintaxis

A continuación se muestra la sintaxis de la instrucción CREATE DATABASE.

CREATE DATABASE dbname;

Ejemplo

La siguiente declaración crea una base de datos llamada testdb en PostgreSQL.

postgres=# CREATE DATABASE testdb;
CREATE DATABASE

Puede listar la base de datos en PostgreSQL usando el comando \ l. Si verifica la lista de bases de datos, puede encontrar la base de datos recién creada de la siguiente manera:

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)

También puede crear una base de datos en PostgreSQL desde el símbolo del sistema usando el comando createdb , un contenedor alrededor de la declaración SQL CREATE DATABASE.

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

Creando una base de datos usando Python

La clase de cursor de psycopg2 proporciona varios métodos para ejecutar varios comandos de PostgreSQL, recuperar registros y copiar datos. Puede crear un objeto de cursor utilizando el método cursor () de la clase Connection.

El método execute () de esta clase acepta una consulta PostgreSQL como parámetro y la ejecuta.

Por lo tanto, para crear una base de datos en PostgreSQL, ejecute la consulta CREATE DATABASE usando este método.

Ejemplo

El siguiente ejemplo de Python crea una base de datos llamada mydb en la base de datos 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()

Salida

Database created successfully........

Puede crear una nueva tabla en una base de datos en PostgreSQL usando la declaración CREATE TABLE. Al ejecutar esto, debe especificar el nombre de la tabla, los nombres de las columnas y sus tipos de datos.

Sintaxis

A continuación se muestra la sintaxis de la declaración CREATE TABLE en PostgreSQL.

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

Ejemplo

El siguiente ejemplo crea una tabla con el nombre CRICKETERS en 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=#

Puede obtener la lista de tablas en una base de datos en PostgreSQL usando el comando \ dt. Después de crear una tabla, si puede verificar la lista de tablas, puede observar la tabla recién creada en ella de la siguiente manera:

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

De la misma manera, puede obtener la descripción de la tabla creada usando \ d como se muestra a continuación:

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

Creando una tabla usando Python

Para crear una tabla usando Python, necesita ejecutar la instrucción CREATE TABLE usando el método execute () del Cursor de pyscopg2 .

Ejemplo

El siguiente ejemplo de Python crea una tabla con el nombre empleado.

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

Salida

Table created successfully........

Puede insertar un registro en una tabla existente en PostgreSQL usando el INSERT INTOdeclaración. Al ejecutar esto, debe especificar el nombre de la tabla y los valores de las columnas en ella.

Sintaxis

A continuación se muestra la sintaxis recomendada de la instrucción INSERT:

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

Donde, columna1, columna2, columna3, .. son los nombres de las columnas de una tabla, y valor1, valor2, valor3, ... son los valores que necesita insertar en la tabla.

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la declaración CREATE TABLE como se muestra a continuación:

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 siguiente declaración de PostgreSQL inserta una fila en la tabla creada anteriormente:

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

Al insertar registros usando la instrucción INSERT INTO, si omite cualquier nombre de columna, el registro se insertará dejando espacios vacíos en las columnas que ha omitido.

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

También puede insertar registros en una tabla sin especificar los nombres de las columnas, si el orden de los valores que pasa es el mismo que el de sus respectivos nombres de columna en la tabla.

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

Después de insertar los registros en una tabla, puede verificar su contenido usando la instrucción SELECT como se muestra a continuación:

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)

Insertar datos con Python

La clase de cursor de psycopg2 proporciona un método con el nombre método execute (). Este método acepta la consulta como parámetro y la ejecuta.

Por lo tanto, para insertar datos en una tabla en PostgreSQL usando python:

• Importar psycopg2 paquete.

• Cree un objeto de conexión utilizando el connect() método, pasando el nombre de usuario, la contraseña, el host (predeterminado opcional: localhost) y la base de datos (opcional) como parámetros.

• Desactive el modo de confirmación automática estableciendo falso como valor para el atributo autocommit.

• los cursor() método del ConnectionLa clase de la biblioteca psycopg2 devuelve un objeto cursor. Cree un objeto de cursor con este método.

• Luego, ejecute las declaraciones INSERT pasándolas como un parámetro al método execute ().

Ejemplo

El siguiente programa de Python crea una tabla con el nombre EMPLOYEE en la base de datos PostgreSQL e inserta registros en ella usando el 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()

Salida

Records inserted........

Puede recuperar el contenido de una tabla existente en PostgreSQL utilizando la instrucción SELECT. En esta declaración, debe especificar el nombre de la tabla y devuelve su contenido en formato tabular que se conoce como conjunto de resultados.

Sintaxis

A continuación se muestra la sintaxis de la instrucción SELECT en PostgreSQL:

SELECT column1, column2, columnN FROM table_name;

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la siguiente 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=#

Y si hemos insertado 5 registros usando instrucciones 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

La siguiente consulta SELECT recupera los valores de las columnas FIRST_NAME, LAST_NAME y COUNTRY de la tabla CRICKETERS.

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

Si desea recuperar todas las columnas de cada registro, debe reemplazar los nombres de las columnas con "⚹" como se muestra a continuación:

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 datos usando Python

READ Operar en cualquier base de datos significa obtener información útil de la base de datos. Puede obtener datos de PostgreSQL utilizando el método fetch () proporcionado por psycopg2.

La clase Cursor proporciona tres métodos, a saber, fetchall (), fetchmany () y, fetchone () donde,

• El método fetchall () recupera todas las filas del conjunto de resultados de una consulta y las devuelve como una lista de tuplas. (Si ejecutamos esto después de recuperar algunas filas, devuelve las restantes).

• El método fetchone () obtiene la siguiente fila en el resultado de una consulta y la devuelve como una tupla.

Note - Un conjunto de resultados es un objeto que se devuelve cuando se utiliza un objeto de cursor para consultar una tabla.

Ejemplo

El siguiente programa de Python se conecta a una base de datos llamada mydb de PostgreSQL y recupera todos los registros de una tabla llamada 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()

Salida

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

Mientras realiza las operaciones SELECT, UPDATE o DELETE, puede especificar la condición para filtrar los registros usando la cláusula WHERE. La operación se realizará sobre los registros que satisfagan la condición dada.

Sintaxis

A continuación se muestra la sintaxis de la cláusula WHERE en PostgreSQL:

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

Puede especificar una condición_de_búsqueda utilizando operadores lógicos o de comparación. like>, <, =, LIKE, NOT, etc. Los siguientes ejemplos aclararían este concepto.

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la siguiente 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=#

Y si hemos insertado 5 registros usando instrucciones 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

La siguiente instrucción SELECT recupera los registros cuya antigüedad es superior a 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=#

Donde la cláusula usando Python

Para obtener registros específicos de una tabla usando el programa Python, ejecute la instrucción SELECT con la cláusula WHERE , pasándola como parámetro alexecute() método.

Ejemplo

El siguiente ejemplo de Python demuestra el 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()

Salida

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

Por lo general, si intenta recuperar datos de una tabla, obtendrá los registros en el mismo orden en que los insertó.

Utilizando el ORDER BY cláusula, mientras recupera los registros de una tabla, puede ordenar los registros resultantes en orden ascendente o descendente según la columna deseada.

Sintaxis

A continuación se muestra la sintaxis de la cláusula ORDER BY en PostgreSQL.

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la siguiente 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=#

Y si hemos insertado 5 registros usando instrucciones 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

La siguiente instrucción SELECT recupera las filas de la tabla CRICKETERS en orden ascendente de su edad:

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:

Puede utilizar más de una columna para ordenar los registros de una tabla. Las siguientes instrucciones SELECT clasifican los registros de la tabla CRICKETERS según las columnas edad y NOMBRE_FIRST.

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 defecto, el ORDER BYLa cláusula ordena los registros de una tabla en orden ascendente. Puede organizar los resultados en orden descendente 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 el contenido de una tabla en un orden específico, invoque el método execute () en el objeto cursor y, pase la instrucción SELECT junto con la cláusula ORDER BY, como parámetro.

Ejemplo

En el siguiente ejemplo, estamos creando una tabla con el nombre y el Empleado, llenándola y recuperando sus registros en el orden (ascendente) de su edad, usando la 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()

Salida

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

Puede modificar el contenido de los registros existentes de una tabla en PostgreSQL utilizando la instrucción UPDATE. Para actualizar filas específicas, debe usar la cláusula WHERE junto con ella.

Sintaxis

A continuación se muestra la sintaxis de la declaración UPDATE en PostgreSQL:

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la siguiente 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=#

Y si hemos insertado 5 registros usando instrucciones 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

La siguiente declaración modifica la edad del jugador de críquet, cuyo nombre es Shikhar -

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

Si recupera el registro cuyo FIRST_NAME es Shikhar, observa que el valor de la edad se ha cambiado a 45 -

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

postgres=#

Si no ha utilizado la cláusula WHERE, se actualizarán los valores de todos los registros. La siguiente instrucción UPDATE aumenta la edad de todos los registros en la tabla CRICKETERS en 1 -

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

Si recupera el contenido de la tabla usando el comando SELECT, puede ver los valores actualizados 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)

Actualizar registros con Python

La clase de cursor de psycopg2 proporciona un método con el nombre método execute (). Este método acepta la consulta como parámetro y la ejecuta.

Por lo tanto, para insertar datos en una tabla en PostgreSQL usando python:

• Importar psycopg2 paquete.

• Cree un objeto de conexión utilizando el connect() método, pasando el nombre de usuario, la contraseña, el host (predeterminado opcional: localhost) y la base de datos (opcional) como parámetros.

• Desactive el modo de confirmación automática estableciendo falso como valor para el atributo autocommit.

• los cursor() método del ConnectionLa clase de la biblioteca psycopg2 devuelve un objeto cursor. Cree un objeto de cursor utilizando este método.

• Luego, ejecute la instrucción UPDATE pasándola como parámetro al método execute ().

Ejemplo

El siguiente código de Python actualiza el contenido de la tabla de empleados y recupera los 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()

Salida

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

Puede eliminar los registros en una tabla existente usando el DELETE FROMdeclaración de la base de datos PostgreSQL. Para eliminar registros específicos, debe usar la cláusula WHERE junto con ella.

Sintaxis

A continuación se muestra la sintaxis de la consulta DELETE en PostgreSQL:

DELETE FROM table_name [WHERE Clause]

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la siguiente 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=#

Y si hemos insertado 5 registros usando instrucciones 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

La siguiente declaración borra el registro del jugador de críquet cuyo apellido es 'Sangakkara'.

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

Si recupera el contenido de la tabla usando la instrucción SELECT, puede ver solo 4 registros ya que hemos eliminado 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)

Si ejecuta la instrucción DELETE FROM sin la cláusula WHERE, se eliminarán todos los registros de la tabla especificada.

postgres=# DELETE FROM CRICKETERS;
DELETE 4

Dado que ha eliminado todos los registros, si intenta recuperar el contenido de la tabla CRICKETERS, utilizando la instrucción SELECT obtendrá un conjunto de resultados vacío como se muestra a continuación:

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

Eliminar datos con Python

La clase de cursor de psycopg2 proporciona un método con el nombre método execute (). Este método acepta la consulta como parámetro y la ejecuta.

Por lo tanto, para insertar datos en una tabla en PostgreSQL usando python:

• Importar psycopg2 paquete.

• Cree un objeto de conexión utilizando el connect() método, pasando el nombre de usuario, la contraseña, el host (predeterminado opcional: localhost) y la base de datos (opcional) como parámetros.

• Desactive el modo de confirmación automática estableciendo falso como valor para el atributo autocommit.

• los cursor() método del ConnectionLa clase de la biblioteca psycopg2 devuelve un objeto cursor. Cree un objeto de cursor utilizando este método.

• Luego, ejecute la instrucción DELETE pasándola como parámetro al método execute ().

Ejemplo

El siguiente código de Python elimina los registros de la tabla EMPLOYEE con valores de edad superiores a 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()

Salida

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

Puede eliminar una tabla de la base de datos PostgreSQL utilizando la instrucción DROP TABLE.

Sintaxis

A continuación se muestra la sintaxis de la declaración DROP TABLE en PostgreSQL:

DROP TABLE table_name;

Ejemplo

Supongamos que hemos creado dos tablas con el nombre CRICKETERS y EMPLOYEES utilizando las siguientes 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=#

Ahora, si verifica la lista de tablas con el comando "\ dt", puede ver las tablas creadas anteriormente como:

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

La siguiente declaración elimina la tabla llamada Empleado de la base de datos:

postgres=# DROP table employee;
DROP TABLE

Como eliminó la tabla Empleado, si recupera la lista de tablas nuevamente, puede observar solo una tabla en ella.

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


postgres=#

Si intenta eliminar la tabla de empleados nuevamente, dado que ya la eliminó, obtendrá un error que dice "la tabla no existe" como se muestra a continuación:

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

Para resolver esto, puede usar la cláusula IF EXISTS junto con la instrucción DELTE. Esto elimina la tabla si existe; de ​​lo contrario, omite la operación DLETE.

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

Eliminar una tabla completa con Python

Puede eliminar una tabla siempre que lo necesite, utilizando la instrucción DROP. Pero debe tener mucho cuidado al eliminar cualquier tabla existente porque los datos perdidos no se recuperarán después de eliminar una tabla.

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

Salida

#Table dropped...

Al ejecutar una declaración SELECT de PostgreSQL, puede limitar el número de registros en su resultado utilizando la cláusula LIMIT.

Sintaxis

A continuación se muestra la sintaxis de la cláusula LMIT en PostgreSQL:

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando la siguiente 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=#

Y si hemos insertado 5 registros usando instrucciones 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

La siguiente declaración recupera los primeros 3 registros de la tabla de jugadores de cricket utilizando la 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)

Si desea obtener registros a partir de un registro en particular (desplazamiento), puede hacerlo utilizando la cláusula OFFSET junto con 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=#

Limitar cláusula usando Python

El siguiente ejemplo de Python recupera el contenido de una tabla llamada EMPLEADO, limitando el número de registros en el 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()

Salida

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

Cuando haya dividido los datos en dos tablas, puede obtener registros combinados de estas dos tablas utilizando Joins.

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS e insertamos 5 registros en ella como se muestra a continuación:

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

Y, si hemos creado otra tabla con el nombre OdiStats e insertamos 5 registros en ella 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);

La siguiente declaración recupera datos que combinan los valores en estas dos tablas:

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

Se une usando Python

Cuando haya dividido los datos en dos tablas, puede obtener registros combinados de estas dos tablas utilizando Joins.

Ejemplo

El siguiente programa de Python demuestra el uso de la 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()

Salida

[
   ('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 clase Cursor de la biblioteca psycopg proporciona métodos para ejecutar los comandos de PostgreSQL en la base de datos utilizando código Python.

Utilizando sus métodos, puede ejecutar sentencias SQL, obtener datos de los conjuntos de resultados, llamar a procedimientos.

Puedes crear Cursor objeto utilizando el método cursor () del objeto / clase Connection.

Ejemplo

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 continuación se muestran los diversos métodos proporcionados por la clase / objeto Cursor.

No Señor.	Métodos y descripción
1	callproc() Este método se utiliza para llamar a la base de datos PostgreSQL de procedimientos existentes.
2	close() Este método se utiliza para cerrar el objeto de cursor actual.
3	executemany() Este método acepta una lista de series de parámetros. Prepara una consulta MySQL y la ejecuta con todos los parámetros.
4	execute() Este método acepta una consulta MySQL como parámetro y ejecuta la consulta dada.
5	fetchall() Este método recupera todas las filas del conjunto de resultados de una consulta y las devuelve como una lista de tuplas. (Si ejecutamos esto después de recuperar algunas filas, devuelve las restantes)
6	fetchone() Este método obtiene la siguiente fila en el resultado de una consulta y la devuelve como una tupla.
7	fetchmany() Este método es similar al fetchone () pero recupera el siguiente conjunto de filas en el conjunto de resultados de una consulta, en lugar de una sola fila.

Propiedades

A continuación se muestran las propiedades de la clase Cursor:

No Señor.	Descripción de propiedad
1	description Esta es una propiedad de solo lectura que devuelve la lista que contiene la descripción de las columnas en un conjunto de resultados.
2	lastrowid Esta es una propiedad de solo lectura, si hay columnas autoincrementadas en la tabla, esto devuelve el valor generado para esa columna en la última operación INSERT o UPDATE.
3	rowcount Esto devuelve el número de filas devueltas / actualizadas en caso de operaciones SELECT y UPDATE.
4	closed Esta propiedad especifica si un cursor está cerrado o no, si es así, devuelve verdadero o falso.
5	connection Esto devuelve una referencia al objeto de conexión con el que se creó este cursor.
6	name Esta propiedad devuelve el nombre del cursor.
7	scrollable Esta propiedad especifica si un cursor en particular se puede desplazar.