Python SQLite - Hızlı Kılavuz

SQLite3, Gerhard Haring tarafından yazılan sqlite3 modülü kullanılarak Python ile entegre edilebilir. PEP 249 tarafından açıklanan DB-API 2.0 spesifikasyonu ile uyumlu bir SQL arayüzü sağlar. Varsayılan olarak Python sürüm 2.5.x ile birlikte gönderildiği için bu modülü ayrı olarak kurmanıza gerek yoktur.

Sqlite3 modülünü kullanmak için, önce veritabanını temsil eden bir bağlantı nesnesi oluşturmanız ve ardından isteğe bağlı olarak tüm SQL ifadelerini çalıştırmanıza yardımcı olacak bir imleç nesnesi oluşturabilirsiniz.

Python SQLite3 Modülü API'leri

Aşağıda, Python programınızdan SQLite veritabanı ile çalışma gereksiniminizi karşılayabilecek önemli sqlite3 modül rutinleri verilmiştir. Daha karmaşık bir uygulama arıyorsanız, Python sqlite3 modülünün resmi belgelerine bakabilirsiniz.

Sr.No. API ve Açıklama
1

sqlite3.connect(database [,timeout ,other optional arguments])

Bu API, SQLite veritabanı dosyasına bir bağlantı açar. Disk yerine RAM'de bulunan bir veritabanına veritabanı bağlantısı açmak için ": memory:" kullanabilirsiniz. Veritabanı başarıyla açılırsa, bir bağlantı nesnesi döndürür.

2

connection.cursor([cursorClass])

Bu rutin, Python ile veritabanı programlamanız boyunca kullanılacak bir imleç oluşturur. Bu yöntem, tek bir isteğe bağlı parametre cursorClass'ı kabul eder. Sağlanmışsa, bu, sqlite3.Cursor'u genişleten özel bir imleç sınıfı olmalıdır.

3

cursor.execute(sql [, optional parameters])

Bu rutin bir SQL ifadesi yürütür. SQL ifadesi parametreleştirilebilir (yani SQL değişmezleri yerine yer tutucular). Sqlite3 modülü iki tür yer tutucuyu destekler: soru işaretleri ve adlandırılmış yer tutucular (stil olarak adlandırılmış).

For example - cursor.execute ("kişi değerlerine ekle (?,?)", (Kim, yaş))

4

connection.execute(sql [, optional parameters])

Bu rutin, imleç nesnesi tarafından sağlanan yukarıdaki yürütme yönteminin bir kısayoludur ve imleç yöntemini çağırarak bir ara imleç nesnesi oluşturur, ardından verilen parametrelerle imleç yürütme yöntemini çağırır.

5

cursor.executemany(sql, seq_of_parameters)

Bu rutin, sql dizisinde bulunan tüm parametre dizileri veya eşlemelerine karşı bir SQL komutu yürütür.

6

connection.executemany(sql[, parameters])

Bu rutin, imleç yöntemini çağırarak bir ara imleç nesnesi oluşturan ve ardından verilen parametrelerle cursor.s execemany yöntemini çağıran bir kısayoldur.

7

cursor.executescript(sql_script)

Bu rutin, komut dosyası biçiminde sağlanan birden çok SQL ifadesini aynı anda yürütür. Önce bir COMMIT deyimi yayınlar, ardından bir parametre olarak aldığı SQL betiğini çalıştırır. Tüm SQL ifadeleri noktalı virgül (;) ile ayrılmalıdır.

8

connection.executescript(sql_script)

Bu rutin, imleç yöntemini çağırarak bir ara imleç nesnesi oluşturan ve ardından verilen parametrelerle imlecin yürütme komutunu çağıran bir kısayoldur.

9

connection.total_changes()

Bu rutin, veritabanı bağlantısı açıldıktan sonra değiştirilen, eklenen veya silinen veritabanı satırlarının toplam sayısını döndürür.

10

connection.commit()

