Acceso a datos de Python - Guía rápida

El estándar de Python para interfaces de bases de datos es Python DB-API. La mayoría de las interfaces de bases de datos de Python se adhieren a este estándar.

Puede elegir la base de datos adecuada para su aplicación. La API de base de datos de Python admite una amplia gama de servidores de bases de datos, como:

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

Aquí está la lista de interfaces de base de datos de Python disponibles: Interfaces y API de base de datos de Python . Debe descargar un módulo DB API por separado para cada base de datos a la que necesite acceder. Por ejemplo, si necesita acceder a una base de datos Oracle y una base de datos MySQL, debe descargar los módulos de base de datos Oracle y MySQL.

¿Qué es mysql-connector-python?

MySQL Python / Connector es una interfaz para conectarse a un servidor de base de datos MySQL desde Python. Implementa la API de base de datos de Python y está construido sobre MySQL.

¿Cómo instalo mysql-connector-python?

En primer lugar, debe asegurarse de haber instalado Python en su máquina. Para hacerlo, abra el símbolo del sistema y escriba python en él y presione Entrar. Si Python ya está instalado en su sistema, este comando mostrará su versión como se muestra a continuación:

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

Ahora presione ctrl + zy luego Enter para salir del shell de Python y crear una carpeta (en la que pretendía instalar el conector Python-MySQL) llamada Python_MySQL como -

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

Verificar PIP

PIP es un administrador de paquetes en Python mediante el cual puede instalar varios módulos / paquetes en Python. Por lo tanto, para instalar Mysql-python mysql-connector-python, debe asegurarse de tener PIP instalado en su computadora y que su ubicación se agregue a la ruta.

Puede hacerlo ejecutando el comando pip. Si no tenía PIP en su sistema o, si no ha agregado su ubicación en elPath variable de entorno, obtendrá un mensaje de error como -

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

Para instalar PIP, descargue get-pip.py en la carpeta creada anteriormente y, desde el comando, navegue e instale pip de la siguiente manera:

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

Instalación de mysql-connector-python

Una vez que haya instalado Python y PIP, abra el símbolo del sistema y actualice pip (opcional) como se muestra a continuación:

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

Luego abra el símbolo del sistema en modo de administrador e instale python MySQL connect como -

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

Verificación

Para verificar la instalación, cree un script de muestra de Python 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_MySQL>python test.py
D:\Python_MySQL>

Instalando Python desde cero

Simplemente, si necesita instalar Python desde cero. Visite la página de inicio de Python .

Clickea en el Downloads , será redirigido a la página de descargas que proporciona enlaces para la última versión de Python para varias plataformas, elija una y descárguela.

Por ejemplo, hemos descargado python-3.7.4.exe (para Windows). Inicie el proceso de instalación haciendo doble clic en el archivo .exe descargado .

Marque la opción Agregar Python 3.7 a la ruta y continúe con la instalación. Después de completar este proceso, Python se instalará en su sistema.

Para conectarse con MySQL, (una forma es) abrir el símbolo del sistema de MySQL en su sistema como se muestra a continuación:

Aquí pide contraseña; debe escribir la contraseña que ha establecido para el usuario predeterminado (root) en el momento de la instalación.

Luego se establece una conexión con MySQL que muestra el siguiente mensaje:

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

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

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

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

Puede desconectarse de la base de datos MySQL en cualquier momento usando el comando exit en el indicador mysql>.

mysql> exit
Bye

Estableciendo conexión con MySQL usando python

Antes de establecer una conexión a la base de datos MySQL usando python, asuma -

• Que hemos creado una base de datos con el nombre mydb.

• Hemos creado una tabla EMPLEADO con columnas PRIMER NOMBRE, APELLIDO, EDAD, SEXO e INGRESOS.

• Las credenciales que estamos usando para conectarnos con MySQL son nombre de usuario: root, contraseña: password.

Puede establecer una conexión utilizando el connect()constructor. Esto acepta nombre de usuario, contraseña, host y el nombre de la base de datos con la que necesita conectarse (opcional) y devuelve un objeto de la clase MySQLConnection.

Ejemplo

A continuación se muestra el ejemplo de conexión con la base de datos MySQL "mydb".

import mysql.connector

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

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

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

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

#Closing the connection
conn.close()

Salida

Al ejecutarse, este script produce la siguiente salida:

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

También puede establecer una conexión con MySQL pasando credenciales (nombre de usuario, contraseña, nombre de host y nombre de la base de datos) a connection.MySQLConnection() como se muestra a continuación -

from mysql.connector import (connection)

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

#Closing the connection
conn.close()

Puede crear una base de datos en MYSQL utilizando la consulta CREATE DATABASE.

Sintaxis

A continuación se muestra la sintaxis de la consulta CREATE DATABASE:

CREATE DATABASE name_of_the_database

Ejemplo

La siguiente declaración crea una base de datos con el nombre mydb en MySQL:

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

Si observa la lista de bases de datos utilizando la instrucción SHOW DATABASES, puede observar la base de datos recién creada en ella como se muestra a continuación:

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

Creando una base de datos en MySQL usando python

Después de establecer la conexión con MySQL, para manipular los datos en él, debe conectarse a una base de datos. Puede conectarse a una base de datos existente o crear la suya propia.

Necesitaría privilegios especiales para crear o eliminar una base de datos MySQL. Entonces, si tiene acceso al usuario raíz, puede crear cualquier base de datos.

Ejemplo

El siguiente ejemplo establece una conexión con MYSQL y crea una base de datos en él.

import mysql.connector

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

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

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

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

#Creating a database
cursor.execute(sql)

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

#Closing the connection
conn.close()

Salida

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

La declaración CREATE TABLE se utiliza para crear tablas en la base de datos MYSQL. Aquí, debe especificar el nombre de la tabla y la definición (nombre y tipo de datos) de cada columna.

Sintaxis

A continuación se muestra la sintaxis para crear una tabla en MySQL:

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

Ejemplo

La siguiente consulta crea una tabla llamada EMPLEADO en MySQL con cinco columnas, a saber, PRIMER NOMBRE, ÚLTIMO NOMBRE, EDAD, SEXO e INGRESOS.

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

La declaración DESC le da la descripción de la tabla especificada. Con esto, puede verificar si la tabla se ha creado o no como se muestra a continuación:

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

Creando una tabla en MySQL usando python

El método llamado execute() (invocado en el objeto cursor) acepta dos variables -

• Un valor de cadena que representa la consulta que se ejecutará.

• Un parámetro opcional de args que puede ser una tupla o una lista o un diccionario, que representa los parámetros de la consulta (valores de los marcadores de posición).

Devuelve un valor entero que representa el número de filas efectuadas por la consulta.

Una vez que se establece una conexión a la base de datos, puede crear tablas pasando la consulta CREATE TABLE al execute() método.

En resumen, para crear una tabla usando python 7minus;

• Importar mysql.connector paquete.

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

• Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.

• Luego, ejecute la instrucción CREATE TABLE pasándola como parámetro alexecute() método.

Ejemplo

El siguiente ejemplo crea una tabla llamada Employee en la base de datos mydb.

import mysql.connector

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

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

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

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

#Closing the connection
conn.close()

Puede agregar nuevas filas a una tabla existente de MySQL usando el INSERT INTOdeclaración. En esto, debe especificar el nombre de la tabla, los nombres de las columnas y los valores (en el mismo orden que los nombres de las columnas).

Sintaxis

A continuación se muestra la sintaxis de la instrucción INSERT INTO de MySQL.

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

Ejemplo

La siguiente consulta inserta un registro en la tabla llamado EMPLEADO.

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

