Python SQLite - szybki przewodnik

SQLite3 można zintegrować z Pythonem za pomocą modułu sqlite3, którego autorem jest Gerhard Haring. Zapewnia interfejs SQL zgodny ze specyfikacją DB-API 2.0 opisaną w PEP 249. Nie musisz instalować tego modułu oddzielnie, ponieważ jest on dostarczany domyślnie wraz z wersją Python 2.5.x.

Aby użyć modułu sqlite3, musisz najpierw utworzyć obiekt połączenia, który reprezentuje bazę danych, a następnie opcjonalnie możesz utworzyć obiekt kursora, który pomoże ci w wykonywaniu wszystkich instrukcji SQL.

Interfejsy API modułu Python SQLite3

Poniżej przedstawiono ważne procedury modułu sqlite3, które mogą wystarczyć do pracy z bazą danych SQLite z poziomu programu w Pythonie. Jeśli szukasz bardziej wyrafinowanej aplikacji, możesz zajrzeć do oficjalnej dokumentacji modułu Python sqlite3.

Sr.No.	API i opis
1	sqlite3.connect(database [,timeout ,other optional arguments]) Ten interfejs API otwiera połączenie z plikiem bazy danych SQLite. Możesz użyć ": memory:" do otwarcia połączenia z bazą danych, która znajduje się w pamięci RAM zamiast na dysku. Jeśli baza danych zostanie otwarta pomyślnie, zwraca obiekt połączenia.
2	connection.cursor([cursorClass]) Ta procedura tworzy kursor, który będzie używany podczas programowania bazy danych w Pythonie. Ta metoda akceptuje jeden opcjonalny parametr cursorClass. Jeśli jest podana, musi to być niestandardowa klasa kursora, która rozszerza sqlite3.Cursor.
3	cursor.execute(sql [, optional parameters]) Ta procedura wykonuje instrukcję SQL. Instrukcja SQL może być sparametryzowana (tj. Symbole zastępcze zamiast literałów SQL). Moduł sqlite3 obsługuje dwa rodzaje symboli zastępczych: znaki zapytania i nazwane symbole zastępcze (nazwany styl). For example - kursor.execute ("wstaw do wartości osób (?,?)", (Kto, wiek))
4	connection.execute(sql [, optional parameters]) Ta procedura jest skrótem do powyższej metody execute udostępnianej przez obiekt kursora i tworzy obiekt pośredniego kursora przez wywołanie metody kursora, a następnie wywołuje metodę wykonywania kursora z podanymi parametrami.
5	cursor.executemany(sql, seq_of_parameters) Ta procedura wykonuje polecenie SQL na wszystkich sekwencjach parametrów lub odwzorowaniach znalezionych w sekwencji sql.
6	connection.executemany(sql[, parameters]) Ta procedura jest skrótem, który tworzy obiekt kursora pośredniego przez wywołanie metody kursora, a następnie wywołuje metodę kursor.s executemany z podanymi parametrami.
7	cursor.executescript(sql_script) Ta procedura wykonuje jednocześnie wiele instrukcji SQL podanych w formie skryptu. Najpierw wydaje instrukcję COMMIT, a następnie wykonuje skrypt SQL, który otrzymuje jako parametr. Wszystkie instrukcje SQL powinny być oddzielone średnikiem (;).
8	connection.executescript(sql_script) Ta procedura jest skrótem, który tworzy pośredni obiekt kursora przez wywołanie metody kursora, a następnie wywołuje metodę executescript kursora z podanymi parametrami.
9	connection.total_changes() Ta procedura zwraca całkowitą liczbę wierszy bazy danych, które zostały zmodyfikowane, wstawione lub usunięte od czasu otwarcia połączenia z bazą danych.
10	connection.commit() Ta metoda zatwierdza bieżącą transakcję. Jeśli nie wywołasz tej metody, wszystko, co zrobiłeś od ostatniego wywołania funkcji commit () nie jest widoczne z innych połączeń z bazą danych.
11	connection.rollback() Ta metoda cofa wszelkie zmiany w bazie danych od ostatniego wywołania funkcji commit ().
12	connection.close() Ta metoda zamyka połączenie z bazą danych. Zwróć uwagę, że nie wywołuje to automatycznie funkcji commit (). Jeśli po prostu zamkniesz połączenie z bazą danych bez uprzedniego wywołania funkcji commit (), zmiany zostaną utracone!
13	cursor.fetchone() Ta metoda pobiera następny wiersz zestawu wyników zapytania, zwracając pojedynczą sekwencję lub None, gdy nie ma więcej danych.
14	cursor.fetchmany([size = cursor.arraysize]) Ta procedura pobiera następny zestaw wierszy wyniku zapytania, zwracając listę. W przypadku braku dostępnych wierszy zwracana jest pusta lista. Metoda próbuje pobrać tyle wierszy, ile wskazuje parametr size.
15	cursor.fetchall() Ta procedura pobiera wszystkie (pozostałe) wiersze wyniku zapytania, zwracając listę. W przypadku braku dostępnych wierszy zwracana jest pusta lista.