Bu yöntem, mevcut işlemi taahhüt eder. Bu yöntemi çağırmazsanız, son commit () çağrısından sonra yaptığınız hiçbir şey diğer veritabanı bağlantılarından görünmez.

11

connection.rollback()

Bu yöntem, son commit () çağrısından bu yana veritabanında yapılan değişiklikleri geri alır.

12

connection.close()

Bu yöntem, veritabanı bağlantısını kapatır. Bunun otomatik olarak commit () öğesini çağırmadığını unutmayın. İlk önce commit () 'i çağırmadan veritabanı bağlantınızı kapatırsanız, değişiklikleriniz kaybolacak!

13

cursor.fetchone()

Bu yöntem, bir sorgu sonuç kümesinin sonraki satırını getirir, tek bir sıra döndürür veya daha fazla veri olmadığında Hiçbiri döndürür.

14

cursor.fetchmany([size = cursor.arraysize])

Bu rutin, bir sorgu sonucunun sonraki satır kümesini getirerek bir liste döndürür. Başka satır kalmadığında boş bir liste döndürülür. Yöntem, size parametresinin belirttiği kadar çok satırı getirmeye çalışır.

15

cursor.fetchall()

Bu rutin, bir sorgu sonucunun tüm (kalan) satırlarını alır ve bir liste döndürür. Kullanılabilir satır olmadığında boş bir liste döndürülür.

SQLite Open komut istemi ile bağlantı kurmak için, SQLite'i kurduğunuz yere göz atın ve sadece komutu çalıştırın. sqlite3 aşağıda gösterildiği gibi -

Python Kullanarak Bağlantı Kurmak

SQLite3 python modülünü kullanarak SQLite2 veritabanı ile iletişim kurabilirsiniz. Bunu yapmak için öncelikle bir bağlantı kurmanız gerekir (bir bağlantı nesnesi oluşturun).

Python kullanarak SQLite3 veritabanıyla bağlantı kurmak için yapmanız gerekenler -

  • İmport deyimini kullanarak sqlite3 modülünü içe aktarın.

  • Connect () yöntemi, bağlanmanız gereken veritabanının adını bir parametre olarak kabul eder ve bir Connection nesnesi döndürür.

Misal

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

Çıktı

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

SQLite CREATE TABLE deyimini kullanarak bir veritabanında bir tablo oluşturabilirsiniz.

Sözdizimi

Aşağıda, SQLite veritabanında bir tablo oluşturmak için sözdizimi verilmiştir -

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

Misal

SQLite sorgusunun / ifadesinin ardından, adı olan bir tablo oluşturulur CRICKETERS SQLite veritabanında -

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

CRICKETERS tablosundaki her oyuncunun Bir günlük kriket istatistiklerini açıklayan bir OdiStats tablosu daha oluşturalım.

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

SQLite veritabanındaki bir veritabanındaki tabloların listesini, .tableskomut. Bir tablo oluşturduktan sonra, tabloların listesini doğrulayabilirseniz, içinde yeni oluşturulan tabloyu şu şekilde gözlemleyebilirsiniz:

sqlite> . tables
CRICKETERS ODIStats
sqlite>

Python Kullanarak Tablo Oluşturma

Cursor nesnesi, sorguları yürütmek ve verileri almak vb. İçin tüm yöntemleri içerir. Bağlantı sınıfının imleç yöntemi bir imleç nesnesi döndürür.

Bu nedenle, python kullanarak SQLite veritabanında bir tablo oluşturmak için -

  • Connect () yöntemini kullanarak bir veritabanıyla bağlantı kurun.

  • Yukarıda oluşturulan bağlantı nesnesinde cursor () yöntemini çağırarak bir imleç nesnesi oluşturun.

  • Şimdi Cursor sınıfının execute () yöntemini kullanarak CREATE TABLE deyimini çalıştırın.

Misal

Aşağıdaki Python programı SQLite3'te Employee adlı bir tablo oluşturur -

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

Çıktı

Table created successfully........