Puede verificar los registros de la tabla después de la operación de inserción usando la instrucción SELECT como:

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

No es obligatorio especificar los nombres de las columnas siempre, si pasa valores de un registro en el mismo orden de las columnas de la tabla, puede ejecutar la instrucción SELECT sin los nombres de columna de la siguiente manera:

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

Insertar datos en una tabla MySQL usando Python

los execute()método (invocado en el objeto cursor) acepta una consulta como parámetro y ejecuta la consulta dada. Para insertar datos, debe pasarle la instrucción INSERT de MySQL como parámetro.

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

Para insertar datos en una tabla en MySQL usando python:

• importar mysql.connector paquete.

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

• Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente

• Luego, ejecute el INSERT declaración pasándola como parámetro a la execute() método.

Ejemplo

El siguiente ejemplo ejecuta la instrucción SQL INSERT para insertar un registro en la tabla EMPLOYEE:

import mysql.connector

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

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

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

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

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

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

# Closing the connection
conn.close()

Insertar valores dinámicamente

También puede utilizar "% s" en lugar de valores en el INSERT consulta de MySQL y pasarles valores como listas como se muestra a continuación -

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

Ejemplo

El siguiente ejemplo inserta un registro en la tabla Empleado de forma dinámica.

import mysql.connector

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

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

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

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

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

print("Data inserted")

# Closing the connection
conn.close()

Salida

Data inserted

Puede recuperar / buscar datos de una tabla en MySQL usando la consulta SELECT. Esta consulta / declaración devuelve el contenido de la tabla especificada en forma tabular y se llama como conjunto de resultados.

Sintaxis

A continuación se muestra la sintaxis de la consulta SELECT:

SELECT column1, column2, columnN FROM table_name;

Ejemplo

Supongamos que hemos creado una tabla en MySQL con el nombre cricketers_data como -

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

La siguiente consulta recupera los valores de FIRST_NAME y Country de la tabla.

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

También puede recuperar todos los valores de cada registro usando * instalados del nombre de las columnas como -

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

Leer datos de una tabla MYSQL usando Python

READ Operar en cualquier base de datos significa obtener información útil de la base de datos. Puede recuperar datos de MYSQL utilizando elfetch() método proporcionado por mysql-connector-python.

La clase cursor.MySQLCursor proporciona tres métodos:fetchall(), fetchmany() y, fetchone() dónde,

• los fetchall()El 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).

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

• los fetchmany() El 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.

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

rowcount - Este es un atributo de solo lectura y devuelve el número de filas que fueron afectadas por un método execute ().

Ejemplo

El siguiente ejemplo recupera todas las filas de la tabla EMPLOYEE usando la consulta SELECT y del conjunto de resultados obtenido inicialmente, estamos recuperando la primera fila usando el método fetchone () y luego recuperando las filas restantes usando el método fetchall ().

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

Salida

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

El siguiente ejemplo recupera las dos primeras filas de la tabla EMPLOYEE utilizando el método fetchmany ().

Ejemplo

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Salida

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

Si desea obtener, eliminar o actualizar filas particulares de una tabla en MySQL, debe usar la cláusula where para especificar la condición para filtrar las filas de la tabla para la operación.

Por ejemplo, si tiene una instrucción SELECT con la cláusula where, solo se recuperarán las filas que satisfagan la condición especificada.

Sintaxis

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

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

Ejemplo

Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -

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

Y si hemos insertado 4 registros usando instrucciones INSERT como:

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

La siguiente declaración de MySQL recupera los registros de los empleados cuyos ingresos son superiores a 4000.

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

DONDE cláusula usando python

Para obtener registros específicos de una tabla usando el programa Python:

• importar mysql.connector paquete.

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

• Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.

• Luego, ejecute la instrucción SELECT con la cláusula WHERE , pasándola como parámetro alexecute() método.

Ejemplo

El siguiente ejemplo crea una tabla llamada Empleado y la llena. Luego, utilizando la cláusula where, recupera los registros con un valor de edad inferior a 23.

import mysql.connector

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

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

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

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

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

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

#Closing the connection
conn.close()

Salida

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

Mientras obtiene datos mediante la consulta SELECT, puede ordenar los resultados en el orden deseado (ascendente o descendente) mediante la cláusula OrderBy. De forma predeterminada, esta cláusula ordena los resultados en orden ascendente; si necesita organizarlos en orden descendente, debe utilizar "DESC" explícitamente.

Sintaxis

A continuación se muestra la lista de columnas SELECT de sintaxis

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

Ejemplo

Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -

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

Y si hemos insertado 4 registros usando instrucciones INSERT como:

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

La siguiente instrucción recupera el contenido de la tabla EMPLOYEE en orden ascendente de edad.

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

También puede recuperar datos en orden descendente usando DESC como:

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

Cláusula ORDER BY usando Python

Para recuperar el contenido de una tabla en un orden específico, invoque el execute() en el objeto cursor y pasar 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, la rellenamos y recuperamos sus registros en el orden (ascendente) de su antigüedad, utilizando la cláusula ORDER BY.

import mysql.connector

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

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

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

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

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

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

#Closing the connection
conn.close()

Salida

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

De la misma manera, puede recuperar datos de una tabla en orden descendente utilizando la cláusula ORDER BY.

Ejemplo

import mysql.connector

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

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

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

#Closing the connection
conn.close()

Salida

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

ACTUALIZAR La operación en cualquier base de datos actualiza uno o más registros, que ya están disponibles en la base de datos. Puede actualizar los valores de los registros existentes en MySQL usando 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 MySQL:

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

Puede combinar N número de condiciones utilizando los operadores AND u OR.

Ejemplo

Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -

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

Y si hemos insertado 4 registros usando instrucciones INSERT como:

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

Seguir la declaración de MySQL aumenta la edad de todos los empleados masculinos en un año:

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

Si recupera el contenido de la tabla, puede ver los valores actualizados como:

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

Actualizar el contenido de una tabla usando Python

Para actualizar los registros en una tabla en MySQL usando python:

• importar mysql.connector paquete.

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

• Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.

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

Ejemplo

El siguiente ejemplo aumenta la edad de todos los hombres en un año.

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Salida

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

Para eliminar registros de una tabla MySQL, debe usar el DELETE FROMdeclaración. 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 MYSQL:

DELETE FROM table_name [WHERE Clause]

Ejemplo

Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -

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

Y si hemos insertado 4 registros usando instrucciones INSERT como:

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

La siguiente declaración de MySQL borra el registro del empleado con FIRST_NAME ”Mac”.

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

Si recupera el contenido de la tabla, puede ver solo 3 registros ya que hemos eliminado uno.

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

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

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

Si recupera el contenido de la tabla, obtendrá un conjunto vacío como se muestra a continuación:

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

Eliminar registros de una tabla usando Python

La operación DELETE es necesaria cuando desea eliminar algunos registros de su base de datos.

Para eliminar los registros en una tabla:

• importar mysql.connector paquete.

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

• Cree un objeto de cursor invocando el cursor() método en el objeto de conexión creado anteriormente.

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

Ejemplo

El siguiente programa borra todos los registros del EMPLEADO cuya EDAD es mayor de 20 -

import mysql.connector

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

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

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

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

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

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

#Closing the connection
conn.close()

Salida

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

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

Puede eliminar una tabla completa utilizando el DROP TABLEdeclaración. Solo necesita especificar el nombre de la tabla que necesita eliminar.

Sintaxis

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

DROP TABLE table_name;

Ejemplo

Antes de eliminar una tabla, obtenga la lista de tablas utilizando la instrucción SHOW TABLES de la siguiente manera:

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

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

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