Aby nawiązać połączenie z wierszem poleceń SQLite Open, przejrzyj lokalizację, w której zainstalowałeś SQLite i po prostu wykonaj polecenie sqlite3 jak pokazano poniżej -

Nawiązywanie połączenia za pomocą Pythona

Możesz komunikować się z bazą danych SQLite2 za pomocą modułu SQLite3 python. Aby to zrobić, musisz najpierw nawiązać połączenie (utworzyć obiekt połączenia).

Aby nawiązać połączenie z bazą danych SQLite3 za pomocą Pythona, musisz:

• Zaimportuj moduł sqlite3 za pomocą instrukcji import.

• Metoda connect () przyjmuje nazwę bazy danych, z którą chcesz się połączyć, jako parametr i zwraca obiekt Connection.

Przykład

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

Wynik

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

Używając instrukcji SQLite CREATE TABLE, można utworzyć tabelę w bazie danych.

Składnia

Poniżej znajduje się składnia tworzenia tabeli w bazie danych SQLite -

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

Przykład

Po zapytaniu / instrukcji SQLite tworzy tabelę z nazwą CRICKETERS w bazie danych SQLite -

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

Stwórzmy jeszcze jedną tabelę OdiStats opisującą jednodniowe statystyki krykieta każdego gracza w tabeli CRICKETERS.

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

Możesz pobrać listę tabel w bazie danych w bazie danych SQLite za pomocą .tablesKomenda. Po utworzeniu tabeli, jeśli możesz zweryfikować listę tabel, możesz obserwować nowo utworzoną tabelę jako -

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Tworzenie tabeli w Pythonie

Obiekt Cursor zawiera wszystkie metody do wykonywania zapytań i pobierania danych itp. Metoda kursora klasy połączenia zwraca obiekt kursora.

Dlatego, aby utworzyć tabelę w bazie danych SQLite za pomocą Pythona -

• Nawiąż połączenie z bazą danych za pomocą metody connect ().

• Utwórz obiekt kursora, wywołując metodę cursor () na powyższym utworzonym obiekcie połączenia.

• Teraz wykonaj instrukcję CREATE TABLE, używając metody execute () klasy Cursor.

Przykład

Poniższy program w Pythonie tworzy tabelę o nazwie Employee w 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()

Wynik

Table created successfully........

Możesz dodać nowe wiersze do istniejącej tabeli SQLite za pomocą instrukcji INSERT INTO. W tym celu musisz określić nazwę tabeli, nazwy kolumn i wartości (w tej samej kolejności, co nazwy kolumn).

Składnia

Poniżej znajduje się zalecana składnia instrukcji INSERT -

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

Gdzie kolumna1, kolumna2, kolumna3, .. to nazwy kolumn tabeli, a wartość1, wartość2, wartość3, ... to wartości, które należy wstawić do tabeli.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS przy użyciu instrukcji CREATE TABLE, jak pokazano poniżej -

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

Poniższa instrukcja PostgreSQL wstawia wiersz do powyższej tabeli.

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

Podczas wstawiania rekordów za pomocą instrukcji INSERT INTO , jeśli pominiesz nazwy kolumn, ten rekord zostanie wstawiony z pozostawieniem pustych spacji w kolumnach, które zostały pominięte.

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

Możesz także wstawiać rekordy do tabeli bez określania nazw kolumn, jeśli kolejność przekazywanych wartości jest taka sama, jak ich nazwy kolumn w tabeli.

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>