INSERT INTO deyimini kullanarak mevcut bir SQLite tablosuna yeni satırlar ekleyebilirsiniz. Bunda, tablonun adını, sütun adlarını ve değerleri (sütun adlarıyla aynı sırada) belirtmeniz gerekir.

Sözdizimi

INSERT ifadesinin önerilen sözdizimi aşağıdadır -

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

Burada, sütun1, sütun2, sütun3, .. bir tablonun sütunlarının adlarıdır ve değer1, değer2, değer3, ... tabloya eklemeniz gereken değerlerdir.

Misal

Aşağıda gösterildiği gibi CREATE TABLE ifadesini kullanarak CRICKETERS adlı bir tablo oluşturduğumuzu varsayalım -

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

Aşağıdaki PostgreSQL ifadesi, yukarıda oluşturulan tabloya bir satır ekler.

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

INSERT INTO deyimini kullanarak kayıt eklerken , herhangi bir sütun adını atlarsanız, bu kayıt atladığınız sütunlarda boşluk bırakılarak eklenecektir.

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

Ayrıca, ilettiğiniz değerlerin sırası tablodaki ilgili sütun adlarıyla aynıysa, sütun adlarını belirtmeden de tabloya kayıt ekleyebilirsiniz.

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>

Kayıtları bir tabloya ekledikten sonra, aşağıda gösterildiği gibi SELECT deyimini kullanarak içeriğini doğrulayabilirsiniz -

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>

Python Kullanarak Veri Ekleme

SQLite veritabanında mevcut bir tabloya kayıt eklemek için -

  • Sqlite3 paketini içe aktarın.

  • Veritabanının adını bir parametre olarak ona ileterek connect () yöntemini kullanarak bir bağlantı nesnesi oluşturun.

  • cursor()yöntem, SQLite3 ile iletişim kurabileceğiniz bir imleç nesnesi döndürür. (Yukarıda oluşturulan) Connection nesnesinde cursor () nesnesini çağırarak bir imleç nesnesi oluşturun.

  • Ardından, imleç nesnesinde bir INSERT ifadesini parametre olarak ileterek execute () yöntemini çağırın.

Misal

Aşağıdaki python örneği, EMPLOYEE adlı bir tabloya kayıtları ekler -

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

Çıktı

Records inserted........

SELECT sorgusunu kullanarak bir SQLite tablosundan veri alabilirsiniz. Bu sorgu / ifade, belirtilen ilişkinin (tablo) içeriğini tablo biçiminde döndürür ve sonuç kümesi olarak adlandırılır.

Sözdizimi

Aşağıda, SQLite'daki SELECT ifadesinin sözdizimi verilmiştir -

SELECT column1, column2, columnN FROM table_name;

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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>

Aşağıdaki SELECT sorgusu, CRICKETERS tablosundan FIRST_NAME, LAST_NAME ve COUNTRY sütunlarının değerlerini alır.

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>

Gözlemlediğiniz gibi, SQLite veritabanının SELECT deyimi yalnızca belirtilen tabloların kayıtlarını döndürür. Biçimlendirilmiş bir çıktı elde etmek için,header, ve mode aşağıda gösterildiği gibi SELECT ifadesinden önce ilgili komutları kullanarak -

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

Her kaydın tüm sütunlarını geri almak istiyorsanız, aşağıda gösterildiği gibi sütunların adlarını "*" ile değiştirmeniz gerekir -

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>

Gelen SQLite'ta varsayılan sütun genişliği doğranır genişliği bunun ötesinde 10 değerleri (2 ülke sütun gözlenir nd yukarıdaki tabloda satır). Her bir sütunun genişliğini gerekli değere ayarlayabilirsiniz..width komutu, aşağıda gösterildiği gibi bir tablonun içeriğini almadan önce -

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>

Python Kullanarak Verileri Alma

Herhangi bir veritabanı üzerinde READ İşlemi, veritabanından bazı yararlı bilgileri almak anlamına gelir. Sqlite python modülü tarafından sağlanan fetch () yöntemini kullanarak MYSQL'den veri alabilirsiniz.