Dado que hemos eliminado la tabla llamada muestra de MySQL, si vuelve a obtener la lista de tablas, no encontrará la muestra del nombre de la tabla en ella.

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

Eliminar una tabla usando Python

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

Para eliminar una tabla de una base de datos MYSQL usando python, invoque el execute() en el objeto cursor y pasarle la sentencia drop como parámetro.

Ejemplo

La siguiente tabla quita una tabla llamada EMPLEADO de la base de datos.

import mysql.connector

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

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

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

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

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

#Closing the connection conn.close()

Salida

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

Drop table solo si existe

Si intenta eliminar una tabla que no existe en la base de datos, se produce un error como:

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

Puede evitar este error verificando si la tabla existe antes de eliminarla, agregando IF EXISTS a la instrucción DELETE.

import mysql.connector

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

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

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

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

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

#Closing the connection
conn.close()

Salida

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

Al buscar registros si desea limitarlos a un número en particular, puede hacerlo utilizando la cláusula LIMIT de MYSQL.

Ejemplo

Supongamos que hemos creado una tabla en MySQL con el nombre EMPLOYEES como -

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

Y si hemos insertado 4 registros usando instrucciones INSERT como:

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

La siguiente instrucción SQL recupera los dos primeros registros de la tabla Empleado utilizando la cláusula LIMIT.

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

Limitar cláusula usando python

Si invoca el execute() en el objeto cursor al pasar la consulta SELECT junto con la cláusula LIMIT, puede recuperar el número requerido de registros.

Para eliminar una tabla de una base de datos MYSQL usando python, invoque el execute() en el objeto cursor y pasarle la sentencia drop como parámetro.

Ejemplo

El siguiente ejemplo de Python crea y llena una tabla con el nombre EMPLOYEE y, usando la cláusula LIMIT, obtiene los dos primeros registros de la misma.

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Salida

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

LIMIT con OFFSET

Si es necesario limitar los registros a partir de registro enésima (no 1 ^st ), puede hacerlo, uso de desplazamiento a lo largo del fin de carrera.

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Salida

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

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre EMPLEADO y los datos introducidos en ella como se muestra a continuación:

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

Entonces, si hemos creado otra tabla y la hemos llenado como -

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

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

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

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

MYSQL JOIN usando Python

El siguiente ejemplo recupera datos de las dos tablas anteriores combinadas por la columna de contacto de la tabla EMPLEADO y la columna ID de la tabla CONTACTO.

import mysql.connector

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

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

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

#Executing the query
cursor.execute(sql)

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

#Closing the connection
conn.close()

Salida

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

El MySQLCursor de mysql-connector-python (y bibliotecas similares) se usa para ejecutar declaraciones para comunicarse con la base de datos MySQL.

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 mysql.connector

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

Métodos

A continuación se muestran los diversos métodos proporcionados por la clase / objeto Cursor.

No Señor	Método y descripción
1	callproc() Este método se utiliza para llamar a la base de datos MySQL de procedimientos existentes.
2	close() Este método se utiliza para cerrar el objeto de cursor actual.
3	Info() Este método proporciona información sobre la última consulta.
4	executemany() Este método acepta una lista de series de parámetros. Prepara una consulta MySQL y la ejecuta con todos los parámetros.
5	execute() Este método acepta una consulta MySQL como parámetro y ejecuta la consulta dada.
6	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)
7	fetchone() Este método obtiene la siguiente fila en el resultado de una consulta y la devuelve como una tupla.
8	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.
9	etchwarnings() Este método devuelve las advertencias generadas por la última consulta ejecutada.

Propiedades

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

No Señor	Descripción de propiedad
1	column_names Esta es una propiedad de solo lectura que devuelve la lista que contiene los nombres de columna de un conjunto de resultados.
2	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.
3	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.
4	rowcount Esto devuelve el número de filas devueltas / actualizadas en caso de operaciones SELECT y UPDATE.
5	statement Esta propiedad devuelve la última sentencia ejecutada.

Instalación

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 ganado una sólida reputación por su confiabilidad, integridad de datos y corrección.

Para comunicarse con PostgreSQL usando Python, necesita instalar psycopg, un adaptador proporcionado para la programación de Python, la versión actual de esto 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 utilizando 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 instrucció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 employee.

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 que contiene.

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 los nombres de las columnas, 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 utilizando 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 usando 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, contraseña, host (predeterminado opcional: localhost) y 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 las declaraciones INSERT pasándolas como 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 utilizando 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 () busca la siguiente fila en el resultado de una consulta y la devuelve como una tupla.

• El método fetchmany () 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.

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 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 utilizando 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 utilizando 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 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 a la execute() 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 utilizando 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 ordenan 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 utilizando 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 usando 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, contraseña, host (predeterminado opcional: localhost) y 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 utilizando 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 utilizando 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 usando 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, contraseña, host (predeterminado opcional: localhost) y 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()El método de la clase Connection 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 elimina 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 usando 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 instrucció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 utilizando 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 críquet usando 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 EMPLOYEE, limitando el número de registros en el resultado a 2 -

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

#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 Combinaciones.

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 Combinaciones.

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étodo 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	astrowid 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, de lo contrario 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 se puede desplazar un cursor en particular.

Instalación

SQLite3 se puede integrar con Python usando el módulo sqlite3, que fue escrito por Gerhard Haring. Proporciona una interfaz SQL compatible con la especificación DB-API 2.0 descrita por PEP 249. No es necesario instalar este módulo por separado porque se envía de forma predeterminada junto con la versión 2.5.x de Python en adelante.

Para usar el módulo sqlite3, primero debe crear un objeto de conexión que represente la base de datos y luego, opcionalmente, puede crear un objeto de cursor, que lo ayudará a ejecutar todas las declaraciones SQL.

API del módulo Python sqlite3

Las siguientes son rutinas importantes del módulo sqlite3, que pueden ser suficientes para su requisito de trabajar con la base de datos SQLite desde su programa Python. Si está buscando una aplicación más sofisticada, puede consultar la documentación oficial del módulo Python sqlite3.