Po wstawieniu rekordów do tabeli możesz zweryfikować jej zawartość za pomocą instrukcji SELECT, jak pokazano poniżej -

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>

Wstawianie danych za pomocą Pythona

Aby dodać rekordy do istniejącej tabeli w bazie danych SQLite -

• Importuj pakiet sqlite3.

• Utwórz obiekt połączenia za pomocą metody connect (), przekazując nazwę bazy danych jako parametr.

• Plik cursor()metoda zwraca obiekt kursora, za pomocą którego można komunikować się z SQLite3. Utwórz obiekt kursora, wywołując obiekt kursora () na (utworzonym powyżej) obiekcie Connection.

• Następnie wywołaj metodę execute () na obiekcie kursora, przekazując do niego instrukcję INSERT jako parametr.

Przykład

Poniższy przykład w Pythonie wstawia rekordy do tabeli o nazwie PRACOWNIK -

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

Wynik

Records inserted........

Możesz pobrać dane z tabeli SQLite za pomocą zapytania SELECT. To zapytanie / instrukcja zwraca zawartość określonej relacji (tabeli) w formie tabelarycznej i jest nazywana zbiorem wyników.

Składnia

Poniżej znajduje się składnia instrukcji SELECT w SQLite -

SELECT column1, column2, columnN FROM table_name;

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następujące zapytanie SELECT pobiera wartości kolumn FIRST_NAME, LAST_NAME i COUNTRY z tabeli 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>

Jak można zauważyć, instrukcja SELECT bazy danych SQLite po prostu zwraca rekordy określonych tabel. Aby uzyskać sformatowane dane wyjściowe, musisz ustawićheader, i mode używając odpowiednich poleceń przed instrukcją SELECT, jak pokazano poniżej -

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

Jeśli chcesz pobrać wszystkie kolumny każdego rekordu, musisz zastąpić nazwy kolumn znakiem „*”, jak pokazano poniżej -

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>

W SQLite domyślnie szerokość kolumn jest 10 wartości poza tym szerokość są posiekane (obserwować kolumnę kraj z 2 ^-go rzędu w powyższej tabeli). Możesz ustawić szerokość każdej kolumny na wymaganą wartość za pomocą.width polecenie, przed pobraniem zawartości tabeli, jak pokazano poniżej -

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>

Pobieranie danych za pomocą Pythona

READ Operacja na dowolnej bazie danych oznacza pobranie przydatnych informacji z bazy danych. Możesz pobrać dane z MYSQL za pomocą metody fetch () dostarczonej przez moduł sqlite python.

Klasa sqlite3.Cursor udostępnia trzy metody, mianowicie fetchall (), fetchmany () i, fetchone () gdzie,

• Metoda fetchall () pobiera wszystkie wiersze ze zbioru wyników zapytania i zwraca je jako listę krotek. (Jeśli wykonamy to po pobraniu kilku wierszy, zwróci pozostałe).

• Metoda fetchone () pobiera następny wiersz w wyniku zapytania i zwraca go jako krotkę.

• Metoda fetchmany () jest podobna do metody fetchone (), ale pobiera następny zestaw wierszy w zestawie wyników zapytania zamiast pojedynczego wiersza.

Note - Zestaw wyników to obiekt, który jest zwracany, gdy obiekt kursora jest używany do zapytania tabeli.

Przykład

Poniższy przykład pobiera wszystkie wiersze tabeli EMPLOYEE za pomocą zapytania SELECT iz otrzymanego zestawu wyników początkowo pobieramy pierwszy wiersz za pomocą metody fetchone (), a następnie pobieramy pozostałe wiersze za pomocą metody fetchall ().

Poniższy program w Pythonie pokazuje, jak pobrać i wyświetlić rekordy z tabeli COMPANY utworzonej w powyższym przykładzie.

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

Wynik

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

Jeśli chcesz pobrać, usunąć lub zaktualizować określone wiersze tabeli w SQLite, musisz użyć klauzuli where, aby określić warunek filtrowania wierszy tabeli dla operacji.

Na przykład, jeśli masz instrukcję SELECT z klauzulą ​​where, zostaną pobrane tylko wiersze spełniające określony warunek.

Składnia