Sqlite3.Cursor sınıfı, fetchall (), fetchmany () ve fetchone () olmak üzere üç yöntem sağlar;

  • Fetchall () yöntemi, bir sorgunun sonuç kümesindeki tüm satırları alır ve bunları demetler listesi olarak döndürür. (Bunu birkaç satırı aldıktan sonra yürütürsek, kalanları döndürür).

  • Fetchone () yöntemi, bir sorgunun sonucundaki sonraki satırı getirir ve bunu bir demet olarak döndürür.

  • Fetchmany () yöntemi fetchone () yöntemine benzer, ancak tek bir satır yerine bir sorgunun sonuç kümesindeki sonraki satır kümesini alır.

Note - Sonuç kümesi, bir tabloyu sorgulamak için bir imleç nesnesi kullanıldığında döndürülen bir nesnedir.

Misal

Aşağıdaki örnek, EMPLOYEE tablosunun tüm satırlarını SELECT sorgusunu kullanarak ve başlangıçta elde edilen sonuç kümesinden alır, fetchone () yöntemini kullanarak ilk satırı alıyoruz ve ardından fetchall () yöntemini kullanarak kalan satırları alıyoruz.

Aşağıdaki Python programı, yukarıdaki örnekte oluşturulan COMPANY tablosundaki kayıtların nasıl getirileceğini ve görüntüleneceğini gösterir.

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

Çıktı

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

SQLite'deki bir tablonun belirli satırlarını getirmek, silmek veya güncellemek istiyorsanız, işlem için tablonun satırlarını filtrelemek için koşul belirtmek üzere where cümlesini kullanmanız gerekir.

Örneğin, where cümlesine sahip bir SELECT deyiminiz varsa, yalnızca belirtilen koşulu karşılayan satırlar alınacaktır.

Sözdizimi

Aşağıda SQLite'daki WHERE cümlesinin sözdizimi verilmiştir -

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

Karşılaştırma veya mantıksal işleçleri kullanarak bir search_condition belirtebilirsiniz. >, <, =, LIKE, NOT, vb. gibi. Aşağıdaki örnekler bu kavramı açıklığa kavuşturacaktır.

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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>

Aşağıdaki SELECT deyimi, yaşı 35'ten büyük olan kayıtları alır -

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>

Python Kullanan Cümle

Cursor nesnesi / sınıfı, sorguları yürütmek ve verileri almak vb. İçin tüm yöntemleri içerir. Bağlantı sınıfının cursor yöntemi bir imleç nesnesi döndürür.

Bu nedenle, python kullanarak SQLite veritabanında bir tablo oluşturmak için -

  • Connect () yöntemini kullanarak bir veritabanıyla bağlantı kurun.

  • Yukarıda oluşturulan bağlantı nesnesinde cursor () yöntemini çağırarak bir imleç nesnesi oluşturun.

  • Şimdi Cursor sınıfının execute () yöntemini kullanarak CREATE TABLE deyimini çalıştırın.

Misal

Aşağıdaki örnek, Employee adında bir tablo oluşturur ve onu doldurur. Daha sonra where cümlesini kullanarak yaş değeri 23'ten küçük olan kayıtları alır.

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

Çıktı

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

SELECT sorgusunu kullanarak verileri alırken, kayıtları eklediğiniz sırayla alırsınız.

Kullanarak sonuçları istediğiniz sırada (artan veya azalan) sıralayabilirsiniz. Order Byfıkra. Varsayılan olarak, bu cümle, sonuçları artan sırada sıralar, eğer onları azalan sırada düzenlemeniz gerekiyorsa, açıkça "DESC" kullanmanız gerekir.

Sözdizimi

Aşağıda, SQLite'daki ORDER BY yan tümcesinin sözdizimi verilmiştir.

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

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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>