No Señor.	API y descripción
1	sqlite3.connect(database [,timeout ,other optional arguments]) Esta API abre una conexión al archivo de base de datos SQLite. Puede utilizar ": memory:" para abrir una conexión de base de datos a una base de datos que reside en la RAM en lugar de en el disco. Si la base de datos se abre correctamente, devuelve un objeto de conexión.
2	connection.cursor([cursorClass]) Esta rutina crea una cursorque se utilizará en toda la programación de su base de datos con Python. Este método acepta un único parámetro opcional cursorClass. Si se proporciona, debe ser una clase de cursor personalizada que amplíe sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Esta rutina ejecuta una instrucción SQL. La instrucción SQL puede parametrizarse (es decir, marcadores de posición en lugar de literales SQL). El módulo sqlite3 admite dos tipos de marcadores de posición: signos de interrogación y marcadores de posición con nombre (estilo con nombre). For example - cursor.execute ("insertar en las personas valores (?,?)", (Quién, edad))
4	connection.execute(sql [, optional parameters]) Esta rutina es un atajo del método de ejecución anterior proporcionado por el objeto cursor y crea un objeto cursor intermedio llamando al método del cursor, luego llama al método de ejecución del cursor con los parámetros dados.
5	cursor.executemany(sql, seq_of_parameters) Esta rutina ejecuta un comando SQL contra todas las secuencias de parámetros o asignaciones que se encuentran en la secuencia sql.
6	connection.executemany(sql[, parameters]) Esta rutina es un atajo que crea un objeto de cursor intermedio llamando al método cursor, luego llama al método cursor.s executemany con los parámetros dados.
7	cursor.executescript(sql_script) Esta rutina ejecuta varias sentencias SQL a la vez proporcionadas en forma de script. Primero emite una declaración COMMIT, luego ejecuta el script SQL que obtiene como parámetro. Todas las sentencias SQL deben estar separadas por punto y coma (;).
8	connection.executescript(sql_script) Esta rutina es un atajo que crea un objeto de cursor intermedio llamando al método del cursor, luego llama al método de ejecución del cursor con los parámetros dados.
9	connection.total_changes() Esta rutina devuelve el número total de filas de la base de datos que se han modificado, insertado o eliminado desde que se abrió la conexión a la base de datos.
10	connection.commit() Este método confirma la transacción actual. Si no llama a este método, cualquier cosa que haya hecho desde la última llamada a commit () no es visible desde otras conexiones de base de datos.
11	connection.rollback() Este método revierte cualquier cambio en la base de datos desde la última llamada a commit ().
12	connection.close() Este método cierra la conexión a la base de datos. Tenga en cuenta que esto no llama automáticamente a commit (). Si cierra la conexión de su base de datos sin llamar a commit () primero, ¡sus cambios se perderán!
13	cursor.fetchone() Este método obtiene la siguiente fila de un conjunto de resultados de consulta y devuelve una sola secuencia, o None cuando no hay más datos disponibles.
14	cursor.fetchmany([size = cursor.arraysize]) Esta rutina recupera el siguiente conjunto de filas del resultado de una consulta y devuelve una lista. Se devuelve una lista vacía cuando no hay más filas disponibles. El método intenta obtener tantas filas como indique el parámetro de tamaño.
15	cursor.fetchall() Esta rutina recupera todas las filas (restantes) del resultado de una consulta y devuelve una lista. Se devuelve una lista vacía cuando no hay filas disponibles.

Para establecer conexión con el símbolo del sistema SQLite Open, navegue a través de la ubicación donde instaló SQLite y simplemente ejecute el comando sqlite3 como se muestra a continuación -

Estableciendo conexión usando Python

Puede comunicarse con la base de datos SQLite2 utilizando el módulo de Python SQLite3. Para hacerlo, primero debe establecer una conexión (crear un objeto de conexión).

Para establecer una conexión con la base de datos SQLite3 usando python, necesita:

• Importe el módulo sqlite3 utilizando la declaración de importación.

• El método connect () acepta el nombre de la base de datos con la que necesita conectarse como parámetro y devuelve un objeto Connection.

Ejemplo

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

Salida

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

Con la declaración SQLite CREATE TABLE puede crear una tabla en una base de datos.

Sintaxis

A continuación se muestra la sintaxis para crear una tabla en la base de datos SQLite:

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

Ejemplo

La siguiente consulta / declaración de SQLite crea una tabla con el nombre CRICKETERS en la base de datos SQLite -

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

Creemos una tabla más de OdiStats que describa las estadísticas de cricket de un día de cada jugador en la tabla CRICKETERS.

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

Puede obtener la lista de tablas en una base de datos en la base de datos SQLite usando el .tablesmando. Después de crear una tabla, si puede verificar la lista de tablas, puede observar la tabla recién creada en ella como:

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Creando una tabla usando Python

El objeto Cursor contiene todos los métodos para ejecutar consultas y recuperar datos, etc. El método de cursor de la clase de conexión devuelve un objeto de cursor.

Por lo tanto, para crear una tabla en la base de datos SQLite usando python:

• Establezca una conexión con una base de datos utilizando el método connect ().

• Cree un objeto de cursor invocando el método cursor () en el objeto de conexión creado anteriormente.

• Ahora ejecute la instrucción CREATE TABLE usando el método execute () de la clase Cursor.

Ejemplo

El siguiente programa de Python crea una tabla llamada Empleado en SQLite3 -

import sqlite3

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

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

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

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

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

#Closing the connection
conn.close()

Salida

Table created successfully........

Puede agregar nuevas filas a una tabla existente de SQLite usando la instrucción INSERT INTO. En esto, debe especificar el nombre de la tabla, los nombres de las columnas y los valores (en el mismo orden que los nombres de las columnas).

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:

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

La siguiente declaración de PostgreSQL inserta una fila en la tabla creada anteriormente.

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

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

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

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.

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

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

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

Insertar datos usando Python

Para agregar registros a una tabla existente en la base de datos SQLite:

• Importar paquete sqlite3.

• Cree un objeto de conexión utilizando el método connect () pasando el nombre de la base de datos como parámetro.

• los cursor()El método devuelve un objeto cursor con el que puede comunicarse con SQLite3. Cree un objeto cursor invocando el objeto cursor () en el objeto Connection (creado anteriormente).

• Luego, invoque el método execute () en el objeto cursor, pasándole una instrucción INSERT como parámetro.

Ejemplo

El siguiente ejemplo de Python inserta registros en una tabla llamada EMPLEADO -

import sqlite3

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

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

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

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

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

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

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

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

# Closing the connection
conn.close()

Salida

Records inserted........

Puede recuperar datos de una tabla SQLite mediante la consulta SELCT. Esta consulta / declaración devuelve el contenido de la relación (tabla) especificada en forma tabular y se llama como conjunto de resultados.

Sintaxis

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

SELECT column1, column2, columnN FROM table_name;

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS utilizando la siguiente consulta:

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

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

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

Como observa, la instrucción SELECT de la base de datos SQLite simplemente devuelve los registros de las tablas especificadas. Para obtener una salida formateada, debe configurar elheadery mode usando los comandos respectivos antes de la instrucción SELECT como se muestra a continuación -

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

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

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

En SQLite, por defecto, el ancho de las columnas es 10 valores más allá de este ancho se cortan (observe la columna de país de la ^2ª fila en la tabla anterior). Puede establecer el ancho de cada columna al valor requerido usando el.width comando, antes de recuperar el contenido de una tabla como se muestra a continuación:

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

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 MYSQL utilizando el método fetch () proporcionado por el módulo python de sqlite.

La clase sqlite3.Cursor proporciona tres métodos: 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 () busca la siguiente fila en el resultado de una consulta y la devuelve como una tupla.

• El método fetchmany () 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.

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 ejemplo recupera todas las filas de la tabla EMPLOYEE usando la consulta SELECT y del conjunto de resultados obtenido inicialmente, estamos recuperando la primera fila usando el método fetchone () y luego recuperando las filas restantes usando el método fetchall ().

El siguiente programa de Python muestra cómo buscar y mostrar registros de la tabla EMPRESA creada en el ejemplo anterior.

import sqlite3

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

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

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

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

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

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

#Closing the connection
conn.close()

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

Si desea obtener, eliminar o actualizar filas particulares de una tabla en SQLite, debe usar la cláusula where para especificar la condición para filtrar las filas de la tabla para la operación.

Por ejemplo, si tiene una instrucción SELECT con la cláusula where, solo se recuperarán las filas que satisfagan la condición especificada.

Sintaxis

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

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 utilizando la siguiente consulta:

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

La siguiente instrucción SELECT recupera los registros cuya antigüedad es superior a 35:

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

Donde cláusula usando python

El objeto / clase Cursor contiene todos los métodos para ejecutar consultas y obtener datos, etc. El método de cursor de la clase de conexión devuelve un objeto de cursor.

Por lo tanto, para crear una tabla en la base de datos SQLite usando python:

• Establezca una conexión con una base de datos utilizando el método connect ().

• Cree un objeto de cursor invocando el método cursor () en el objeto de conexión creado anteriormente.