Poniżej znajduje się składnia klauzuli WHERE w SQLite -

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

Warunek_wyszukiwania można określić za pomocą porównania lub operatorów logicznych. takie jak>, <, =, LIKE, NOT itd. Poniższe przykłady wyjaśniają tę koncepcję.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następująca instrukcja SELECT pobiera rekordy, których wiek jest większy niż 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>

Where Klauzula przy użyciu Pythona

Obiekt / klasa Cursor zawiera wszystkie metody do wykonywania zapytań i pobierania danych itp. Metoda kursora klasy połączenia zwraca obiekt kursora.

Dlatego, aby utworzyć tabelę w bazie danych SQLite za pomocą Pythona -

• Nawiąż połączenie z bazą danych za pomocą metody connect ().

• Utwórz obiekt kursora, wywołując metodę cursor () na powyższym utworzonym obiekcie połączenia.

• Teraz wykonaj instrukcję CREATE TABLE, używając metody execute () klasy Cursor.

Przykład

Poniższy przykład tworzy tabelę o nazwie Employee i zapełnia ją. Następnie za pomocą klauzuli where pobiera rekordy z wartością wieku mniejszą niż 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()

Wynik

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

Podczas pobierania danych za pomocą zapytania SELECT otrzymasz rekordy w tej samej kolejności, w jakiej je wstawiłeś.

Możesz sortować wyniki w żądanej kolejności (rosnąco lub malejąco) za pomocą Order Byklauzula. Domyślnie ta klauzula sortuje wyniki w porządku rosnącym, jeśli chcesz uporządkować je w porządku malejącym, musisz jawnie użyć „DESC”.

Składnia

Poniżej znajduje się składnia klauzuli ORDER BY w SQLite.

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następująca instrukcja SELECT pobiera wiersze tabeli CRICKETERS w rosnącej kolejności ich wieku -

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>

Do sortowania rekordów tabeli można użyć więcej niż jednej kolumny. Następujące instrukcje SELECT sortują rekordy tabeli CRICKETERS na podstawie kolumn AGE i 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>

Domyślnie ORDER BY klauzula sortuje rekordy tabeli w porządku rosnącym, możesz uporządkować wyniki w porządku malejącym, używając DESC jako -

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>

Klauzula ORDER BY w języku Python

Aby pobrać zawartość tabeli w określonej kolejności, wywołaj metodę execute () na obiekcie kursora i przekaż instrukcję SELECT wraz z klauzulą ​​ORDER BY jako parametr do niej.

Przykład

W poniższym przykładzie tworzymy tabelę z imieniem i nazwiskiem i Pracownikiem, zapełniamy ją i pobieramy jej rekordy w (rosnącej) kolejności ich wieku, używając klauzuli 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()

Wynik

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

UPDATE Operacja na dowolnej bazie danych oznacza modyfikację wartości jednego lub więcej rekordów tabeli, które są już dostępne w bazie danych. Możesz zaktualizować wartości istniejących rekordów w SQLite za pomocą instrukcji UPDATE.

Aby zaktualizować określone wiersze, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia instrukcji UPDATE w SQLite -

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następujące zdanie modyfikuje wiek krykiecisty, którego imię to Shikhar -

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

Jeśli odzyskasz rekord, którego FIRST_NAME to Shikhar, zauważysz, że wartość wieku została zmieniona na 45 -

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

Jeśli nie użyłeś klauzuli WHERE, wartości wszystkich rekordów zostaną zaktualizowane. Kolejne polecenie UPDATE zwiększa wiek wszystkich rekordów w tabeli CRICKETERS o 1 -

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

Jeśli pobierzesz zawartość tabeli za pomocą polecenia SELECT, możesz zobaczyć zaktualizowane wartości jako -

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>

Aktualizowanie istniejących rekordów za pomocą Pythona

Aby dodać rekordy do istniejącej tabeli w bazie danych SQLite -

• Importuj pakiet sqlite3.

• Utwórz obiekt połączenia za pomocą metody connect (), przekazując nazwę bazy danych jako parametr.

• Plik cursor()metoda zwraca obiekt kursora, za pomocą którego można komunikować się z SQLite3. Utwórz obiekt kursora, wywołując obiekt kursora () na (utworzonym powyżej) obiekcie Connection.