Aşağıdaki SELECT ifadesi, CRICKETERS tablosunun satırlarını yaşlarının artan sırasına göre alır -

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>

Bir tablonun kayıtlarını sıralamak için birden fazla sütun kullanabilirsiniz. Aşağıdaki SELECT ifadeleri, CRICKETERS tablosunun kayıtlarını AGE ve FIRST_NAME sütunlarına göre sıralar .

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>

Varsayılan olarak, ORDER BY cümleci, bir tablonun kayıtlarını artan sırada sıralar, DESC kullanarak sonuçları azalan sırada düzenleyebilirsiniz.

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>

Python Kullanarak Maddeye Göre SİPARİŞ

Bir tablonun içeriğini belirli bir sırayla almak için, imleç nesnesinde execute () yöntemini çağırın ve SELECT deyimini ORDER BY yan tümcesi ile birlikte ona bir parametre olarak iletin.

Misal

Aşağıdaki örnekte, ad ve Çalışan ile bir tablo oluşturuyoruz, onu dolduruyoruz ve ORDER BY deyimini kullanarak kayıtlarını yaşlarına göre (artan) sırayla geri alıyoruz.

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

Çıktı

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

GÜNCELLEME Herhangi bir veritabanı üzerinde işlem, veritabanında zaten mevcut olan bir tablonun bir veya daha fazla kaydının değerlerinin değiştirilmesi anlamına gelir. UPDATE deyimini kullanarak SQLite'daki mevcut kayıtların değerlerini güncelleyebilirsiniz.

Belirli satırları güncellemek için, onunla birlikte WHERE yan tümcesini kullanmanız gerekir.

Sözdizimi

Aşağıda, SQLite'daki UPDATE ifadesinin sözdizimi verilmiştir -

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

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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>

Aşağıdaki Açıklama, ilk adı olan kriket oyuncunun yaşını değiştirir. Shikhar -

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

FIRST_NAME Şikhar olan kaydı alırsanız, yaş değerinin 45 olarak değiştirildiğini görürsünüz -

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

Kullanmadıysanız, tüm kayıtların WHERE yan tümcesi değerleri güncellenecektir. UPDATE ifadesinin ardından, CRICKETERS tablosundaki tüm kayıtların yaşı 1 artar -

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

SELECT komutunu kullanarak tablonun içeriğini alırsanız, güncellenmiş değerleri şu şekilde görebilirsiniz -

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>

Python Kullanarak Mevcut Kayıtları Güncelleme

SQLite veritabanında mevcut bir tabloya kayıt eklemek için -

  • Sqlite3 paketini içe aktarın.

  • Veritabanının adını bir parametre olarak ona ileterek connect () yöntemini kullanarak bir bağlantı nesnesi oluşturun.

  • cursor()yöntem, SQLite3 ile iletişim kurabileceğiniz bir imleç nesnesi döndürür. (Yukarıda oluşturulan) Connection nesnesinde cursor () nesnesini çağırarak bir imleç nesnesi oluşturun.

  • Ardından, imleç nesnesinde bir UPDATE deyimini parametre olarak ileterek execute () yöntemini çağırın.

Misal

Python örneğini takiben, EMPLOYEE adında bir tablo oluşturur, içine 5 kayıt ekler ve tüm erkek çalışanların yaşını 1 artırır -

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

Çıktı

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

Kayıtları bir SQLite tablosundan silmek için DELETE FROM deyimini kullanmanız gerekir. Belirli kayıtları kaldırmak için, onunla birlikte WHERE cümlesini kullanmanız gerekir.

Sözdizimi

Aşağıda, SQLite'daki DELETE sorgusunun sözdizimi verilmiştir -

DELETE FROM table_name [WHERE Clause]

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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>

Aşağıdaki açıklama, soyadı 'Sangakkara' olan kriketçinin rekorunu siliyor.

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

SELECT deyimini kullanarak tablonun içeriğini alırsanız, birini sildiğimiz için yalnızca 4 kaydı görebilirsiniz.

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>