• Ahora ejecute la instrucción CREATE TABLE usando el método execute () de la clase Cursor.

Ejemplo

El siguiente ejemplo crea una tabla llamada Empleado y la llena. Luego, utilizando la cláusula where, recupera los registros con un valor de edad inferior a 23.

import sqlite3

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

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

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

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

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

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

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

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

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

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

#Closing the connection
conn.close()

Salida

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

Mientras obtiene datos mediante la consulta SELECT, obtendrá los registros en el mismo orden en que los insertó.

Puede ordenar los resultados en el orden deseado (ascendente o descendente) utilizando el Order Bycláusula. De forma predeterminada, esta cláusula ordena los resultados en orden ascendente; si necesita organizarlos en orden descendente, debe utilizar "DESC" explícitamente.

Sintaxis

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

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 utilizando la siguiente consulta:

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

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

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

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 AGE y FIRST_NAME .

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

Por defecto, el ORDER BY cláusula ordena los registros de una tabla en orden ascendente, puede organizar los resultados en orden descendente usando DESC como -

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

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, la rellenamos y recuperamos sus registros en el orden (ascendente) de su antigüedad, utilizando 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
#Populating the table
cursor.execute('''INSERT INTO EMPLOYEE
   (FIRST_NAME, LAST_NAME, AGE, SEX, INCOME) VALUES 
   ('Ramya', 'Rama priya', 27, 'F', 9000),
   ('Vinay', 'Battacharya', 20, 'M', 6000), 
   ('Sharukh', 'Sheik', 25, 'M', 8300), 
   ('Sarmista', 'Sharma', 26, 'F', 10000),
   ('Tripthi', 'Mishra', 24, 'F', 6000)''')
conn.commit()

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

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

#Closing the connection
conn.close()

Salida

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

ACTUALIZAR La operación en cualquier base de datos implica modificar los valores de uno o más registros de una tabla, que ya están disponibles en la base de datos. Puede actualizar los valores de los registros existentes en SQLite usando 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 SQLite:

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS utilizando la siguiente consulta:

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

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

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

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

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

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 -

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

Si recupera el contenido de la tabla usando el comando SELECT, puede ver los valores actualizados como -

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

Actualizar registros existentes usando Python

Para agregar registros a una tabla existente en la base de datos SQLite:

• Importar paquete sqlite3.

• Cree un objeto de conexión utilizando el método connect () pasando el nombre de la base de datos como parámetro.

• los cursor()El método devuelve un objeto cursor con el que puede comunicarse con SQLite3. Cree un objeto cursor invocando el objeto cursor () en el objeto Connection (creado anteriormente).

• Luego, invoque el método execute () en el objeto cursor, pasándole una instrucción UPDATE como parámetro.

Ejemplo

Siguiendo el ejemplo de Python, crea una tabla con el nombre EMPLEADO, inserta 5 registros en ella y aumenta la edad de todos los empleados varones en 1 -

import sqlite3

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

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

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

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

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

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

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

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

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

#Closing the connection
conn.close()

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), 
   ('Vinay', 'Battacharya', 21, 'M', 6000.0), 
   ('Sharukh', 'Sheik', 26, 'M', 8300.0), 
   ('Sarmista', 'Sharma', 26, 'F', 10000.0), 
   ('Tripthi', 'Mishra', 24, 'F', 6000.0)]

Para eliminar registros de una tabla SQLite, debe usar la instrucción DELETE FROM. Para eliminar registros específicos, debe usar la cláusula WHERE junto con ella.

Para actualizar filas específicas, debe usar la cláusula WHERE junto con ella.

Sintaxis

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

DELETE FROM table_name [WHERE Clause]

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS utilizando la siguiente consulta:

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

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

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

Si recupera el contenido de la tabla usando la instrucción SELECT, puede ver solo 4 registros ya que hemos eliminado uno.

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

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

sqlite> DELETE FROM CRICKETERS;
sqlite>

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:

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Eliminar datos usando Python

Para agregar registros a una tabla existente en la base de datos SQLite:

• Importar paquete sqlite3.

• Cree un objeto de conexión utilizando el método connect () pasando el nombre de la base de datos como parámetro.

• los cursor()El método devuelve un objeto cursor con el que puede comunicarse con SQLite3. Cree un objeto cursor invocando el objeto cursor () en el objeto Connection (creado anteriormente).

• Luego, invoque el método execute () en el objeto cursor, pasándole una instrucción DELETE como parámetro.

Ejemplo

El siguiente ejemplo de Python elimina los registros de la tabla EMPLOYEE con un valor de edad superior a 25.

import sqlite3

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

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

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

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

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

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

#Closing the connection
conn.close()

Salida

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

Puede eliminar una tabla completa utilizando la instrucción DROP TABLE. Solo necesita especificar el nombre de la tabla que necesita eliminar.

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:

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

Ahora, si verifica la lista de tablas usando el .tables comando, puede ver las tablas creadas anteriormente en él (lista) como -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

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

sqlite> DROP table employee;
sqlite>

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

sqlite> .tables
CRICKETERS
sqlite>

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

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

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.

sqlite> DROP table IF EXISTS employee;
sqlite>

Soltar una tabla usando Python

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

Ejemplo

Para eliminar una tabla de una base de datos SQLite3 usando python, invoque el execute() en el objeto cursor y pasarle la sentencia drop como parámetro.

import sqlite3

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

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

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

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

#Closing the connection
conn.close()

Salida

Table dropped...

Mientras busca registros si desea limitarlos a un número en particular, puede hacerlo utilizando la cláusula LIMIT de SQLite.

Sintaxis

A continuación se muestra la sintaxis de la cláusula LIMIT en SQLite:

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS utilizando la siguiente consulta:

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

Y si hemos insertado 5 registros usando instrucciones INSERT como:

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

La siguiente declaración recupera los primeros 3 registros de la tabla de jugadores de críquet usando la cláusula LIMIT:

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

Si necesita limitar los registros comenzando desde el n-ésimo registro (no el primero), puede hacerlo usando OFFSET junto con LIMIT.

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

Cláusula LIMIT usando Python

Si invoca el método execute () en el objeto cursor pasando la consulta SELECT junto con la cláusula LIMIT, puede recuperar el número requerido de registros.

Ejemplo

El siguiente ejemplo de Python recupera los dos primeros registros de la tabla EMPLOYEE usando la cláusula LIMIT.

import sqlite3

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

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

Salida

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

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

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS utilizando la siguiente consulta:

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

Creemos una tabla más de OdiStats que describa las estadísticas de cricket de un día de cada jugador en la tabla CRICKETERS.

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

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

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

Unirse a la cláusula usando Python

Siguiendo el ejemplo de SQLite, demuestra la cláusula JOIN usando python -

import sqlite3

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

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

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

#Executing the query
cursor.execute(sql)

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

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

#Closing the connection
conn.close()

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 sqlite3.Cursor es una instancia mediante la cual puede invocar métodos que ejecutan declaraciones SQLite, obtener datos de los conjuntos de resultados de las consultas. Puedes crearCursor objeto utilizando el método cursor () del objeto / clase Connection.

Ejemplo

import sqlite3

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