• Następnie wywołaj metodę execute () na obiekcie kursora, przekazując do niego instrukcję UPDATE jako parametr.

Przykład

Idąc za przykładem Pythona, tworzy tabelę o nazwie PRACOWNIK, wstawia do niej 5 rekordów i zwiększa wiek wszystkich pracowników płci męskiej o 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()

Wynik

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

Aby usunąć rekordy z tabeli SQLite, musisz użyć instrukcji DELETE FROM. Aby usunąć określone rekordy, musisz użyć wraz z nią klauzuli WHERE.

Składnia

Poniżej znajduje się składnia zapytania DELETE w SQLite -

DELETE FROM table_name [WHERE Clause]

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Poniższe stwierdzenie usuwa wpis krykiecisty, którego nazwisko brzmi „Sangakkara”.

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

Jeśli pobierzesz zawartość tabeli za pomocą instrukcji SELECT, zobaczysz tylko 4 rekordy, ponieważ jeden został usunięty.

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>

Jeśli wykonasz instrukcję DELETE FROM bez klauzuli WHERE, wszystkie rekordy z określonej tabeli zostaną usunięte.

sqlite> DELETE FROM CRICKETERS;
sqlite>

Ponieważ usunąłeś wszystkie rekordy, jeśli spróbujesz odzyskać zawartość tabeli CRICKETERS, używając instrukcji SELECT otrzymasz pusty zestaw wyników, jak pokazano poniżej -

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Usuwanie danych za pomocą Pythona

Aby dodać rekordy do istniejącej tabeli w bazie danych SQLite -

• Importuj pakiet sqlite3.

• Utwórz obiekt połączenia za pomocą metody connect () , przekazując nazwę bazy danych jako parametr.

• Plik cursor()metoda zwraca obiekt kursora, za pomocą którego można komunikować się z SQLite3. Utwórz obiekt kursora, wywołując obiekt kursora () na (utworzonym powyżej) obiekcie Connection.

• Następnie wywołaj metodę execute () na obiekcie kursora, przekazując plik DELETE jako parametr do niej.

Przykład

Poniższy przykład w Pythonie usuwa rekordy z tabeli EMPLOYEE z wartością wieku większą niż 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()

Wynik

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

Możesz usunąć całą tabelę za pomocą instrukcji DROP TABLE. Musisz tylko podać nazwę tabeli, którą chcesz usunąć.

Składnia

Poniżej znajduje się składnia instrukcji DROP TABLE w PostgreSQL -

DROP TABLE table_name;

Przykład

Załóżmy, że utworzyliśmy dwie tabele o nazwach KRYKIETY i PRACOWNICY, używając następujących zapytań -

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>

Teraz, jeśli zweryfikujesz listę tabel przy użyciu .tables polecenie, możesz zobaczyć powyższe utworzone tabele w nim (lista) jako -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

Poniższa instrukcja usuwa tabelę o nazwie Employee z bazy danych -

sqlite> DROP table employee;
sqlite>

Ponieważ usunąłeś tabelę Employee, jeśli ponownie odzyskasz listę tabel, możesz obserwować tylko jedną tabelę w niej.

sqlite> .tables
CRICKETERS
sqlite>

Jeśli spróbujesz ponownie usunąć tabelę pracowników, ponieważ już ją usunąłeś, pojawi się komunikat o błędzie „nie ma takiej tabeli”, jak pokazano poniżej -

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

Aby rozwiązać ten problem, można użyć klauzuli IF EXISTS wraz z instrukcją DELETE. Spowoduje to usunięcie tabeli, jeśli istnieje, w przeciwnym razie pominie operację DELETE.

sqlite> DROP table IF EXISTS employee;
sqlite>

Upuszczanie tabeli za pomocą Pythona

Możesz usunąć tabelę w dowolnym momencie, używając instrukcji DROP MYSQL, ale musisz być bardzo ostrożny podczas usuwania istniejącej tabeli, ponieważ utracone dane nie zostaną odzyskane po usunięciu tabeli.

Przykład

Aby usunąć tabelę z bazy danych SQLite3 za pomocą języka Python, wywołaj plik execute() na obiekcie kursora i przekaż do niego instrukcję drop jako parametr.

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