DELETE FROM deyimini WHERE yan tümcesi olmadan çalıştırırsanız, belirtilen tablodaki tüm kayıtlar silinecektir.

sqlite> DELETE FROM CRICKETERS;
sqlite>

Tüm kayıtları sildiğiniz için, CRICKETERS tablosunun içeriğini almaya çalışırsanız, SELECT deyimini kullanarak aşağıda gösterildiği gibi boş bir sonuç kümesi alırsınız -

sqlite> SELECT * FROM CRICKETERS;
sqlite>

Python Kullanarak Verileri Silme

SQLite veritabanında mevcut bir tabloya kayıt eklemek için -

  • Sqlite3 paketini içe aktarın.

  • Veritabanının adını bir parametre olarak ona ileterek connect () yöntemini kullanarak bir bağlantı nesnesi oluşturun .

  • cursor()yöntem, SQLite3 ile iletişim kurabileceğiniz bir imleç nesnesi döndürür. (Yukarıda oluşturulan) Connection nesnesinde cursor () nesnesini çağırarak bir imleç nesnesi oluşturun.

  • Ardından, imleç nesnesinde execute () yöntemini bir DELETE bir parametre olarak ifade.

Misal

Aşağıdaki python örneği, EMPLOYEE tablosundaki 25'den büyük yaş değerine sahip kayıtları siler.

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

Çıktı

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

DROP TABLE deyimini kullanarak tüm tabloyu kaldırabilirsiniz. Silmeniz gereken tablonun adını belirtmeniz yeterlidir.

Sözdizimi

PostgreSQL'de DROP TABLE deyiminin sözdizimi aşağıdadır -

DROP TABLE table_name;

Misal

Aşağıdaki sorguları kullanarak CRICKETERS ve EMPLOYEES adında iki tablo oluşturduğumuzu varsayalım -

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>

Şimdi, tablo listesini kullanarak doğrularsanız .tables komut, yukarıda oluşturulan tabloları içinde (liste) olarak görebilirsiniz -

sqlite> .tables
CRICKETERS EMPLOYEE
sqlite>

Aşağıdaki ifade, Employee adlı tabloyu veritabanından siler -

sqlite> DROP table employee;
sqlite>

Çalışan tablosunu sildiğiniz için, tabloların listesini yeniden alırsanız, içinde yalnızca bir tablo görebilirsiniz.

sqlite> .tables
CRICKETERS
sqlite>

Çalışan tablosunu tekrar silmeye çalışırsanız, zaten silmiş olduğunuz için aşağıda gösterildiği gibi "böyle bir tablo yok" diyen bir hata alırsınız -

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

Bunu çözmek için, DELETE ifadesiyle birlikte IF EXISTS yan tümcesini kullanabilirsiniz. Bu, varsa tabloyu kaldırır, aksi takdirde DELETE işlemini atlar.

sqlite> DROP table IF EXISTS employee;
sqlite>

Python Kullanarak Tablo Bırakma

MYSQL'in DROP ifadesini kullanarak bir tabloyu istediğiniz zaman bırakabilirsiniz, ancak mevcut tabloyu silerken çok dikkatli olmalısınız çünkü bir tablo silindikten sonra kaybolan veriler kurtarılmayacaktır.

Misal

Python kullanarak bir SQLite3 veritabanından bir tablo bırakmak için execute() yöntemini imleç nesnesine yerleştirin ve drop deyimini bir parametre olarak ona iletin.

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

Çıktı

Table dropped...

Kayıtları alırken belirli bir sayı ile sınırlandırmak istiyorsanız, SQLite'ın LIMIT tümcesini kullanarak bunu yapabilirsiniz.

Sözdizimi

Aşağıda, SQLite'daki LIMIT cümlesinin sözdizimi verilmiştir -

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

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

Ve INSERT ifadelerini kullanarak 5 kayıt eklediysek -

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>

Aşağıdaki ifade, LIMIT cümlesini kullanarak Cricketers tablosunun ilk 3 kaydını alır -

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>