#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étodo y descripción
1	execute() Esta rutina ejecuta una instrucción SQL. La instrucción SQL puede parametrizarse (es decir, marcadores de posición en lugar de literales SQL). El módulo psycopg2 admite marcadores de posición con el signo% s Por ejemplo: cursor.execute ("insertar en personas valores (% s,% s)", (quién, edad))
2	executemany() Esta rutina ejecuta un comando SQL contra todas las secuencias de parámetros o asignaciones que se encuentran en la secuencia sql.
3	fetchone() Este método obtiene la siguiente fila de un conjunto de resultados de consulta y devuelve una sola secuencia, o None cuando no hay más datos disponibles.
4	fetchmany() Esta rutina recupera el siguiente conjunto de filas del resultado de una consulta y devuelve una lista. Se devuelve una lista vacía cuando no hay más filas disponibles. El método intenta obtener tantas filas como indique el parámetro de tamaño.
5	fetchall() Esta rutina recupera todas las filas (restantes) del resultado de una consulta y devuelve una lista. Se devuelve una lista vacía cuando no hay filas disponibles.

Propiedades

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

No Señor	Método y descripción
1	arraySize Esta es una propiedad de lectura / escritura que puede establecer el número de filas devueltas por el método fetchmany ().
2	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.
3	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.
4	rowcount Esto devuelve el número de filas devueltas / actualizadas en caso de operaciones SELECT y UPDATE.
5	connection Este atributo de solo lectura proporciona la conexión de base de datos SQLite utilizada por el objeto Cursor.

Pymongo es una distribución de Python que proporciona herramientas para trabajar con MongoDB, es la forma más preferida de comunicarse con la base de datos MongoDB desde Python.

Instalación

Para instalar pymongo en primer lugar, asegúrese de haber instalado python3 (junto con PIP) y MongoDB correctamente. Luego ejecute el siguiente comando.

C:\WINDOWS\system32>pip install pymongo
Collecting pymongo
Using cached https://files.pythonhosted.org/packages/cb/a6/b0ae3781b0ad75825e00e29dc5489b53512625e02328d73556e1ecdf12f8/pymongo-3.9.0-cp37-cp37m-win32.whl
Installing collected packages: pymongo
Successfully installed pymongo-3.9.0

Verificación

Una vez que haya instalado pymongo, abra un nuevo documento de texto, pegue la siguiente línea en él y guárdelo como test.py.

import pymongo

Si ha instalado pymongo correctamente, si ejecuta test.py como se muestra a continuación, no debería tener ningún problema.

D:\Python_MongoDB>test.py
D:\Python_MongoDB>

A diferencia de otras bases de datos, MongoDB no proporciona un comando separado para crear una base de datos.

En general, el comando use se usa para seleccionar / cambiar a la base de datos específica. Este comando verifica inicialmente si la base de datos que especificamos existe, si es así, se conecta a ella. Si la base de datos que especificamos con el comando use no existe, se creará una nueva base de datos.

Por lo tanto, puede crear una base de datos en MongoDB usando el Use mando.

Sintaxis

Sintaxis básica de use DATABASE declaración es la siguiente:

use DATABASE_NAME

Ejemplo

El siguiente comando crea una base de datos nombrada en mydb.

>use mydb
switched to db mydb

Puede verificar su creación usando el comando db, esto muestra la base de datos actual.

>db
mydb

Creando una base de datos usando Python

Para conectarse a MongoDB usando pymongo, necesita importar y crear un MongoClient, luego puede acceder directamente a la base de datos que necesita crear en atributo passion.

Ejemplo

El siguiente ejemplo crea una base de datos en MangoDB.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

#Verification
print("List of databases after creating new one")
print(client.list_database_names())

Salida

Database created........
List of databases after creating new one:
['admin', 'config', 'local', 'mydb']

También puede especificar el puerto y los nombres de host mientras crea un MongoClient y puede acceder a las bases de datos en estilo diccionario.

Ejemplo

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']
print("Database created........")

Salida

Database created........

Una colección en MongoDB contiene un conjunto de documentos, es análoga a una tabla en bases de datos relacionales.

Puede crear una colección utilizando el createCollection()método. Este método acepta un valor de cadena que representa el nombre de la colección que se creará y un parámetro de opciones (opcional).

Con esto, puede especificar lo siguiente:

• El tamaño de la colección.
• El número máximo de documentos permitidos en la colección limitada.
• Si la colección que creamos debe ser una colección con límite (colección de tamaño fijo).
• Si la colección que creamos debe indexarse ​​automáticamente.

Sintaxis

A continuación se muestra la sintaxis para crear una colección en MongoDB.

db.createCollection("CollectionName")

Ejemplo

El siguiente método crea una colección denominada ExampleCollection.

> use mydb
switched to db mydb
> db.createCollection("ExampleCollection")
{ "ok" : 1 }
>

De manera similar, a continuación se muestra una consulta que crea una colección usando las opciones del método createCollection ().

>db.createCollection("mycol", { capped : true, autoIndexId : true, size :
6142800, max : 10000 } )
{ "ok" : 1 }
>

Creando una colección usando Python

El siguiente ejemplo de Python se conecta a una base de datos en MongoDB (mydb) y crea una colección en ella.

Ejemplo

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
collection = db['example']
print("Collection created........")

Salida

Collection created........

Puede almacenar documentos en MongoDB utilizando el método insert () . Este método acepta un documento JSON como parámetro.

Sintaxis

A continuación se muestra la sintaxis del método de inserción.

>db.COLLECTION_NAME.insert(DOCUMENT_NAME)

Ejemplo

