Python SQLite - Guía rápida

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 un cursor que 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 declaració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 simplemente 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 la consulta, devolviendo 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 una conexión con el símbolo del sistema de 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 usando 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 ..........")

Usando 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 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 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 usando 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 con 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 de 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 SELECT. 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 usando 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 declaración SELECT de la base de datos SQLite simplemente devuelve los registros de las tablas especificadas. Para obtener una salida formateada, debe configurar elheader, y 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   rilanka
Virat        Kohli        India
Rohit        Sharma       India

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 sqlite python.

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 () obtiene 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 EMPLEADO 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 usando 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 la 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 usar "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 usando 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 usando 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 con 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 de 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.

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 usando 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 con 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 de 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, pasando un DELETE declaración como un 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 DELETE. Esto elimina la tabla si existe; de lo contrario, omite la operación DELETE.

sqlite> DROP table IF EXISTS employee;
sqlite>

Soltar una tabla usando Python

Puede eliminar una tabla cuando lo necesite, utilizando la instrucció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 usando 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 cricket utilizando 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 empezando por el n-ésimo registro (no el 1 ^° ), 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 Joins.

Ejemplo

Supongamos que hemos creado una tabla con el nombre CRICKETERS usando 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. Puede crear un objeto Cursor 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.

Método	Descripción
ejecutar()	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))
ejecutar muchos ()	Esta rutina ejecuta un comando SQL contra todas las secuencias de parámetros o asignaciones que se encuentran en la secuencia sql.
fetchone ()	Este método obtiene la siguiente fila de un conjunto de resultados de la consulta, devolviendo una sola secuencia o None cuando no hay más datos disponibles.
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.
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:

Método	Descripción
arraySize	Esta es una propiedad de lectura / escritura que puede establecer el número de filas devueltas por el método fetchmany ().
descripción	Esta es una propiedad de solo lectura que devuelve la lista que contiene la descripción de las columnas en un conjunto de resultados.
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.
número de filas	Esto devuelve el número de filas devueltas / actualizadas en caso de operaciones SELECT y UPDATE.
conexión	Este atributo de solo lectura proporciona la conexión de base de datos SQLite utilizada por el objeto Cursor.

↰ Previous page