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