> use mydb
switched to db mydb
> db.createCollection("sample")
{ "ok" : 1 }
> doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
{ "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
> db.sample.insert(doc1)
WriteResult({ "nInserted" : 1 })
>

Del mismo modo, también puede insertar varios documentos utilizando el insert() método.

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = 
[
   {
      "_id": "1001", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   }, 
   {
      "_id": "1002", 
      "name" : "Rahim", 
      "age" : 27, 
      "city" : "Bangalore" 
   }, 
   {
      "_id": "1003", 
      "name" : "Robert", 
      "age" : 28, 
      "city" : "Mumbai" 
   }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.sample.insert(data)
BulkWriteResult
({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 3,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})
>

Creando una colección usando Python

Pymongo proporciona un método llamado insert_one () para insertar un documento en MangoDB. Para este método, necesitamos pasar el documento en formato de diccionario.

Ejemplo

El siguiente ejemplo inserta un documento en la colección denominada ejemplo.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
doc1 = {"name": "Ram", "age": "26", "city": "Hyderabad"}
coll.insert_one(doc1)
print(coll.find_one())

Salida

{
   '_id': ObjectId('5d63ad6ce043e2a93885858b'), 
   'name': 'Ram', 
   'age': '26', 
   'city': 'Hyderabad'
}

Para insertar varios documentos en MongoDB usando pymongo, debe invocar el método insert_many ().

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydb']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = 
[
   {
      "_id": "101", 
      "name": "Ram", 
      "age": "26", 
      "city": "Hyderabad"
   },
   {
      "_id": "102", 
      "name": "Rahim", 
      "age": "27", 
      "city": "Bangalore"
   },
   {
      "_id": "103", 
      "name": "Robert", 
      "age": "28", 
      "city": "Mumbai"
   }
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

Salida

Data inserted ......
['101', '102', '103']

Puede leer / recuperar documentos almacenados de MongoDB usando el find()método. Este método recupera y muestra todos los documentos en MongoDB de forma no estructurada.

Sintaxis

A continuación se muestra la sintaxis del find() método.

>db.CollectionName.find()

Ejemplo

Supongamos que hemos insertado 3 documentos en una base de datos denominada testDB en una colección denominada muestra utilizando las siguientes consultas:

> use testDB
> db.createCollection("sample")
> data = [
   {"_id": "1001", "name" : "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
> db.sample.insert(data)

Puede recuperar los documentos insertados utilizando el método find () como:

> use testDB
switched to db testDB
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
>

También puede recuperar el primer documento de la colección usando el método findOne () como -

> db.sample.findOne()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Recuperando datos (buscar) usando Python

los find_One() El método de pymongo se usa para recuperar un solo documento basado en su consulta, en caso de que no haya coincidencias, este método no devuelve nada y si no usa ninguna consulta, devuelve el primer documento de la colección.

Este método es útil siempre que necesite recuperar solo un documento de un resultado o, si está seguro de que su consulta devuelve solo un documento.

Ejemplo

El siguiente ejemplo de Python recupera el primer documento de una colección:

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['mydatabase']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")
print(res.inserted_ids)

#Retrieving the first record using the find_one() method
print("First record of the collection: ")
print(coll.find_one())

#Retrieving a record with is 103 using the find_one() method
print("Record whose id is 103: ")
print(coll.find_one({"_id": "103"}))

Salida

Data inserted ......
['101', '102', '103']
First record of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
Record whose id is 103:
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Para obtener varios documentos en una sola consulta (llamada única o método de búsqueda), puede utilizar el find()método del pymongo. Si no ha pasado ninguna consulta, devuelve todos los documentos de una colección y, si ha pasado una consulta a este método, devuelve todos los documentos coincidentes.

Ejemplo

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Records of the collection: ")
for doc1 in coll.find():
print(doc1)

#Retrieving records with age greater than 26 using the find() method
print("Record whose age is more than 26: ")
for doc2 in coll.find({"age":{"$gt":"26"}}):
print(doc2)

Salida

Data inserted ......
Records of the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Record whose age is more than 26:
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Mientras recupera usando find()método, puede filtrar los documentos utilizando el objeto de consulta. Puede pasar la consulta especificando la condición de los documentos requeridos como parámetro de este método.

Operadores

A continuación se muestra la lista de operadores utilizados en las consultas en MongoDB.

Operación	Sintaxis	Ejemplo
Igualdad	{"valor clave"}	db.mycol.find ({"por": "punto de tutoriales"})
Menos que	{"clave": {$ lt: "valor"}}	db.mycol.find ({"me gusta": {$ lt: 50}})
Menor que igual	{"clave": {$ lte: "valor"}}	db.mycol.find ({"me gusta": {$ lte: 50}})
Mas grande que	{"clave": {$ gt: "valor"}}	db.mycol.find ({"me gusta": {$ gt: 50}})
Mayor que igual	{"clave" {$ gte: "valor"}}	db.mycol.find ({"me gusta": {$ gte: 50}})
No es igual	{"clave": {$ ne: "valor"}}	db.mycol.find ({"me gusta": {$ ne: 50}})

Ejemplo 1

El siguiente ejemplo recupera el documento en una colección cuyo nombre es sarmista.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sdsegf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc1 in coll.find({"name":"Sarmista"}):
   print(doc1)

Salida

Data inserted ......
Documents in the collection:
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}

Ejemplo 2

El siguiente ejemplo recupera el documento de una colección cuyo valor de antigüedad es superior a 26.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['ghhj']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving data
print("Documents in the collection: ")

for doc in coll.find({"age":{"$gt":"26"}}):
   print(doc)

Salida

Data inserted ......
Documents in the collection:
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Mientras recupera el contenido de una colección, puede ordenarlos y organizarlos en orden ascendente o descendente utilizando el sort() método.

A este método, puede pasar el campo (s) y el orden de clasificación que es 1 o -1. Donde, 1 es para orden ascendente y -1 es orden descendente.

Sintaxis

A continuación se muestra la sintaxis del método sort () .

>db.COLLECTION_NAME.find().sort({KEY:1})

Ejemplo

Supongamos que hemos creado una colección e insertado 5 documentos en ella como se muestra a continuación:

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

La siguiente línea recupera todos los documentos de la colección que están clasificados en orden ascendente según la antigüedad.

> db.sample.find().sort({age:1})
{ "_id" : "1005", "name" : "Sarmista", "age" : 23, "city" : "Delhi" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }

Ordenando los documentos usando Python

Para ordenar los resultados de una consulta en orden ascendente o descendente, pymongo proporciona la sort()método. Para este método, pase un valor numérico que represente la cantidad de documentos que necesita en el resultado.

De forma predeterminada, este método clasifica los documentos en orden ascendente según el campo especificado. Si necesita ordenar en orden descendente, pase -1 junto con el nombre del campo -

coll.find().sort("age",-1)

Ejemplo

El siguiente ejemplo recupera todos los documentos de una colección organizados según los valores de edad en orden ascendente:

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['b_mydb']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("List of documents (sorted in ascending order based on age): ")

for doc1 in coll.find().sort("age"):
   print(doc1)

Salida

Data inserted ......
List of documents (sorted in ascending order based on age):
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1006', 'name': 'Rasajna', 'age': 26, 'city': 'Chennai'}
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Puede eliminar documentos de una colección mediante el remove()método de MongoDB. Este método acepta dos parámetros opcionales:

• criterios de eliminación que especifican la condición para eliminar documentos.

• solo uno, si pasa verdadero o 1 como segundo parámetro, solo se eliminará un documento.

Sintaxis

A continuación se muestra la sintaxis del método remove ():

>db.COLLECTION_NAME.remove(DELLETION_CRITTERIA)

Ejemplo

Supongamos que hemos creado una colección e insertado 5 documentos en ella como se muestra a continuación:

> use testDB
switched to db testDB
> db.createCollection("myColl")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

La siguiente consulta elimina los documentos de la colección que tienen el valor de nombre Sarmista.

> db.sample.remove({"name": "Sarmista"})
WriteResult({ "nRemoved" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
{ "_id" : "1004", "name" : "Romeo", "age" : 25, "city" : "Pune" }
{ "_id" : "1006", "name" : "Rasajna", "age" : 26, "city" : "Chennai" }

Si invocas remove() sin pasar los criterios de eliminación, se eliminarán todos los documentos de la colección.

> db.sample.remove({})
WriteResult({ "nRemoved" : 5 })
> db.sample.find()

Eliminar documentos usando Python

Para eliminar documentos de una colección de MangoDB, puede eliminar documentos de una colección utilizando los métodos delete_one() y delete_many() métodos.

Estos métodos aceptan un objeto de consulta que especifica la condición para eliminar documentos.

El método detele_one () elimina un solo documento, en caso de una coincidencia. Si no se especifica ninguna consulta, este método elimina el primer documento de la colección.

Ejemplo

El siguiente ejemplo de Python elimina el documento de la colección que tiene un valor de identificación como 1006.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['lpaksgf']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting one document
coll.delete_one({"_id" : "1006"})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Salida

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
{'_id': '1004', 'name': 'Romeo', 'age': 25, 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': 23, 'city': 'Delhi'}

Del mismo modo, el delete_many() El método de pymongo elimina todos los documentos que cumplen la condición especificada.

Ejemplo

El siguiente ejemplo elimina todos los documentos de la colección cuyo valor de edad sea superior a 26:

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['sampleDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": "25", "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": "23", "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": "26", "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Deleting multiple documents
coll.delete_many({"age":{"$gt":"26"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Salida

Data inserted ......
Documents in the collection after update operation:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1004', 'name': 'Romeo', 'age': '25', 'city': 'Pune'}
{'_id': '1005', 'name': 'Sarmista', 'age': '23', 'city': 'Delhi'}
{'_id': '1006', 'name': 'Rasajna', 'age': '26', 'city': 'Chennai'}

Si invoca el método delete_many () sin pasar ninguna consulta, este método elimina todos los documentos de la colección.

coll.delete_many({})

Puede eliminar colecciones usando drop() método de MongoDB.

Sintaxis

A continuación se muestra la sintaxis del método drop ():

db.COLLECTION_NAME.drop()

Ejemplo

El siguiente ejemplo deja caer la colección con el nombre de la muestra:

> show collections
myColl
sample
> db.sample.drop()
true
> show collections
myColl

Dejar caer la colección usando Python

Puede eliminar / eliminar una colección de la base de datos actual invocando el método drop ().

Ejemplo

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['example2']

#Creating a collection
col1 = db['collection']
col1.insert_one({"name": "Ram", "age": "26", "city": "Hyderabad"})
col2 = db['coll']
col2.insert_one({"name": "Rahim", "age": "27", "city": "Bangalore"})
col3 = db['myColl']
col3.insert_one({"name": "Robert", "age": "28", "city": "Mumbai"})
col4 = db['data']
col4.insert_one({"name": "Romeo", "age": "25", "city": "Pune"})

#List of collections
print("List of collections:")
collections = db.list_collection_names()
for coll in collections:
print(coll)

#Dropping a collection
col1.drop()
col4.drop()
print("List of collections after dropping two of them: ")

#List of collections
collections = db.list_collection_names()

for coll in collections:
   print(coll)

Salida

List of collections:
coll
data
collection
myColl
List of collections after dropping two of them:
coll
myColl

Puede actualizar el contenido de un documento existente utilizando el update() método o save() método.

El método de actualización modifica el documento existente, mientras que el método de guardado reemplaza el documento existente por el nuevo.

Sintaxis

A continuación se muestra la sintaxis de los métodos update () y save () de MangoDB:

>db.COLLECTION_NAME.update(SELECTION_CRITERIA, UPDATED_DATA)
Or,
db.COLLECTION_NAME.save({_id:ObjectId(),NEW_DATA})

Ejemplo

Supongamos que hemos creado una colección en una base de datos e insertado 3 registros en ella como se muestra a continuación:

> use testdatabase
switched to db testdatabase
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" },
   ... {"_id": "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }
]
[
   {
      "_id" : "1001",
      "name" : "Ram",
      "age" : "26",
      "city" : "Hyderabad"
   },
   {
      "_id" : "1002",
      "name" : "Rahim",
      "age" : 27,
      "city" : "Bangalore"
   },
   {
      "_id" : "1003",
      "name" : "Robert",
      "age" : 28,
      "city" : "Mumbai"
   }
]
> db.createCollection("sample")
{ "ok" : 1 }
> db.sample.insert(data)

El siguiente método actualiza el valor de la ciudad del documento con la identificación 1002.

> db.sample.update({"_id":"1002"},{"$set":{"city":"Visakhapatnam"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

De manera similar, puede reemplazar el documento con nuevos datos guardándolo con la misma identificación usando el método save ().

> db.sample.save(
   { "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
)
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.sample.find()
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Vijayawada" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Visakhapatnam" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Actualizar documentos usando Python

Similar al método find_one () que recupera un solo documento, el método update_one () de pymongo actualiza un solo documento.

Este método acepta una consulta que especifica qué documento actualizar y la operación de actualización.

Ejemplo

El siguiente ejemplo de Python actualiza el valor de ubicación de un documento en una colección.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_one({"_id":"102"},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Salida

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}

Del mismo modo, el update_many() El método de pymongo actualiza todos los documentos que satisfacen la condición especificada.

Ejemplo

El siguiente ejemplo actualiza el valor de ubicación en todos los documentos de una colección (condición vacía):

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['myDB']

#Creating a collection
coll = db['example']

#Inserting document into a collection
data = [
   {"_id": "101", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "102", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "103", "name": "Robert", "age": "28", "city": "Mumbai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving all the records using the find() method
print("Documents in the collection: ")
for doc1 in coll.find():
print(doc1)
coll.update_many({},{"$set":{"city":"Visakhapatnam"}})

#Retrieving all the records using the find() method
print("Documents in the collection after update operation: ")

for doc2 in coll.find():
   print(doc2)

Salida

Data inserted ......
Documents in the collection:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}
Documents in the collection after update operation:
{'_id': '101', 'name': 'Ram', 'age': '26', 'city': 'Visakhapatnam'}
{'_id': '102', 'name': 'Rahim', 'age': '27', 'city': 'Visakhapatnam'}
{'_id': '103', 'name': 'Robert', 'age': '28', 'city': 'Visakhapatnam'}

Mientras recupera el contenido de una colección, puede limitar el número de documentos en el resultado utilizando el método limit (). Este método acepta un valor numérico que representa el número de documentos que desea en el resultado.

Sintaxis

A continuación se muestra la sintaxis del método limit ():

>db.COLLECTION_NAME.find().limit(NUMBER)

Ejemplo

Supongamos que hemos creado una colección e insertado 5 documentos en ella como se muestra a continuación:

> use testDB
switched to db testDB
> db.createCollection("sample")
{ "ok" : 1 }
> data = [
   ... {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   ... {"_id": "1002", "name": "Rahim", "age": 27, "city": "Bangalore"},
   ... {"_id": "1003", "name": "Robert", "age": 28, "city": "Mumbai"},
   ... {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   ... {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   ... {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
> db.sample.insert(data)
BulkWriteResult({
   "writeErrors" : [ ],
   "writeConcernErrors" : [ ],
   "nInserted" : 6,
   "nUpserted" : 0,
   "nMatched" : 0,
   "nModified" : 0,
   "nRemoved" : 0,
   "upserted" : [ ]
})

La siguiente línea recupera los primeros 3 documentos de la colección.

> db.sample.find().limit(3)
{ "_id" : "1001", "name" : "Ram", "age" : "26", "city" : "Hyderabad" }
{ "_id" : "1002", "name" : "Rahim", "age" : 27, "city" : "Bangalore" }
{ "_id" : "1003", "name" : "Robert", "age" : 28, "city" : "Mumbai" }

Limitando los documentos usando python

Para restringir los resultados de una consulta a un número particular de documentos, pymongo proporciona la limit()método. A este método, pase un valor numérico que represente la cantidad de documentos que necesita en el resultado.

Ejemplo

El siguiente ejemplo recupera los tres primeros documentos de una colección.

from pymongo import MongoClient

#Creating a pymongo client
client = MongoClient('localhost', 27017)

#Getting the database instance
db = client['l']

#Creating a collection
coll = db['myColl']

#Inserting document into a collection
data = [
   {"_id": "1001", "name": "Ram", "age": "26", "city": "Hyderabad"},
   {"_id": "1002", "name": "Rahim", "age": "27", "city": "Bangalore"},
   {"_id": "1003", "name": "Robert", "age": "28", "city": "Mumbai"},
   {"_id": "1004", "name": "Romeo", "age": 25, "city": "Pune"},
   {"_id": "1005", "name": "Sarmista", "age": 23, "city": "Delhi"},
   {"_id": "1006", "name": "Rasajna", "age": 26, "city": "Chennai"}
]
res = coll.insert_many(data)
print("Data inserted ......")

#Retrieving first 3 documents using the find() and limit() methods
print("First 3 documents in the collection: ")

for doc1 in coll.find().limit(3):
   print(doc1)

Salida

Data inserted ......
First 3 documents in the collection:
{'_id': '1001', 'name': 'Ram', 'age': '26', 'city': 'Hyderabad'}
{'_id': '1002', 'name': 'Rahim', 'age': '27', 'city': 'Bangalore'}
{'_id': '1003', 'name': 'Robert', 'age': '28', 'city': 'Mumbai'}