Wynik

Table dropped...

Podczas pobierania rekordów, jeśli chcesz ograniczyć je o określoną liczbę, możesz to zrobić, korzystając z klauzuli LIMIT programu SQLite.

Składnia

Poniżej znajduje się składnia klauzuli LIMIT w SQLite -

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

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

A jeśli wstawiliśmy do niego 5 rekordów, używając instrukcji INSERT jako -

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>

Następująca instrukcja pobiera pierwsze 3 rekordy tabeli Cricketers przy użyciu klauzuli 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>

Jeśli trzeba ograniczyć rekordy począwszy od n-tego rekordu (nie 1 ^st ), można to zrobić, offsetowego wraz z 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>

Klauzula LIMIT w Pythonie

Jeśli wywołasz metodę execute () na obiekcie kursora, przekazując zapytanie SELECT wraz z klauzulą ​​LIMIT, możesz pobrać wymaganą liczbę rekordów.

Przykład

Poniższy przykład w języku Python pobiera pierwsze dwa rekordy tabeli EMPLOYEE przy użyciu klauzuli 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()

Wynik

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

Po podzieleniu danych na dwie tabele możesz pobrać połączone rekordy z tych dwóch tabel za pomocą funkcji Łączenia.

Przykład

Załóżmy, że utworzyliśmy tabelę o nazwie CRICKETERS, używając następującego zapytania -

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

Stwórzmy jeszcze jedną tabelę OdiStats opisującą jednodniowe statystyki krykieta każdego gracza w tabeli CRICKETERS.

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

Następująca instrukcja pobiera dane łączące wartości z tych dwóch tabel -

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>

Join Clause przy użyciu Pythona

Zgodnie z przykładem SQLite demonstruje klauzulę JOIN przy użyciu języka 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()

Wynik

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

Klasa sqlite3.Cursor to instancja, za pomocą której można wywoływać metody wykonujące instrukcje SQLite, pobierać dane z wyników zapytań. Obiekt Cursor można utworzyć za pomocą metody kursora () obiektu / klasy Connection.

Przykład

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

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

Metody

Poniżej przedstawiono różne metody udostępniane przez klasę / obiekt Cursor.

metoda	Opis
wykonać()	Ta procedura wykonuje instrukcję SQL. Instrukcja SQL może być sparametryzowana (tj. Symbole zastępcze zamiast literałów SQL). Moduł psycopg2 obsługuje symbole zastępcze przy użyciu znaku% s Na przykład: kursor.execute ("wstaw do wartości osób (% s,% s)", (kto, wiek))
executemany ()	Ta procedura wykonuje polecenie SQL na wszystkich sekwencjach parametrów lub odwzorowaniach znalezionych w sekwencji sql.
fetchone ()	Ta metoda pobiera następny wiersz zestawu wyników zapytania, zwracając pojedynczą sekwencję lub None, gdy nie ma więcej danych.
fetchmany ()	Ta procedura pobiera następny zestaw wierszy wyniku zapytania, zwracając listę. W przypadku braku dostępnych wierszy zwracana jest pusta lista. Metoda próbuje pobrać tyle wierszy, ile wskazuje parametr size.
fetchall ()	Ta procedura pobiera wszystkie (pozostałe) wiersze wyniku zapytania, zwracając listę. W przypadku braku dostępnych wierszy zwracana jest pusta lista.

Nieruchomości

Poniżej przedstawiono właściwości klasy Cursor -

metoda	Opis
arraySize	Jest to właściwość do odczytu / zapisu, w której można ustawić liczbę wierszy zwracanych przez metodę fetchmany ().
opis	Jest to właściwość tylko do odczytu, która zwraca listę zawierającą opis kolumn w zestawie wyników.
lastrowid	Jest to właściwość tylko do odczytu, jeśli w tabeli znajdują się jakiekolwiek automatycznie zwiększane kolumny, zwraca wartość wygenerowaną dla tej kolumny w ostatniej operacji INSERT lub UPDATE.
Liczba wierszy	Zwraca liczbę wierszy zwróconych / zaktualizowanych w przypadku operacji SELECT i UPDATE.
połączenie	Ten atrybut tylko do odczytu zapewnia połączenie z bazą danych SQLite używane przez obiekt Cursor.