Eğer n'inci kaydı (değil 1 başlayarak kayıtları sınırlamak gerekirse st ) kullanarak, LIMIT birlikte OFFSET kullanarak, bunu yapabilirsiniz.

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>

Python Kullanan LIMIT Maddesi

SELECT sorgusunu LIMIT yan tümcesi ile ileterek imleç nesnesinde execute () yöntemini çağırırsanız, gerekli sayıda kaydı alabilirsiniz.

Misal

Aşağıdaki python örneği, LIMIT deyimini kullanarak EMPLOYEE tablosunun ilk iki kaydını alır.

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

Çıktı

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

Verileri iki tabloya böldüğünüzde, bu iki tablodan Birleşik kayıtları Birleştir seçeneğini kullanarak alabilirsiniz.

Misal

Aşağıdaki sorguyu kullanarak CRICKETERS adında bir tablo oluşturduğumuzu varsayalım -

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

CRICKETERS tablosundaki her oyuncunun Bir günlük kriket istatistiklerini açıklayan bir OdiStats tablosu daha oluşturalım.

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

Aşağıdaki ifade, bu iki tablodaki değerleri birleştiren verileri alır -

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>

Python Kullanarak Maddeye Katıl

Aşağıdaki SQLite örneğini, python kullanarak JOIN cümlesini gösterir -

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

Çıktı

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

Sqlite3.Cursor sınıfı, SQLite deyimlerini yürüten, sorguların sonuç kümelerinden veri alan yöntemleri çağırabileceğiniz bir örnektir. Connection nesnesinin / sınıfının cursor () yöntemini kullanarak Cursor nesnesini oluşturabilirsiniz.

Misal

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

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

Yöntemler

Aşağıdakiler, Cursor sınıfı / nesnesi tarafından sağlanan çeşitli yöntemlerdir.

Yöntem Açıklama
execute ()

Bu rutin bir SQL ifadesi yürütür. SQL ifadesi parametreleştirilebilir (yani SQL değişmezleri yerine yer tutucular). Psycopg2 modülü,% s işaretini kullanan yer tutucuyu destekler

Örneğin: cursor.execute ("kişi değerlerine ekle (% s,% s)", (kim, yaş))

execemany ()

Bu rutin, sql dizisinde bulunan tüm parametre dizileri veya eşlemelerine karşı bir SQL komutu yürütür.

fetchone ()

Bu yöntem, bir sorgu sonuç kümesinin sonraki satırını getirir, tek bir sıra döndürür veya daha fazla veri olmadığında Hiçbiri döndürür.

fetchmany ()

Bu rutin, bir sorgu sonucunun sonraki satır kümesini getirerek bir liste döndürür. Başka satır kalmadığında boş bir liste döndürülür. Yöntem, size parametresinin belirttiği kadar çok satırı getirmeye çalışır.

fetchall ()

Bu rutin, bir sorgu sonucunun tüm (kalan) satırlarını alır ve bir liste döndürür. Kullanılabilir satır olmadığında boş bir liste döndürülür.

Özellikleri

Aşağıdakiler Cursor sınıfının özellikleridir -

Yöntem Açıklama
arraySize

Bu, fetchmany () yöntemi tarafından döndürülen satır sayısını ayarlayabileceğiniz bir okuma / yazma özelliğidir.

açıklama

Bu, bir sonuç kümesindeki sütunların açıklamasını içeren listeyi döndüren salt okunur bir özelliktir.

son kalabalık

Bu salt okunur bir özelliktir, tabloda otomatik olarak artan sütunlar varsa, bu son INSERT veya UPDATE işleminde o sütun için oluşturulan değeri döndürür.

Rowcount

Bu, SELECT ve UPDATE işlemleri durumunda döndürülen / güncellenen satır sayısını döndürür.

bağ

Bu salt okunur öznitelik, Cursor nesnesi tarafından kullanılan SQLite veritabanı Bağlantısını sağlar.