SQLite - Panduan Cepat
Bab ini membantu Anda memahami apa itu SQLite, apa bedanya dengan SQL, mengapa ia dibutuhkan dan cara ia menangani database aplikasi.
SQLite adalah pustaka perangkat lunak yang mengimplementasikan mesin database SQL transaksional, tanpa server, tanpa konfigurasi, dan mandiri. SQLite adalah salah satu mesin database yang tumbuh paling cepat, tetapi itu pertumbuhan dalam hal popularitas, tidak ada hubungannya dengan ukurannya. Kode sumber untuk SQLite ada di domain publik.
Apa itu SQLite?
SQLite adalah pustaka dalam proses yang mengimplementasikan mesin database SQL transaksional, tanpa server, tanpa konfigurasi, dan mandiri. Ini adalah database, yang tidak dikonfigurasi-nol, yang berarti seperti database lain Anda tidak perlu mengkonfigurasinya di sistem Anda.
Mesin SQLite bukanlah proses yang berdiri sendiri seperti database lain, Anda dapat menautkannya secara statis atau dinamis sesuai kebutuhan Anda dengan aplikasi Anda. SQLite mengakses file penyimpanannya secara langsung.
Mengapa SQLite?
SQLite tidak memerlukan proses atau sistem server terpisah untuk beroperasi (tanpa server).
SQLite hadir dengan konfigurasi nol, yang berarti tidak diperlukan pengaturan atau administrasi.
Basis data SQLite lengkap disimpan dalam satu file disk lintas platform.
SQLite sangat kecil dan ringan, kurang dari 400KiB terkonfigurasi penuh atau kurang dari 250KiB dengan fitur opsional dihilangkan.
SQLite bersifat mandiri, yang berarti tidak ada dependensi eksternal.
Transaksi SQLite sepenuhnya sesuai dengan ACID, memungkinkan akses yang aman dari beberapa proses atau utas.
SQLite mendukung sebagian besar fitur bahasa kueri yang ditemukan dalam standar SQL92 (SQL2).
SQLite ditulis dalam ANSI-C dan menyediakan API yang sederhana dan mudah digunakan.
SQLite tersedia di UNIX (Linux, Mac OS-X, Android, iOS) dan Windows (Win32, WinCE, WinRT).
SQLite Sejarah Singkat
2000 - D. Richard Hipp mendesain SQLite untuk tujuan tanpa administrasi yang diperlukan untuk mengoperasikan program.
2000 - Pada bulan Agustus, SQLite 1.0 dirilis dengan GNU Database Manager.
2011 - Hipp mengumumkan untuk menambahkan antarmuka UNQl ke SQLite DB dan untuk mengembangkan UNQLite (Database berorientasi dokumen).
Batasan SQLite
Ada beberapa fitur SQL92 yang tidak didukung di SQLite yang didaftar di dalam tabel berikut.
| Sr.No. | Fitur & Deskripsi |
|---|---|
| 1 | RIGHT OUTER JOIN Hanya LEFT OUTER JOIN yang diterapkan. |
| 2 | FULL OUTER JOIN Hanya LEFT OUTER JOIN yang diterapkan. |
| 3 | ALTER TABLE Varian RENAME TABLE dan ADD COLUMN dari perintah ALTER TABLE didukung. DROP COLUMN, ALTER COLUMN, ADD CONSTRAINT tidak didukung. |
| 4 | Trigger support UNTUK SETIAP pemicu ROW didukung tetapi tidak UNTUK SETIAP pemicu PERNYATAAN. |
| 5 | VIEWs TAMPILAN di SQLite bersifat hanya baca. Anda tidak dapat menjalankan pernyataan DELETE, INSERT, atau UPDATE pada tampilan. |
| 6 | GRANT and REVOKE Satu-satunya izin akses yang dapat diterapkan adalah izin akses file normal dari sistem operasi yang mendasarinya. |
Perintah SQLite
Perintah SQLite standar untuk berinteraksi dengan database relasional mirip dengan SQL. Mereka adalah CREATE, SELECT, INSERT, UPDATE, DELETE dan DROP. Perintah-perintah ini dapat diklasifikasikan ke dalam kelompok berdasarkan sifat operasionalnya -
DDL - Bahasa Definisi Data
| Sr.No. | Perintah & Deskripsi |
|---|---|
| 1 | CREATE Membuat tabel baru, tampilan tabel, atau objek lain dalam database. |
| 2 | ALTER Mengubah objek database yang sudah ada, seperti tabel. |
| 3 | DROP Menghapus seluruh tabel, tampilan tabel atau objek lain dalam database. |
DML - Bahasa Manipulasi Data
| Sr.No. | Perintah & Deskripsi |
|---|---|
| 1 | INSERT Membuat rekor |
| 2 | UPDATE Mengubah catatan |
| 3 | DELETE Menghapus catatan |
DQL - Bahasa Kueri Data
| Sr.No. | Perintah & Deskripsi |
|---|---|
| 1 | SELECT Mengambil rekaman tertentu dari satu atau beberapa tabel |
SQLite terkenal dengan fitur zero-configuration yang hebat, yang berarti tidak diperlukan pengaturan atau administrasi yang rumit. Bab ini akan memandu Anda melalui proses penyiapan SQLite di Windows, Linux, dan Mac OS X.
Instal SQLite di Windows
Step 1- Buka halaman unduh SQLite , dan unduh binari yang telah dikompilasi dari bagian Windows.
Step 2 - Unduh file zip sqlite-shell-win32 - *. Zip dan sqlite-dll-win32 - * .zip.
Step 3 - Buat folder C: \> sqlite dan unzip di atas dua file zip di folder ini, yang akan memberi Anda file sqlite3.def, sqlite3.dll dan sqlite3.exe.
Step 4 - Tambahkan C: \> sqlite di variabel lingkungan PATH Anda dan terakhir buka command prompt dan keluarkan perintah sqlite3, yang akan menampilkan hasil berikut.
C:\>sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>Instal SQLite di Linux
Saat ini, hampir semua versi OS Linux dikirimkan dengan SQLite. Jadi Anda cukup mengeluarkan perintah berikut untuk memeriksa apakah Anda sudah menginstal SQLite di mesin Anda.
$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>Jika Anda tidak melihat hasil di atas, berarti Anda tidak menginstal SQLite di mesin Linux Anda. Berikut adalah langkah-langkah berikut untuk menginstal SQLite -
Step 1- Buka halaman unduh SQLite dan unduh sqlite-autoconf - *. Tar.gz dari bagian kode sumber.
Step 2 - Jalankan perintah berikut -
$tar xvfz sqlite-autoconf-3071502.tar.gz
$cd sqlite-autoconf-3071502 $./configure --prefix=/usr/local
$make $make installPerintah di atas akan diakhiri dengan instalasi SQLite di mesin Linux Anda. Yang dapat Anda verifikasi seperti yang dijelaskan di atas.
Instal SQLite di Mac OS X
Meskipun versi terbaru Mac OS X sudah diinstal sebelumnya dengan SQLite tetapi jika Anda tidak memiliki instalasi yang tersedia, ikuti saja langkah-langkah berikut ini -
Step 1- Buka halaman unduh SQLite , dan unduh sqlite-autoconf - *. Tar.gz dari bagian kode sumber.
Step 2 - Jalankan perintah berikut -
$tar xvfz sqlite-autoconf-3071502.tar.gz $cd sqlite-autoconf-3071502
$./configure --prefix=/usr/local $make
$make installProsedur di atas akan diakhiri dengan penginstalan SQLite di mesin Mac OS X Anda. Yang dapat Anda verifikasi dengan mengeluarkan perintah berikut -
$sqlite3
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>Terakhir, Anda memiliki command prompt SQLite di mana Anda dapat mengeluarkan perintah SQLite untuk latihan Anda.
Bab ini akan memandu Anda melalui perintah sederhana dan berguna yang digunakan oleh programmer SQLite. Perintah ini disebut perintah titik SQLite dan pengecualian dengan perintah ini adalah perintah tersebut tidak boleh diakhiri dengan titik koma (;).
Mari kita mulai dengan mengetik yang sederhana sqlite3 perintah pada prompt perintah yang akan memberi Anda prompt perintah SQLite di mana Anda akan mengeluarkan berbagai perintah SQLite.
$sqlite3
SQLite version 3.3.6
Enter ".help" for instructions
sqlite>Untuk daftar perintah titik yang tersedia, Anda dapat memasukkan ".help" kapan saja. Misalnya -
sqlite>.helpPerintah di atas akan menampilkan daftar berbagai perintah titik SQLite penting, yang tercantum dalam tabel berikut.
| Sr.No. | Perintah & Deskripsi |
|---|---|
| 1 | .backup ?DB? FILE Cadangkan DB (default "utama") ke FILE |
| 2 | .bail ON|OFF Berhenti setelah terjadi kesalahan. Default NONAKTIF |
| 3 | .databases Buat daftar nama dan file dari database terlampir |
| 4 | .dump ?TABLE? Buang database dalam format teks SQL. Jika TABLE ditentukan, hanya dump tabel yang cocok dengan pola LIKE TABLE |
| 5 | .echo ON|OFF Aktifkan atau nonaktifkan gema perintah |
| 6 | .exit Keluar dari perintah SQLite |
| 7 | .explain ON|OFF Aktifkan atau nonaktifkan mode keluaran yang sesuai untuk JELASKAN. Tanpa argumen, ini akan mengaktifkan MENJELASKAN |
| 8 | .header(s) ON|OFF Aktifkan atau nonaktifkan tampilan header |
| 9 | .help Tunjukkan pesan ini |
| 10 | .import FILE TABLE Impor data dari FILE ke TABLE |
| 11 | .indices ?TABLE? Tunjukkan nama semua indeks. Jika TABLE ditentukan, hanya tampilkan indeks untuk tabel yang cocok dengan pola LIKE TABLE |
| 12 | .load FILE ?ENTRY? Muat perpustakaan ekstensi |
| 13 | .log FILE|off Hidupkan atau matikan masuk. FILE bisa stderr / stdout |
| 14 | .mode MODE Atur mode keluaran di mana MODE adalah salah satu dari -
|
| 15 | .nullvalue STRING Cetak STRING sebagai ganti nilai NULL |
| 16 | .output FILENAME Kirim keluaran ke FILENAME |
| 17 | .output stdout Kirim keluaran ke layar |
| 18 | .print STRING... Cetak STRING literal |
| 19 | .prompt MAIN CONTINUE Ganti perintah standar |
| 20 | .quit Keluar dari perintah SQLite |
| 21 | .read FILENAME Jalankan SQL di FILENAME |
| 22 | .schema ?TABLE? Tampilkan pernyataan CREATE. Jika TABLE ditentukan, hanya perlihatkan tabel yang cocok dengan pola LIKE TABLE |
| 23 | .separator STRING Ubah pemisah yang digunakan oleh mode keluaran dan .import |
| 24 | .show Tunjukkan nilai saat ini untuk berbagai pengaturan |
| 25 | .stats ON|OFF Aktifkan atau nonaktifkan statistik |
| 26 | .tables ?PATTERN? Buat daftar nama tabel yang cocok dengan pola LIKE |
| 27 | .timeout MS Coba buka tabel terkunci selama milidetik MS |
| 28 | .width NUM NUM Tetapkan lebar kolom untuk mode "kolom" |
| 29 | .timer ON|OFF Aktifkan atau nonaktifkan pengukuran timer CPU |
Mari mencoba .show perintah untuk melihat pengaturan default untuk prompt perintah SQLite Anda.
sqlite>.show
echo: off
explain: off
headers: off
mode: column
nullvalue: ""
output: stdout
separator: "|"
width:
sqlite>Pastikan tidak ada spasi di antara sqlite> prompt dan perintah titik, jika tidak maka tidak akan berhasil.
Memformat Output
Anda dapat menggunakan urutan perintah titik berikut untuk memformat keluaran Anda.
sqlite>.header on
sqlite>.mode column
sqlite>.timer on
sqlite>Pengaturan di atas akan menghasilkan keluaran dalam format berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
CPU Time: user 0.000000 sys 0.000000Tabel sqlite_master
Tabel master menyimpan informasi utama tentang tabel database Anda dan itu disebut sqlite_master. Anda dapat melihat skemanya sebagai berikut -
sqlite>.schema sqlite_masterIni akan menghasilkan hasil sebagai berikut.
CREATE TABLE sqlite_master (
type text,
name text,
tbl_name text,
rootpage integer,
sql text
);SQLite diikuti oleh seperangkat aturan dan pedoman unik yang disebut Sintaks. Bab ini mencantumkan semua Sintaks SQLite dasar.
Sensitivitas Kasus
Hal penting yang perlu diperhatikan adalah bahwa SQLite adalah case insensitive, yaitu klausul GLOB dan glob memiliki arti yang sama dalam pernyataan SQLite.
Komentar
Komentar SQLite adalah catatan tambahan, yang dapat Anda tambahkan ke kode SQLite untuk meningkatkan keterbacaannya dan dapat muncul di mana saja; spasi dapat muncul, termasuk ekspresi di dalam dan di tengah pernyataan SQL lainnya, tetapi tidak dapat disarangkan.
Komentar SQL dimulai dengan dua karakter "-" yang berurutan (ASCII 0x2d) dan meluas hingga dan termasuk karakter baris baru berikutnya (ASCII 0x0a) atau hingga akhir masukan, mana saja yang lebih dulu.
Anda juga dapat menggunakan komentar gaya-C, yang dimulai dengan "/ *" dan diperluas hingga dan termasuk pasangan karakter "* /" berikutnya atau hingga akhir masukan, mana saja yang lebih dulu. Komentar gaya C dapat mencakup beberapa baris.
sqlite> .help -- This is a single line commentPernyataan SQLite
Semua pernyataan SQLite dimulai dengan salah satu kata kunci seperti SELECT, INSERT, UPDATE, DELETE, ALTER, DROP, dll., Dan semua pernyataan diakhiri dengan titik koma (;).
Pernyataan SQLite ANALYZE
ANALYZE;
or
ANALYZE database_name;
or
ANALYZE database_name.table_name;SQLite DAN / ATAU Klausul
SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION-1 {AND|OR} CONDITION-2;Pernyataan SQLite ALTER TABLE
ALTER TABLE table_name ADD COLUMN column_def...;Pernyataan SQLite ALTER TABLE (Ganti nama)
ALTER TABLE table_name RENAME TO new_table_name;Pernyataan SQLite ATTACH DATABASE
ATTACH DATABASE 'DatabaseName' As 'Alias-Name';Pernyataan SQLite BEGIN TRANSACTION
BEGIN;
or
BEGIN EXCLUSIVE TRANSACTION;Klausul SQLite ANTARA
SELECT column1, column2....columnN
FROM table_name
WHERE column_name BETWEEN val-1 AND val-2;Pernyataan COMMIT SQLite
COMMIT;Pernyataan SQLite CREATE INDEX
CREATE INDEX index_name
ON table_name ( column_name COLLATE NOCASE );Pernyataan SQLite CREATE UNIQUE INDEX
CREATE UNIQUE INDEX index_name
ON table_name ( column1, column2,...columnN);Pernyataan SQLite CREATE TABLE
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);Pernyataan SQLite CREATE TRIGGER
CREATE TRIGGER database_name.trigger_name
BEFORE INSERT ON table_name FOR EACH ROW
BEGIN
stmt1;
stmt2;
....
END;Pernyataan SQLite CREATE VIEW
CREATE VIEW database_name.view_name AS
SELECT statement....;Pernyataan SQLite CREATE VIRTUAL TABLE
CREATE VIRTUAL TABLE database_name.table_name USING weblog( access.log );
or
CREATE VIRTUAL TABLE database_name.table_name USING fts3( );Pernyataan TRANSAKSI KOMIT SQLite
COMMIT;SQLite COUNT Clause
SELECT COUNT(column_name)
FROM table_name
WHERE CONDITION;Pernyataan SQLite DELETE
DELETE FROM table_name
WHERE {CONDITION};Pernyataan SQLite Pisahkan DATABASE
DETACH DATABASE 'Alias-Name';Klausa DISTINCT SQLite
SELECT DISTINCT column1, column2....columnN
FROM table_name;Pernyataan SQLite DROP INDEX
DROP INDEX database_name.index_name;Pernyataan SQLite DROP TABLE
DROP TABLE database_name.table_name;Pernyataan SQLite DROP VIEW
DROP INDEX database_name.view_name;Pernyataan SQLite DROP TRIGGER
DROP INDEX database_name.trigger_name;SQLite EXISTS Clause
SELECT column1, column2....columnN
FROM table_name
WHERE column_name EXISTS (SELECT * FROM table_name );Pernyataan SQLite EXPLAIN
EXPLAIN INSERT statement...;
or
EXPLAIN QUERY PLAN SELECT statement...;Klausul GLOB SQLite
SELECT column1, column2....columnN
FROM table_name
WHERE column_name GLOB { PATTERN };SQLite GROUP BY Klausul
SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name;Klausul SQLite HAVING
SELECT SUM(column_name)
FROM table_name
WHERE CONDITION
GROUP BY column_name
HAVING (arithematic function condition);Pernyataan SQLite INSERT INTO
INSERT INTO table_name( column1, column2....columnN)
VALUES ( value1, value2....valueN);SQLite IN Klausul
SELECT column1, column2....columnN
FROM table_name
WHERE column_name IN (val-1, val-2,...val-N);Seperti Klausa SQLite
SELECT column1, column2....columnN
FROM table_name
WHERE column_name LIKE { PATTERN };SQLite TIDAK DALAM Klausul
SELECT column1, column2....columnN
FROM table_name
WHERE column_name NOT IN (val-1, val-2,...val-N);SQLite ORDER BY Clause
SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION
ORDER BY column_name {ASC|DESC};Pernyataan SQLite PRAGMA
PRAGMA pragma_name;
For example:
PRAGMA page_size;
PRAGMA cache_size = 1024;
PRAGMA table_info(table_name);Pernyataan SQLite RELEASE SAVEPOINT
RELEASE savepoint_name;Pernyataan SQLite REINDEX
REINDEX collation_name;
REINDEX database_name.index_name;
REINDEX database_name.table_name;Pernyataan ROLLBACK SQLite
ROLLBACK;
or
ROLLBACK TO SAVEPOINT savepoint_name;Pernyataan SAVEPOINT SQLite
SAVEPOINT savepoint_name;Pernyataan SQLite SELECT
SELECT column1, column2....columnN
FROM table_name;Pernyataan SQLite UPDATE
UPDATE table_name
SET column1 = value1, column2 = value2....columnN=valueN
[ WHERE CONDITION ];Pernyataan SQLite VACUUM
VACUUM;Klausul WHERE SQLite
SELECT column1, column2....columnN
FROM table_name
WHERE CONDITION;Tipe data SQLite adalah atribut yang menentukan tipe data dari objek apa pun. Setiap kolom, variabel, dan ekspresi memiliki tipe data terkait di SQLite.
Anda akan menggunakan tipe data ini saat membuat tabel Anda. SQLite menggunakan sistem tipe dinamis yang lebih umum. Di SQLite, tipe data suatu nilai dikaitkan dengan nilai itu sendiri, bukan dengan penampungnya.
Kelas Penyimpanan SQLite
Setiap nilai yang disimpan dalam database SQLite memiliki salah satu dari kelas penyimpanan berikut -
| Sr.No. | Kelas & Deskripsi Penyimpanan |
|---|---|
| 1 | NULL Nilainya adalah nilai NULL. |
| 2 | INTEGER Nilainya adalah bilangan bulat bertanda, disimpan dalam 1, 2, 3, 4, 6, atau 8 byte tergantung pada besarnya nilai. |
| 3 | REAL Nilainya adalah nilai floating point, disimpan sebagai angka floating point IEEE 8-byte. |
| 4 | TEXT Nilainya adalah string teks, disimpan menggunakan encoding database (UTF-8, UTF-16BE atau UTF-16LE) |
| 5 | BLOB Nilai adalah sekumpulan data, disimpan persis seperti saat dimasukkan. |
Kelas penyimpanan SQLite sedikit lebih umum daripada tipe data. Kelas penyimpanan INTEGER, misalnya, mencakup 6 tipe data integer berbeda dengan panjang berbeda.
Jenis Afinitas SQLite
SQLite mendukung konsep type affinitydi kolom. Setiap kolom masih dapat menyimpan semua jenis data tetapi kelas penyimpanan yang disukai untuk kolom disebut denganaffinity. Setiap kolom tabel dalam database SQLite3 diberikan salah satu dari afinitas tipe berikut -
| Sr.No. | Afinitas & Deskripsi |
|---|---|
| 1 | TEXT Kolom ini menyimpan semua data menggunakan kelas penyimpanan NULL, TEXT atau BLOB. |
| 2 | NUMERIC Kolom ini mungkin berisi nilai menggunakan semua lima kelas penyimpanan. |
| 3 | INTEGER Berperilaku sama seperti kolom dengan afinitas NUMERIK, dengan pengecualian dalam ekspresi CAST. |
| 4 | REAL Berperilaku seperti kolom dengan afinitas NUMERIK kecuali yang memaksa nilai integer ke representasi floating point. |
| 5 | NONE Kolom dengan afinitas TIDAK ADA yang lebih menyukai satu kelas penyimpanan daripada yang lain dan tidak ada upaya untuk memaksa data dari satu kelas penyimpanan ke kelas lain. |
Nama Jenis dan Afinitas SQLite
Tabel berikut mencantumkan berbagai nama tipe data yang dapat digunakan saat membuat tabel SQLite3 dengan afinitas yang diterapkan terkait.
| Tipe data | Afinitas |
|---|---|
|
BILANGAN BULAT |
|
TEKS |
|
TIDAK ADA |
|
NYATA |
|
NUMERIK |
Jenis Data Boolean
SQLite tidak memiliki kelas penyimpanan Boolean terpisah. Sebagai gantinya, nilai Boolean disimpan sebagai bilangan bulat 0 (salah) dan 1 (benar).
Jenis Data Tanggal dan Waktu
SQLite tidak memiliki kelas penyimpanan terpisah untuk menyimpan tanggal dan / atau waktu, tetapi SQLite mampu menyimpan tanggal dan waktu sebagai nilai TEXT, REAL atau INTEGER.
| Sr.No. | Kelas Penyimpanan & Format Tanggal |
|---|---|
| 1 | TEXT Tanggal dalam format seperti "YYYY-MM-DD HH: MM: SS.SSS" |
| 2 | REAL Jumlah hari sejak tengah hari di Greenwich pada tanggal 24 November 4714 SM |
| 3 | INTEGER Jumlah detik sejak 1970-01-01 00:00:00 UTC |
Anda dapat memilih untuk menyimpan tanggal dan waktu dalam salah satu format ini dan secara bebas mengonversi antar format menggunakan fungsi tanggal dan waktu bawaan.
Di SQLite, sqlite3perintah digunakan untuk membuat database SQLite baru. Anda tidak perlu memiliki hak khusus untuk membuat database.
Sintaksis
Berikut ini adalah sintaks dasar dari perintah sqlite3 untuk membuat database: -
$sqlite3 DatabaseName.dbSelalu, nama database harus unik dalam RDBMS.
Contoh
Jika Anda ingin membuat database baru <testDB.db>, maka pernyataan SQLITE3 adalah sebagai berikut -
$sqlite3 testDB.db
SQLite version 3.7.15.2 2013-01-09 11:53:05
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>Perintah di atas akan membuat file testDB.dbdi direktori saat ini. File ini akan digunakan sebagai database oleh mesin SQLite. Jika Anda perhatikan saat membuat database, perintah sqlite3 akan memberikan filesqlite> prompt setelah membuat file database berhasil.
Setelah database dibuat, Anda dapat memverifikasinya di daftar database menggunakan SQLite berikut .databases perintah.
sqlite>.databases
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.dbAnda akan menggunakan SQLite .quit perintah untuk keluar dari prompt sqlite sebagai berikut -
sqlite>.quit
$Perintah .dump
Kamu dapat memakai .dump dot perintah untuk mengekspor database lengkap dalam file teks menggunakan perintah SQLite berikut pada prompt perintah.
$sqlite3 testDB.db .dump > testDB.sqlPerintah di atas akan mengonversi seluruh konten testDB.db database ke dalam pernyataan SQLite dan membuangnya ke file teks ASCII testDB.sql. Anda dapat melakukan pemulihan dari testDB.sql yang dihasilkan dengan cara sederhana sebagai berikut -
$sqlite3 testDB.db < testDB.sqlSaat ini database Anda kosong, jadi Anda dapat mencoba dua prosedur di atas setelah Anda memiliki beberapa tabel dan data di database Anda. Untuk saat ini, mari kita lanjutkan ke bab berikutnya.
Pertimbangkan kasus ketika Anda memiliki beberapa database yang tersedia dan Anda ingin menggunakan salah satu dari mereka dalam satu waktu. SQLiteATTACH DATABASE pernyataan digunakan untuk memilih database tertentu, dan setelah perintah ini, semua pernyataan SQLite akan dijalankan di bawah database terlampir.
Sintaksis
Berikut ini adalah sintaks dasar pernyataan SQLite ATTACH DATABASE.
ATTACH DATABASE 'DatabaseName' As 'Alias-Name';Perintah di atas juga akan membuat database jika database belum dibuat, selain itu hanya akan melampirkan nama file database dengan database logis 'Alias-Name'.
Contoh
Jika Anda ingin melampirkan database yang sudah ada testDB.db, maka pernyataan Lampirkan DATABASE adalah sebagai berikut -
sqlite> ATTACH DATABASE 'testDB.db' as 'TEST';Gunakan SQLite .database perintah untuk menampilkan database terlampir.
sqlite> .database
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.db
2 test /home/sqlite/testDB.dbNama database main dan tempdicadangkan untuk database utama dan database untuk menampung tabel sementara dan objek data sementara lainnya. Kedua nama database ini ada untuk setiap koneksi database dan tidak boleh digunakan untuk lampiran, jika tidak, Anda akan mendapatkan pesan peringatan berikut.
sqlite> ATTACH DATABASE 'testDB.db' as 'TEMP';
Error: database TEMP is already in use
sqlite> ATTACH DATABASE 'testDB.db' as 'main';
Error: database TEMP is already in useSQLite DETACH DATABASEpernyataan digunakan untuk melepaskan dan memisahkan database bernama dari koneksi database yang sebelumnya dilampirkan menggunakan pernyataan ATTACH. Jika file database yang sama telah dilampirkan dengan beberapa alias, maka perintah DETACH hanya akan memutuskan nama yang diberikan dan sisa lampiran akan tetap berlanjut. Anda tidak dapat melepaskanmain atau temp database.
Jika database adalah database dalam memori atau sementara, database akan dihancurkan dan isinya akan hilang.
Sintaksis
Berikut ini adalah sintaks dasar SQLite Pisahkan pernyataan 'Alias-Name'.
DETACH DATABASE 'Alias-Name';Di sini, 'Alias-Name' adalah alias yang sama, yang Anda gunakan saat melampirkan database menggunakan pernyataan ATTACH.
Contoh
Anggap Anda memiliki database, yang Anda buat di bab sebelumnya dan melampirkannya dengan 'test' dan 'currentDB' seperti yang bisa kita lihat menggunakan .database perintah.
sqlite>.databases
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.db
2 test /home/sqlite/testDB.db
3 currentDB /home/sqlite/testDB.dbMari kita coba melepaskan 'currentDB' dari testDB.db menggunakan perintah berikut.
sqlite> DETACH DATABASE 'currentDB';Sekarang, jika Anda akan memeriksa lampiran saat ini, Anda akan menemukan bahwa testDB.db masih terhubung dengan 'test' dan 'main'.
sqlite>.databases
seq name file
--- --------------- ----------------------
0 main /home/sqlite/testDB.db
2 test /home/sqlite/testDB.dbSQLite CREATE TABLEpernyataan digunakan untuk membuat tabel baru di salah satu database yang diberikan. Membuat tabel dasar melibatkan penamaan tabel dan menentukan kolomnya dan tipe data setiap kolom.
Sintaksis
Berikut ini adalah sintaks dasar dari pernyataan CREATE TABLE.
CREATE TABLE database_name.table_name(
column1 datatype PRIMARY KEY(one or more columns),
column2 datatype,
column3 datatype,
.....
columnN datatype
);CREATE TABLE adalah kata kunci yang memerintahkan sistem database untuk membuat tabel baru. Nama unik atau pengenal untuk tabel mengikuti pernyataan CREATE TABLE. Secara opsional, Anda bisa menentukan nama_database bersama dengan nama_tabel .
Contoh
Berikut adalah contoh yang membuat tabel PERUSAHAAN dengan ID sebagai kunci utama dan NOT NULL adalah batasan yang menunjukkan bahwa bidang ini tidak boleh NULL saat membuat catatan dalam tabel ini.
sqlite> CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);Mari kita buat satu tabel lagi, yang akan kita gunakan dalam latihan kita di bab-bab selanjutnya.
sqlite> CREATE TABLE DEPARTMENT(
ID INT PRIMARY KEY NOT NULL,
DEPT CHAR(50) NOT NULL,
EMP_ID INT NOT NULL
);Anda dapat memverifikasi apakah tabel Anda telah berhasil dibuat menggunakan perintah SQLite .tables perintah, yang akan digunakan untuk membuat daftar semua tabel dalam database terlampir.
sqlite>.tables
COMPANY DEPARTMENTDi sini, Anda dapat melihat tabel PERUSAHAAN dua kali karena tabel PERUSAHAAN menampilkan database utama dan tabel test.COMPANY untuk alias 'tes' yang dibuat untuk testDB.db Anda. Anda bisa mendapatkan informasi lengkap tentang tabel menggunakan SQLite berikut.schema perintah.
sqlite>.schema COMPANY
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);SQLite DROP TABLE pernyataan digunakan untuk menghapus definisi tabel dan semua data terkait, indeks, pemicu, batasan, dan spesifikasi izin untuk tabel itu.
Anda harus berhati-hati saat menggunakan perintah ini karena sekali tabel dihapus maka semua informasi yang tersedia di tabel juga akan hilang selamanya.
Sintaksis
Berikut ini adalah sintaks dasar dari pernyataan DROP TABLE. Secara opsional, Anda dapat menentukan nama database bersama dengan nama tabel sebagai berikut -
DROP TABLE database_name.table_name;Contoh
Mari kita verifikasi tabel PERUSAHAAN terlebih dahulu dan kemudian kita akan menghapusnya dari database.
sqlite>.tables
COMPANY test.COMPANYIni berarti tabel COMPANY tersedia di database, jadi mari kita jatuhkan sebagai berikut -
sqlite>DROP TABLE COMPANY;
sqlite>Sekarang, jika Anda mencoba perintah .TABLES, maka Anda tidak akan menemukan tabel PERUSAHAAN lagi.
sqlite>.tables
sqlite>Itu tidak menunjukkan apa-apa yang berarti tabel dari database Anda telah berhasil dijatuhkan.
SQLite INSERT INTO Pernyataan digunakan untuk menambahkan baris data baru ke dalam tabel di database.
Sintaksis
Berikut adalah dua sintaks dasar dari pernyataan INSERT INTO.
INSERT INTO TABLE_NAME [(column1, column2, column3,...columnN)]
VALUES (value1, value2, value3,...valueN);Di sini, kolom1, kolom2, ... kolomN adalah nama kolom dalam tabel tempat Anda ingin memasukkan data.
Anda mungkin tidak perlu menentukan nama kolom dalam kueri SQLite jika Anda menambahkan nilai untuk semua kolom pada tabel. Namun, pastikan urutan nilainya dalam urutan yang sama dengan kolom di tabel. Sintaks SQLite INSERT INTO adalah sebagai berikut -
INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);Contoh
Pertimbangkan Anda telah membuat tabel PERUSAHAAN di testDB.db Anda sebagai berikut -
sqlite> CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);Sekarang, pernyataan berikut akan membuat enam record dalam tabel COMPANY.
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (5, 'David', 27, 'Texas', 85000.00 );
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (6, 'Kim', 22, 'South-Hall', 45000.00 );Anda dapat membuat record di tabel COMPANY menggunakan sintaks kedua sebagai berikut -
INSERT INTO COMPANY VALUES (7, 'James', 24, 'Houston', 10000.00 );Semua pernyataan di atas akan membuat catatan berikut di tabel PERUSAHAAN. Di bab berikutnya, Anda akan mempelajari cara menampilkan semua record ini dari tabel.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mengisi Satu Tabel Menggunakan Tabel Lain
Anda dapat mengisi data ke dalam tabel melalui pernyataan pilih di atas tabel lain asalkan tabel lain memiliki sekumpulan bidang, yang diperlukan untuk mengisi tabel pertama. Ini sintaksnya -
INSERT INTO first_table_name [(column1, column2, ... columnN)]
SELECT column1, column2, ...columnN
FROM second_table_name
[WHERE condition];Untuk saat ini, Anda dapat melewati pernyataan di atas. Pertama, mari pelajari klausa SELECT dan WHERE yang akan dibahas pada bab-bab selanjutnya.
SQLite SELECTpernyataan digunakan untuk mengambil data dari tabel database SQLite yang mengembalikan data dalam bentuk tabel hasil. Tabel hasil ini juga disebutresult sets.
Sintaksis
Berikut ini adalah sintaks dasar dari pernyataan SQLite SELECT.
SELECT column1, column2, columnN FROM table_name;Di sini, kolom1, kolom2 ... adalah bidang tabel, yang nilainya ingin Anda ambil. Jika Anda ingin mengambil semua bidang yang tersedia di bidang tersebut, Anda dapat menggunakan sintaks berikut -
SELECT * FROM table_name;Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh untuk mengambil dan menampilkan semua record ini menggunakan pernyataan SELECT. Di sini, tiga perintah pertama telah digunakan untuk mengatur keluaran yang diformat dengan benar.
sqlite>.header on
sqlite>.mode column
sqlite> SELECT * FROM COMPANY;Akhirnya, Anda akan mendapatkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Jika Anda hanya ingin mengambil bidang yang dipilih dari tabel PERUSAHAAN, gunakan kueri berikut -
sqlite> SELECT ID, NAME, SALARY FROM COMPANY;Kueri di atas akan menghasilkan hasil sebagai berikut.
ID NAME SALARY
---------- ---------- ----------
1 Paul 20000.0
2 Allen 15000.0
3 Teddy 20000.0
4 Mark 65000.0
5 David 85000.0
6 Kim 45000.0
7 James 10000.0Mengatur Lebar Kolom Output
Terkadang, Anda akan menghadapi masalah terkait dengan keluaran yang terpotong dalam kasus .mode columnyang terjadi karena lebar default kolom yang akan ditampilkan. Yang dapat Anda lakukan adalah, Anda dapat mengatur lebar kolom yang dapat ditampilkan menggunakan.width num, num.... perintah sebagai berikut -
sqlite>.width 10, 20, 10
sqlite>SELECT * FROM COMPANY;Di atas .width perintah mengatur lebar kolom pertama menjadi 10, lebar kolom kedua 20 dan lebar kolom ketiga 10. Akhirnya, pernyataan SELECT di atas akan memberikan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- -------------------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Informasi Skema
Seperti semua dot commands tersedia di prompt SQLite, maka saat memprogram dengan SQLite, Anda akan menggunakan pernyataan SELECT berikut dengan sqlite_master tabel untuk mencantumkan semua tabel yang dibuat dalam database Anda.
sqlite> SELECT tbl_name FROM sqlite_master WHERE type = 'table';Dengan asumsi Anda hanya memiliki tabel PERUSAHAAN di testDB.db Anda, ini akan menghasilkan hasil sebagai berikut.
tbl_name
----------
COMPANYAnda dapat mendaftar informasi lengkap tentang tabel PERUSAHAAN sebagai berikut -
sqlite> SELECT sql FROM sqlite_master WHERE type = 'table' AND tbl_name = 'COMPANY';Dengan asumsi Anda hanya memiliki tabel PERUSAHAAN di testDB.db Anda, ini akan menghasilkan hasil sebagai berikut.
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
)Apa yang dimaksud dengan Operator di SQLite?
Operator adalah kata khusus atau karakter yang digunakan terutama dalam klausa WHERE pernyataan SQLite untuk melakukan operasi, seperti perbandingan dan operasi aritmatika.
Operator digunakan untuk menentukan kondisi dalam pernyataan SQLite dan berfungsi sebagai konjungsi untuk beberapa kondisi dalam sebuah pernyataan.
- Operator aritmatika
- Operator perbandingan
- Operator logika
- Operator bitwise
Operator Aritmatika SQLite
Asumsikan variabel a memegang 10 dan variabel b menampung 20, maka operator aritmatika SQLite akan digunakan sebagai berikut -
Tunjukkan Contoh
| Operator | Deskripsi | Contoh |
|---|---|---|
| + (Penambahan) | Menambahkan nilai di kedua sisi operator | a + b akan menghasilkan 30 |
| - (Pengurangan) | Mengurangi operan tangan kanan dari operan tangan kiri | a - b akan memberikan -10 |
| * (Perkalian) | Mengalikan nilai di kedua sisi operator | a * b akan memberi 200 |
| / (Divisi) | Membagi operan tangan kiri dengan operan tangan kanan | b / a akan memberi 2 |
| % (Modulus) | Membagi operan tangan kiri dengan operan tangan kanan dan mengembalikan sisanya | b% a akan memberi 0 |
Operator Perbandingan SQLite
Asumsikan variabel a memegang 10 dan variabel b menampung 20, maka operator perbandingan SQLite akan digunakan sebagai berikut
Tunjukkan Contoh
| Operator | Deskripsi | Contoh |
|---|---|---|
| == | Memeriksa apakah nilai dari dua operan sama atau tidak, jika ya maka kondisinya menjadi benar. | (a == b) tidak benar. |
| = | Memeriksa apakah nilai dari dua operan sama atau tidak, jika ya maka kondisinya menjadi benar. | (a = b) tidak benar. |
| ! = | Memeriksa apakah nilai dari dua operan sama atau tidak, jika nilainya tidak sama, maka kondisinya menjadi benar. | (a! = b) benar. |
| <> | Memeriksa apakah nilai dari dua operan sama atau tidak, jika nilainya tidak sama, maka kondisinya menjadi benar. | (a <> b) benar. |
| > | Memeriksa apakah nilai operan kiri lebih besar dari nilai operan kanan, jika ya maka kondisinya menjadi benar. | (a> b) tidak benar. |
| < | Memeriksa apakah nilai operan kiri kurang dari nilai operan kanan, jika ya maka kondisinya menjadi benar. | (a <b) benar. |
| > = | Memeriksa apakah nilai operan kiri lebih besar dari atau sama dengan nilai operan kanan, jika ya maka kondisinya menjadi benar. | (a> = b) tidak benar. |
| <= | Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanan, jika ya maka kondisinya menjadi benar. | (a <= b) benar. |
| ! < | Memeriksa apakah nilai operan kiri tidak kurang dari nilai operan kanan, jika ya maka kondisinya menjadi benar. | (a! <b) salah. |
| !> | Memeriksa apakah nilai operan kiri tidak lebih besar dari nilai operan kanan, jika ya maka kondisinya menjadi benar. | (a!> b) benar. |
Operator Logika SQLite
Berikut adalah daftar semua operator logika yang tersedia di SQLite.
Tunjukkan Contoh
| Sr.No. | Operator & Deskripsi |
|---|---|
| 1 | AND Operator AND memungkinkan adanya beberapa kondisi dalam klausa WHERE pernyataan SQL. |
| 2 | BETWEEN Operator BETWEEN digunakan untuk mencari nilai yang ada di dalam satu set nilai, dengan mempertimbangkan nilai minimum dan nilai maksimum. |
| 3 | EXISTS Operator EXISTS digunakan untuk mencari keberadaan baris dalam tabel tertentu yang memenuhi kriteria tertentu. |
| 4 | IN Operator IN digunakan untuk membandingkan nilai dengan daftar nilai literal yang telah ditentukan. |
| 5 | NOT IN Negasi operator IN yang digunakan untuk membandingkan nilai dengan daftar nilai literal yang telah ditentukan. |
| 6 | LIKE Operator LIKE digunakan untuk membandingkan nilai dengan nilai serupa menggunakan operator wildcard. |
| 7 | GLOB Operator GLOB digunakan untuk membandingkan nilai dengan nilai serupa menggunakan operator wildcard. Selain itu, GLOB peka huruf besar / kecil, tidak seperti LIKE. |
| 8 | NOT Operator NOT membalikkan arti dari operator logika yang digunakannya. Misalnya. TIDAK ADA, TIDAK ANTARA, TIDAK DI, dll.This is negate operator. |
| 9 | OR Operator OR digunakan untuk menggabungkan beberapa kondisi dalam klausa WHERE pernyataan SQL. |
| 10 | IS NULL Operator NULL digunakan untuk membandingkan nilai dengan nilai NULL. |
| 11 | IS Operator IS bekerja seperti = |
| 12 | IS NOT Operator IS bekerja seperti! = |
| 13 | || Menambahkan dua string berbeda dan membuat yang baru. |
| 14 | UNIQUE Operator UNIQUE mencari keunikan setiap baris dari tabel tertentu (tidak ada duplikat). |
Operator Bitwise SQLite
Operator bitwise bekerja pada bit dan melakukan operasi bit demi bit. Berikut adalah tabel kebenaran untuk& dan |.
| p | q | p & q | p | q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 |
Asumsikan jika A= 60; danB = 13, maka dalam format biner menjadi sebagai berikut -
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A | B = 0011 1101
~ A = 1100 0011
Operator Bitwise yang didukung oleh bahasa SQLite dicantumkan di tabel berikut. Asumsikan variabelA memegang 60 dan variabel B memegang 13, lalu -
Tunjukkan Contoh
| Operator | Deskripsi | Contoh |
|---|---|---|
| & | Biner AND Operator menyalin sedikit ke hasil, jika ada di kedua operan. | (A & B) akan memberikan 12 yaitu 0000 1100 |
| | | Biner ATAU Operator menyalin sedikit, jika ada di salah satu operan. | (A | B) akan menghasilkan 61 yaitu 0011 1101 |
| ~ | Operator Pelengkap Binary Ones adalah unary dan memiliki efek bit 'membalik'. | (~ A) akan memberikan -61 yaitu 1100 0011 dalam bentuk komplemen 2 karena bilangan biner bertanda |
| << | Operator Binary Left Shift. Nilai operan kiri dipindahkan ke kiri dengan jumlah bit yang ditentukan oleh operan kanan. | A << 2 akan menghasilkan 240 yaitu 1111 0000 |
| >> | Operator Pergeseran Kanan Biner. Nilai operan kiri dipindahkan ke kanan dengan jumlah bit yang ditentukan oleh operan kanan. | A >> 2 akan menghasilkan 15 yaitu 0000 1111 |
Ekspresi adalah kombinasi dari satu atau beberapa nilai, operator, dan fungsi SQL yang mengevaluasi suatu nilai.
Ekspresi SQL seperti rumus dan ditulis dalam bahasa kueri. Anda juga bisa menggunakan untuk membuat kueri database untuk sekumpulan data tertentu.
Sintaksis
Pertimbangkan sintaks dasar dari pernyataan SELECT sebagai berikut -
SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION | EXPRESSION];Berikut adalah berbagai jenis ekspresi SQLite.
SQLite - Ekspresi Boolean
Ekspresi Boolean SQLite mengambil data berdasarkan pencocokan nilai tunggal. Berikut adalah sintaksnya -
SELECT column1, column2, columnN
FROM table_name
WHERE SINGLE VALUE MATCHTING EXPRESSION;Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh sederhana yang menunjukkan penggunaan SQLite Boolean Expressions -
sqlite> SELECT * FROM COMPANY WHERE SALARY = 10000;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
4 James 24 Houston 10000.0SQLite - Ekspresi Numerik
Ekspresi ini digunakan untuk melakukan operasi matematika apa pun dalam kueri apa pun. Berikut adalah sintaksnya -
SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;Di sini, ekspresi_numerik digunakan untuk ekspresi matematika atau rumus apa pun. Berikut ini adalah contoh sederhana yang menunjukkan penggunaan SQLite Numeric Expressions.
sqlite> SELECT (15 + 6) AS ADDITION
ADDITION = 21Ada beberapa fungsi bawaan seperti avg(), sum(), count(), dll., untuk melakukan apa yang disebut aggregate data calculations terhadap tabel atau kolom tabel tertentu.
sqlite> SELECT COUNT(*) AS "RECORDS" FROM COMPANY;
RECORDS = 7SQLite - Ekspresi Tanggal
Ekspresi Tanggal mengembalikan nilai tanggal dan waktu sistem saat ini. Ekspresi ini digunakan dalam berbagai manipulasi data.
sqlite> SELECT CURRENT_TIMESTAMP;
CURRENT_TIMESTAMP = 2013-03-17 10:43:35SQLite WHERE klausa digunakan untuk menentukan kondisi saat mengambil data dari satu tabel atau beberapa tabel.
Jika kondisi yang diberikan terpenuhi, artinya benar, maka ia mengembalikan nilai spesifik dari tabel. Anda harus menggunakan klausa WHERE untuk memfilter catatan dan hanya mengambil catatan yang diperlukan.
Klausa WHERE tidak hanya digunakan dalam pernyataan SELECT, tetapi juga digunakan dalam pernyataan UPDATE, DELETE, dll., Yang akan dibahas dalam bab-bab selanjutnya.
Sintaksis
Berikut ini adalah sintaks dasar dari pernyataan SQLite SELECT dengan klausa WHERE.
SELECT column1, column2, columnN
FROM table_name
WHERE [condition]Contoh
Anda dapat menentukan kondisi menggunakan Comparision atau Logical Operator seperti>, <, =, LIKE, NOT, dll. Pertimbangkan tabel COMPANY dengan record berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh sederhana yang menunjukkan penggunaan Operator Logika SQLite. Mengikuti pernyataan SELECT mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25AND gaji lebih besar dari atau sama dengan 65000.00.
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25 OR gaji lebih besar dari atau sama dengan 65000.00.
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana AGE bukan NULL, yang berarti semua catatan karena tidak ada catatan yang memiliki AGE sama dengan NULL.
sqlite> SELECT * FROM COMPANY WHERE AGE IS NOT NULL;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mengikuti pernyataan SELECT mencantumkan semua record di mana NAME dimulai dengan 'Ki', tidak peduli apa yang muncul setelah 'Ki'.
sqlite> SELECT * FROM COMPANY WHERE NAME LIKE 'Ki%';
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
6 Kim 22 South-Hall 45000.0Mengikuti pernyataan SELECT mencantumkan semua record di mana NAME dimulai dengan 'Ki', tidak peduli apa yang muncul setelah 'Ki'.
sqlite> SELECT * FROM COMPANY WHERE NAME GLOB 'Ki*';
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
6 Kim 22 South-Hall 45000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana nilai AGE adalah 25 atau 27.
sqlite> SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana nilai AGE bukan 25 atau 27.
sqlite> SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
3 Teddy 23 Norway 20000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana nilai USIA berada di ANTARA 25 DAN 27.
sqlite> SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Mengikuti pernyataan SELECT menggunakan sub-query SQL, di mana sub-query menemukan semua record dengan bidang AGE yang memiliki GAJI> 65000 dan kemudian klausa WHERE digunakan bersama dengan operator EXISTS untuk mendaftar semua record di mana AGE dari query luar ada dalam hasil yang dikembalikan oleh sub-kueri -
sqlite> SELECT AGE FROM COMPANY
WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
AGE
----------
32
25
23
25
27
22
24Mengikuti pernyataan SELECT menggunakan sub-query SQL di mana sub-query menemukan semua catatan dengan bidang AGE memiliki GAJI> 65000 dan kemudian klausa WHERE digunakan bersama dengan> operator untuk mencantumkan semua catatan di mana AGE dari kueri luar lebih besar dari usia dalam hasil yang dikembalikan oleh sub-kueri.
sqlite> SELECT * FROM COMPANY
WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0SQLite AND & ORoperator digunakan untuk mengkompilasi beberapa kondisi untuk mempersempit data yang dipilih dalam pernyataan SQLite. Kedua operator ini disebutconjunctive operators.
Operator ini menyediakan cara untuk membuat beberapa perbandingan dengan operator yang berbeda dalam pernyataan SQLite yang sama.
Operator AND
Itu ANDoperator memungkinkan adanya beberapa kondisi dalam klausa WHERE pernyataan SQLite. Saat menggunakan operator AND, kondisi lengkap akan dianggap benar jika semua kondisi benar. Misalnya, [condition1] AND [condition2] hanya akan benar jika condition1 dan condition2 benar.
Sintaksis
Berikut ini adalah sintaks dasar operator AND dengan klausa WHERE.
SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];Anda bisa menggabungkan Njumlah ketentuan yang menggunakan operator AND. Untuk tindakan yang akan diambil oleh pernyataan SQLite, apakah itu transaksi atau kueri, semua kondisi yang dipisahkan oleh DAN harus BENAR.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25 AND gaji lebih besar dari atau sama dengan 65000.00.
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Operator OR
Operator OR juga digunakan untuk menggabungkan beberapa kondisi dalam klausa WHERE pernyataan SQLite. Saat menggunakan operator OR, kondisi lengkap akan dianggap benar jika setidaknya salah satu ketentuannya benar. Misalnya, [kondisi1] ATAU [kondisi2] akan menjadi benar jika kondisi1 atau kondisi2 benar.
Sintaksis
Berikut sintaks dasar operator OR dengan klausa WHERE.
SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]Anda bisa menggabungkan Njumlah kondisi menggunakan operator OR. Untuk tindakan yang akan diambil oleh pernyataan SQLite, apakah itu transaksi atau kueri, hanya SALAH SATU kondisi yang dipisahkan oleh ATAU harus BENAR.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mengikuti pernyataan SELECT mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25 OR gaji lebih besar dari atau sama dengan 65000.00.
sqlite> SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0SQLite UPDATEQuery digunakan untuk mengubah record yang ada dalam sebuah tabel. Anda dapat menggunakan klausa WHERE dengan kueri UPDATE untuk memperbarui baris yang dipilih, jika tidak, semua baris akan diperbarui.
Sintaksis
Berikut ini adalah sintaks dasar dari kueri UPDATE dengan klausa WHERE.
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];Anda bisa menggabungkan N jumlah ketentuan yang menggunakan operator DAN atau ATAU.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh, yang akan memperbarui ADDRESS untuk pelanggan yang ID-nya adalah 6.
sqlite> UPDATE COMPANY SET ADDRESS = 'Texas' WHERE ID = 6;Sekarang, tabel COMPANY akan memiliki record berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 Texas 45000.0
7 James 24 Houston 10000.0Jika Anda ingin mengubah semua nilai kolom ALAMAT dan GAJI di tabel PERUSAHAAN, Anda tidak perlu menggunakan klausa WHERE dan kueri UPDATE akan seperti berikut -
sqlite> UPDATE COMPANY SET ADDRESS = 'Texas', SALARY = 20000.00;Sekarang, tabel COMPANY akan memiliki record berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 Texas 20000.0
2 Allen 25 Texas 20000.0
3 Teddy 23 Texas 20000.0
4 Mark 25 Texas 20000.0
5 David 27 Texas 20000.0
6 Kim 22 Texas 20000.0
7 James 24 Texas 20000.0SQLite DELETEKueri digunakan untuk menghapus rekaman yang ada dari tabel. Anda dapat menggunakan klausa WHERE dengan kueri DELETE untuk menghapus baris yang dipilih, jika tidak, semua catatan akan dihapus.
Sintaksis
Berikut ini adalah sintaks dasar dari query DELETE dengan klausa WHERE.
DELETE FROM table_name
WHERE [condition];Anda bisa menggabungkan N jumlah ketentuan yang menggunakan operator DAN atau ATAU.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh, yang akan MENGHAPUS pelanggan dengan ID 7.
sqlite> DELETE FROM COMPANY WHERE ID = 7;Sekarang tabel PERUSAHAAN akan memiliki catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0Jika Anda ingin MENGHAPUS semua record dari tabel COMPANY, Anda tidak perlu menggunakan klausa WHERE dengan query DELETE, yang akan menjadi sebagai berikut -
sqlite> DELETE FROM COMPANY;Sekarang, tabel COMPANY tidak memiliki record karena semua record telah dihapus oleh pernyataan DELETE.
SQLite LIKEoperator digunakan untuk mencocokkan nilai teks dengan pola menggunakan wildcard. Jika ekspresi pencarian bisa dicocokkan dengan ekspresi pola, operator LIKE akan mengembalikan nilai true, yaitu 1. Ada dua karakter pengganti yang digunakan dalam hubungannya dengan operator LIKE -
- Tanda persen (%)
- Garis bawah (_)
Tanda persen mewakili nol, satu, atau beberapa angka atau karakter. Garis bawah mewakili satu angka atau karakter. Simbol-simbol ini dapat digunakan dalam kombinasi.
Sintaksis
Berikut ini adalah sintaks dasar dari% dan _.
SELECT FROM table_name
WHERE column LIKE 'XXXX%'
or
SELECT FROM table_name
WHERE column LIKE '%XXXX%'
or
SELECT FROM table_name
WHERE column LIKE 'XXXX_'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX'
or
SELECT FROM table_name
WHERE column LIKE '_XXXX_'Anda bisa menggabungkan Njumlah ketentuan yang menggunakan operator DAN atau ATAU. Di sini, XXXX bisa berupa nilai numerik atau string apa pun.
Contoh
Tabel berikut mencantumkan sejumlah contoh yang menunjukkan bagian MANA yang memiliki klausa LIKE yang berbeda dengan operator '%' dan '_'.
| Sr.No. | Pernyataan & Deskripsi |
|---|---|
| 1 | WHERE SALARY LIKE '200%' Menemukan nilai apa pun yang dimulai dengan 200 |
| 2 | WHERE SALARY LIKE '%200%' Menemukan nilai apa pun yang memiliki 200 di posisi mana pun |
| 3 | WHERE SALARY LIKE '_00%' Menemukan nilai apa pun yang memiliki 00 di posisi kedua dan ketiga |
| 4 | WHERE SALARY LIKE '2_%_%' Menemukan nilai apa pun yang dimulai dengan 2 dan setidaknya memiliki panjang 3 karakter |
| 5 | WHERE SALARY LIKE '%2' Menemukan nilai apa pun yang diakhiri dengan 2 |
| 6 | WHERE SALARY LIKE '_2%3' Menemukan nilai apa pun yang memiliki 2 di posisi kedua dan diakhiri dengan 3 |
| 7 | WHERE SALARY LIKE '2___3' Menemukan nilai apa pun dalam angka lima digit yang dimulai dengan 2 dan diakhiri dengan 3 |
Mari kita ambil contoh nyata, perhatikan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah sebuah contoh, yang akan menampilkan semua record dari tabel COMPANY dimana AGE dimulai dengan 2.
sqlite> SELECT * FROM COMPANY WHERE AGE LIKE '2%';Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh, yang akan menampilkan semua record dari tabel COMPANY dimana ADDRESS akan memiliki tanda hubung (-) di dalam teks.
sqlite> SELECT * FROM COMPANY WHERE ADDRESS LIKE '%-%';Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
4 Mark 25 Rich-Mond 65000.0
6 Kim 22 South-Hall 45000.0SQLite GLOBoperator digunakan untuk mencocokkan hanya nilai teks dengan pola menggunakan wildcard. Jika ekspresi pencarian dapat dicocokkan dengan ekspresi pola, operator GLOB akan mengembalikan nilai true, yaitu 1. Tidak seperti operator LIKE, GLOB peka huruf besar-kecil dan mengikuti sintaks UNIX untuk menetapkan karakter pengganti berikut.
- Tanda asterisk (*)
- Tanda tanya (?)
Tanda asterisk (*) mewakili nol atau beberapa angka atau karakter. Tanda tanya (?) Mewakili satu angka atau karakter.
Sintaksis
Berikut ini adalah sintaks dasar * dan ?.
SELECT FROM table_name
WHERE column GLOB 'XXXX*'
or
SELECT FROM table_name
WHERE column GLOB '*XXXX*'
or
SELECT FROM table_name
WHERE column GLOB 'XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX'
or
SELECT FROM table_name
WHERE column GLOB '?XXXX?'
or
SELECT FROM table_name
WHERE column GLOB '????'Anda bisa menggabungkan Njumlah ketentuan yang menggunakan operator DAN atau ATAU. Di sini, XXXX bisa berupa nilai numerik atau string apa pun.
Contoh
Tabel berikut mencantumkan sejumlah contoh yang menunjukkan DI MANA bagian memiliki klausa LIKE yang berbeda dengan '*' dan '?' operator.
| Sr.No. | Pernyataan & Deskripsi |
|---|---|
| 1 | WHERE SALARY GLOB '200*' Menemukan nilai apa pun yang dimulai dengan 200 |
| 2 | WHERE SALARY GLOB '*200*' Menemukan nilai apa pun yang memiliki 200 di posisi mana pun |
| 3 | WHERE SALARY GLOB '?00*' Menemukan nilai apa pun yang memiliki 00 di posisi kedua dan ketiga |
| 4 | WHERE SALARY GLOB '2??' Menemukan nilai apa pun yang dimulai dengan 2 dan setidaknya memiliki panjang 3 karakter |
| 5 | WHERE SALARY GLOB '*2' Menemukan nilai apa pun yang diakhiri dengan 2 |
| 6 | WHERE SALARY GLOB '?2*3' Menemukan nilai apa pun yang memiliki 2 di posisi kedua dan diakhiri dengan 3 |
| 7 | WHERE SALARY GLOB '2???3' Menemukan nilai apa pun dalam angka lima digit yang dimulai dengan 2 dan diakhiri dengan 3 |
Mari kita ambil contoh nyata, perhatikan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut ini adalah sebuah contoh, yang akan menampilkan semua record dari tabel COMPANY, dimana AGE dimulai dengan 2.
sqlite> SELECT * FROM COMPANY WHERE AGE GLOB '2*';Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah sebuah contoh, yang akan menampilkan semua record dari tabel COMPANY dimana ADDRESS akan memiliki tanda hubung (-) di dalam teks -
sqlite> SELECT * FROM COMPANY WHERE ADDRESS GLOB '*-*';Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
4 Mark 25 Rich-Mond 65000.0
6 Kim 22 South-Hall 45000.0SQLite LIMIT klausa digunakan untuk membatasi jumlah data yang dikembalikan oleh pernyataan SELECT.
Sintaksis
Berikut adalah sintaks dasar dari pernyataan SELECT dengan klausa LIMIT.
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]Berikut adalah sintaks klausa LIMIT jika digunakan bersama dengan klausa OFFSET.
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows] OFFSET [row num]Mesin SQLite akan mengembalikan baris mulai dari baris berikutnya ke OFFSET yang diberikan seperti yang ditunjukkan di bawah ini pada contoh terakhir.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut ini adalah contoh, yang membatasi baris dalam tabel sesuai dengan jumlah baris yang ingin Anda ambil dari tabel.
sqlite> SELECT * FROM COMPANY LIMIT 6;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0Namun dalam situasi tertentu, Anda mungkin perlu mengambil sekumpulan record dari offset tertentu. Berikut adalah contoh yang picks up 3 catatan mulai dari 3 rd posisi.
sqlite> SELECT * FROM COMPANY LIMIT 3 OFFSET 2;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0SQLite ORDER BY klausa digunakan untuk mengurutkan data dalam urutan naik atau turun, berdasarkan satu atau beberapa kolom.
Sintaksis
Berikut ini adalah sintaks dasar dari klausa ORDER BY.
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];Anda dapat menggunakan lebih dari satu kolom di klausa ORDER BY. Pastikan kolom apa pun yang Anda gunakan untuk mengurutkan, kolom itu harus tersedia di daftar kolom.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh yang akan mengurutkan hasil dalam urutan menurun menurut GAJI.
sqlite> SELECT * FROM COMPANY ORDER BY SALARY ASC;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
7 James 24 Houston 10000.0
2 Allen 25 Texas 15000.0
1 Paul 32 California 20000.0
3 Teddy 23 Norway 20000.0
6 Kim 22 South-Hall 45000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Berikut ini adalah contoh yang akan mengurutkan hasil dalam urutan menurun menurut NAMA dan GAJI.
sqlite> SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000.0
5 David 27 Texas 85000.0
7 James 24 Houston 10000.0
6 Kim 22 South-Hall 45000.0
4 Mark 25 Rich-Mond 65000.0
1 Paul 32 California 20000.0
3 Teddy 23 Norway 20000.0Berikut ini adalah contoh, yang akan mengurutkan hasil dalam urutan turun menurut NAME.
sqlite> SELECT * FROM COMPANY ORDER BY NAME DESC;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
3 Teddy 23 Norway 20000.0
1 Paul 32 California 20000.0
4 Mark 25 Rich-Mond 65000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
5 David 27 Texas 85000.0
2 Allen 25 Texas 15000.0SQLite GROUP BY klausa digunakan dalam kolaborasi dengan pernyataan SELECT untuk mengatur data identik ke dalam kelompok.
Klausa GROUP BY mengikuti klausa WHERE dalam pernyataan SELECT dan mendahului klausa ORDER BY.
Sintaksis
Berikut ini adalah sintaks dasar dari klausa GROUP BY. Klausa GROUP BY harus mengikuti kondisi di klausa WHERE dan harus mendahului klausa ORDER BY jika salah satu digunakan.
SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnNAnda dapat menggunakan lebih dari satu kolom di klausa GROUP BY. Pastikan kolom apa pun yang Anda gunakan untuk mengelompokkan, kolom itu harus tersedia di daftar kolom.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Jika Anda ingin mengetahui jumlah total gaji pada setiap pelanggan, maka kueri GROUP BY adalah sebagai berikut -
sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;Ini akan menghasilkan hasil sebagai berikut -
NAME SUM(SALARY)
---------- -----------
Allen 15000.0
David 85000.0
James 10000.0
Kim 45000.0
Mark 65000.0
Paul 20000.0
Teddy 20000.0Sekarang, mari kita buat tiga record lagi dalam tabel COMPANY menggunakan pernyataan INSERT berikut.
INSERT INTO COMPANY VALUES (8, 'Paul', 24, 'Houston', 20000.00 );
INSERT INTO COMPANY VALUES (9, 'James', 44, 'Norway', 5000.00 );
INSERT INTO COMPANY VALUES (10, 'James', 45, 'Texas', 5000.00 );Sekarang, tabel kami memiliki record berikut dengan nama duplikat.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
8 Paul 24 Houston 20000.0
9 James 44 Norway 5000.0
10 James 45 Texas 5000.0Sekali lagi, mari kita gunakan pernyataan yang sama untuk mengelompokkan-berdasarkan semua catatan menggunakan kolom NAMA sebagai berikut -
sqlite> SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;Ini akan menghasilkan hasil sebagai berikut.
NAME SUM(SALARY)
---------- -----------
Allen 15000
David 85000
James 20000
Kim 45000
Mark 65000
Paul 40000
Teddy 20000Mari kita gunakan klausa ORDER BY bersama dengan klausa GROUP BY sebagai berikut -
sqlite> SELECT NAME, SUM(SALARY)
FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;Ini akan menghasilkan hasil sebagai berikut.
NAME SUM(SALARY)
---------- -----------
Teddy 20000
Paul 40000
Mark 65000
Kim 45000
James 20000
David 85000
Allen 15000Klausa HAVING memungkinkan Anda untuk menentukan kondisi yang memfilter hasil grup mana yang muncul di hasil akhir.
Klausa WHERE menempatkan kondisi pada kolom yang dipilih, sedangkan klausa HAVING menempatkan kondisi pada grup yang dibuat oleh klausa GROUP BY.
Sintaksis
Berikut adalah posisi klausa HAVING dalam query SELECT.
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BYKlausa HAVING harus mengikuti klausa GROUP BY dalam kueri dan juga harus mendahului klausa ORDER BY jika digunakan. Berikut ini adalah sintaks dari pernyataan SELECT, termasuk klausa HAVING.
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
8 Paul 24 Houston 20000.0
9 James 44 Norway 5000.0
10 James 45 Texas 5000.0Berikut ini adalah contoh yang akan menampilkan record yang jumlah namanya kurang dari 2.
sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) < 2;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000
5 David 27 Texas 85000
6 Kim 22 South-Hall 45000
4 Mark 25 Rich-Mond 65000
3 Teddy 23 Norway 20000Berikut ini adalah contoh, yang akan menampilkan record yang jumlah namanya lebih besar dari 2.
sqlite > SELECT * FROM COMPANY GROUP BY name HAVING count(name) > 2;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
10 James 45 Texas 5000SQLite DISTINCT kata kunci digunakan dalam hubungannya dengan pernyataan SELECT untuk menghilangkan semua record duplikat dan hanya mengambil record unik.
Mungkin ada situasi ketika Anda memiliki beberapa rekaman duplikat dalam sebuah tabel. Saat mengambil catatan seperti itu, lebih masuk akal untuk hanya mengambil catatan unik daripada mengambil catatan duplikat.
Sintaksis
Berikut ini adalah sintaks dasar kata kunci DISTINCT untuk menghilangkan catatan duplikat.
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0
8 Paul 24 Houston 20000.0
9 James 44 Norway 5000.0
10 James 45 Texas 5000.0Pertama, mari kita lihat bagaimana kueri SELECT berikut mengembalikan catatan gaji duplikat.
sqlite> SELECT name FROM COMPANY;Ini akan menghasilkan hasil sebagai berikut.
NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
James
JamesSekarang, mari kita gunakan DISTINCT kata kunci dengan query SELECT di atas dan lihat hasilnya.
sqlite> SELECT DISTINCT name FROM COMPANY;Ini akan menghasilkan hasil sebagai berikut, di mana tidak ada entri duplikat.
NAME
----------
Paul
Allen
Teddy
Mark
David
Kim
JamesSQLite PRAGMAperintah adalah perintah khusus yang akan digunakan untuk mengontrol berbagai variabel lingkungan dan bendera negara dalam lingkungan SQLite. Nilai PRAGMA dapat dibaca dan juga dapat diatur berdasarkan kebutuhan.
Sintaksis
Untuk menanyakan nilai PRAGMA saat ini, cukup berikan nama pragma.
PRAGMA pragma_name;Untuk menyetel nilai baru untuk PRAGMA, gunakan sintaks berikut.
PRAGMA pragma_name = value;Mode set dapat berupa nama atau padanan bilangan bulat tetapi nilai yang dikembalikan akan selalu berupa bilangan bulat.
auto_vacuum Pragma
Itu auto_vacuumpragma mendapatkan atau menyetel mode vakum otomatis. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]auto_vacuum;
PRAGMA [database.]auto_vacuum = mode;Dimana mode dapat berupa salah satu dari berikut -
| Sr.No. | Nilai & Deskripsi Pragma |
|---|---|
| 1 | 0 or NONE Penyedot debu otomatis dinonaktifkan. Ini adalah mode default yang berarti bahwa file database tidak akan pernah menyusut ukurannya kecuali secara manual disedot menggunakan perintah VACUUM. |
| 2 | 1 or FULL Vakum otomatis diaktifkan dan sepenuhnya otomatis yang memungkinkan file database menyusut saat data dihapus dari database. |
| 3 | 2 or INCREMENTAL Penyedot debu otomatis diaktifkan tetapi harus diaktifkan secara manual. Dalam mode ini data referensi dipertahankan, tetapi halaman gratis hanya dimasukkan ke dalam daftar gratis. Halaman-halaman ini dapat dipulihkan menggunakanincremental_vacuum pragma kapan saja. |
cache_size Pragma
Itu cache_sizepragma bisa mendapatkan atau menyetel sementara ukuran maksimum cache halaman dalam memori. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]cache_size;
PRAGMA [database.]cache_size = pages;Itu pagesnilai mewakili jumlah halaman di cache. Cache halaman built-in memiliki ukuran default 2.000 halaman dan ukuran minimum 10 halaman.
case_sensitive_like Pragma
Itu case_sensitive_likepragma mengontrol sensitivitas huruf dari ekspresi LIKE bawaan. Secara default, pragma ini salah yang berarti bahwa operator LIKE bawaan mengabaikan kasus huruf. Berikut ini adalah sintaks sederhana.
PRAGMA case_sensitive_like = [true|false];Tidak ada cara untuk menanyakan keadaan pragma saat ini.
count_changes Pragma
count_changespragma mendapatkan atau menyetel nilai kembali dari pernyataan manipulasi data seperti INSERT, UPDATE dan DELETE. Berikut ini adalah sintaks sederhana.
PRAGMA count_changes;
PRAGMA count_changes = [true|false];Secara default, pragma ini salah dan pernyataan ini tidak mengembalikan apa pun. Jika disetel ke true, setiap pernyataan yang disebutkan akan mengembalikan tabel satu kolom, satu baris yang terdiri dari nilai integer tunggal yang menunjukkan baris yang terpengaruh oleh operasi tersebut.
database_list Pragma
Itu database_listpragma akan digunakan untuk mendaftar semua database yang dilampirkan. Berikut ini adalah sintaks sederhana.
PRAGMA database_list;Pragma ini akan mengembalikan tabel tiga kolom dengan satu baris per database terbuka atau terlampir yang memberikan nomor urut database, namanya dan file yang terkait.
pengkodean Pragma
Itu encodingpragma mengontrol bagaimana string dikodekan dan disimpan dalam file database. Berikut ini adalah sintaks sederhana.
PRAGMA encoding;
PRAGMA encoding = format;Nilai format dapat berupa salah satu UTF-8, UTF-16le, atau UTF-16be.
freelist_count Pragma
Itu freelist_countpragma mengembalikan satu bilangan bulat yang menunjukkan berapa banyak halaman database yang saat ini ditandai sebagai gratis dan tersedia. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]freelist_count;Nilai format dapat berupa salah satu UTF-8, UTF-16le, atau UTF-16be.
index_info Pragma
Itu index_infopragma mengembalikan informasi tentang indeks database. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]index_info( index_name );Kumpulan hasil akan berisi satu baris untuk setiap kolom yang terdapat dalam indeks yang memberikan urutan kolom, indeks kolom dengan tabel dan nama kolom.
index_list Pragma
index_listpragma mencantumkan semua indeks yang terkait dengan sebuah tabel. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]index_list( table_name );Kumpulan hasil akan berisi satu baris untuk setiap indeks yang memberikan urutan indeks, nama indeks dan bendera yang menunjukkan apakah indeks itu unik atau tidak.
journal_mode Pragma
Itu journal_modepragma mendapatkan atau menyetel mode jurnal yang mengontrol bagaimana file jurnal disimpan dan diproses. Berikut ini adalah sintaks sederhana.
PRAGMA journal_mode;
PRAGMA journal_mode = mode;
PRAGMA database.journal_mode;
PRAGMA database.journal_mode = mode;Ada lima mode jurnal yang didukung seperti yang tercantum dalam tabel berikut.
| Sr.No. | Nilai & Deskripsi Pragma |
|---|---|
| 1 | DELETE Ini adalah mode default. Di sini, di akhir transaksi, file jurnal dihapus. |
| 2 | TRUNCATE File jurnal dipotong menjadi panjang nol byte. |
| 3 | PERSIST File jurnal dibiarkan di tempatnya, tetapi tajuknya diganti untuk menunjukkan jurnal tidak lagi valid. |
| 4 | MEMORY Catatan jurnal disimpan di memori, bukan di disk. |
| 5 | OFF Tidak ada catatan jurnal yang disimpan. |
max_page_count Pragma
Itu max_page_countpragma mendapatkan atau menyetel jumlah halaman maksimum yang diizinkan untuk database. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]max_page_count;
PRAGMA [database.]max_page_count = max_page;Nilai defaultnya adalah 1.073.741.823 yang merupakan satu halaman giga, yang artinya jika ukuran halaman default 1 KB, ini memungkinkan database berkembang hingga satu terabyte.
page_count Pragma
Itu page_countpragma kembali dalam jumlah halaman saat ini dalam database. Berikut ini adalah sintaks sederhana -
PRAGMA [database.]page_count;Ukuran file database harus page_count * page_size.
page_size Pragma
Itu page_sizepragma mendapatkan atau menyetel ukuran halaman database. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]page_size;
PRAGMA [database.]page_size = bytes;Secara default, ukuran yang diizinkan adalah 512, 1024, 2048, 4096, 8192, 16384, dan 32768 byte. Satu-satunya cara untuk mengubah ukuran halaman pada database yang sudah ada adalah dengan mengatur ukuran halaman dan segera VACUUM database.
parser_trace Pragma
Itu parser_tracekontrol pragma mencetak status debugging saat mengurai perintah SQL. Berikut ini adalah sintaks sederhana.
PRAGMA parser_trace = [true|false];Secara default, ini disetel ke false tetapi ketika diaktifkan dengan menyetelnya ke true, parser SQL akan mencetak statusnya saat mengurai perintah SQL.
recursive_triggers Pragma
Itu recursive_triggerspragma mendapatkan atau menyetel fungsi pemicu rekursif. Jika pemicu rekursif tidak diaktifkan, tindakan pemicu tidak akan mengaktifkan pemicu lain. Berikut ini adalah sintaks sederhana.
PRAGMA recursive_triggers;
PRAGMA recursive_triggers = [true|false];schema_version Pragma
Itu schema_versionpragma mendapatkan atau menyetel nilai versi skema yang disimpan di header database. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]schema_version;
PRAGMA [database.]schema_version = number;Ini adalah nilai integer bertanda tangan 32-bit yang melacak perubahan skema. Setiap kali perintah pengubah skema dijalankan (seperti, CREATE ... atau DROP ...), nilai ini bertambah.
secure_delete Pragma
Itu secure_deletepragma digunakan untuk mengontrol bagaimana konten dihapus dari database. Berikut ini adalah sintaks sederhana.
PRAGMA secure_delete;
PRAGMA secure_delete = [true|false];
PRAGMA database.secure_delete;
PRAGMA database.secure_delete = [true|false];Nilai default untuk tanda hapus aman biasanya tidak aktif, tetapi ini dapat diubah dengan opsi build SQLITE_SECURE_DELETE.
sql_trace Pragma
Itu sql_tracepragma digunakan untuk membuang hasil pelacakan SQL ke layar. Berikut ini adalah sintaks sederhana.
PRAGMA sql_trace;
PRAGMA sql_trace = [true|false];SQLite harus dikompilasi dengan direktif SQLITE_DEBUG agar pragma ini dapat disertakan.
sinkronis Pragma
Itu synchronouspragma mendapatkan atau menyetel mode sinkronisasi disk saat ini, yang mengontrol seberapa agresif SQLite akan menulis data hingga ke penyimpanan fisik. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]synchronous;
PRAGMA [database.]synchronous = mode;SQLite mendukung mode sinkronisasi berikut seperti yang tercantum dalam tabel.
| Sr.No. | Nilai & Deskripsi Pragma |
|---|---|
| 1 | 0 or OFF Tidak ada sinkronisasi sama sekali |
| 2 | 1 or NORMAL Sinkronkan setelah setiap urutan operasi disk kritis |
| 3 | 2 or FULL Sinkronkan setelah setiap operasi disk penting |
temp_store Pragma
Itu temp_storepragma mendapatkan atau menyetel mode penyimpanan yang digunakan oleh file database sementara. Berikut ini adalah sintaks sederhana.
PRAGMA temp_store;
PRAGMA temp_store = mode;SQLite mendukung mode penyimpanan berikut.
| Sr.No. | Nilai & Deskripsi Pragma |
|---|---|
| 1 | 0 or DEFAULT Gunakan default waktu kompilasi. Biasanya FILE. |
| 2 | 1 or FILE Gunakan penyimpanan berbasis file. |
| 3 | 2 or MEMORY Gunakan penyimpanan berbasis memori. |
temp_store_directory Pragma
Itu temp_store_directorypragma mendapatkan atau menyetel lokasi yang digunakan untuk file database sementara. Berikut ini adalah sintaks sederhana.
PRAGMA temp_store_directory;
PRAGMA temp_store_directory = 'directory_path';user_version Pragma
Itu user_versionpragma mendapatkan atau menyetel nilai versi yang ditentukan pengguna yang disimpan di header database. Berikut ini adalah sintaks sederhana.
PRAGMA [database.]user_version;
PRAGMA [database.]user_version = number;Ini adalah nilai bilangan bulat bertanda tangan 32-bit, yang dapat ditetapkan oleh pengembang untuk tujuan pelacakan versi.
writable_schema Pragma
Itu writable_schemapragma mendapat atau menetapkan kemampuan untuk mengubah tabel sistem. Berikut ini adalah sintaks sederhana.
PRAGMA writable_schema;
PRAGMA writable_schema = [true|false];Jika pragma ini disetel, tabel yang dimulai dengan sqlite_ dapat dibuat dan dimodifikasi, termasuk tabel sqlite_master. Berhati-hatilah saat menggunakan pragma karena dapat menyebabkan kerusakan database lengkap.
Batasan adalah aturan yang diberlakukan pada kolom data pada tabel. Ini digunakan untuk membatasi jenis data yang bisa masuk ke dalam tabel. Ini memastikan keakuratan dan keandalan data dalam database.
Batasan dapat berupa tingkat kolom atau tingkat tabel. Batasan tingkat kolom diterapkan hanya untuk satu kolom, sedangkan batasan tingkat tabel diterapkan ke seluruh tabel.
Berikut ini adalah batasan yang umum digunakan yang tersedia di SQLite.
NOT NULL Constraint - Memastikan bahwa kolom tidak boleh memiliki nilai NULL.
DEFAULT Constraint - Memberikan nilai default untuk kolom jika tidak ada yang ditentukan.
UNIQUE Constraint - Memastikan bahwa semua nilai dalam kolom berbeda.
PRIMARY Key - Secara unik mengidentifikasi setiap baris / record dalam tabel database.
CHECK Constraint - Memastikan bahwa semua nilai dalam kolom memenuhi kondisi tertentu.
NOT NULL Constraint
Secara default, kolom dapat menampung nilai NULL. Jika Anda tidak ingin kolom memiliki nilai NULL, maka Anda perlu menentukan batasan tersebut pada kolom ini dengan menetapkan bahwa NULL sekarang tidak diizinkan untuk kolom itu.
NULL tidak sama dengan tidak ada data, melainkan mewakili data yang tidak diketahui.
Contoh
Misalnya, pernyataan SQLite berikut membuat tabel baru yang disebut PERUSAHAAN dan menambahkan lima kolom, tiga di antaranya, ID dan NAMA dan USIA, menentukan untuk tidak menerima NULL.
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);Batasan DEFAULT
Batasan DEFAULT memberikan nilai default ke kolom ketika pernyataan INSERT INTO tidak memberikan nilai tertentu.
Contoh
Misalnya, pernyataan SQLite berikut membuat tabel baru bernama PERUSAHAAN dan menambahkan lima kolom. Di sini, kolom SALARY diatur ke 5000.00 secara default, jadi jika pernyataan INSERT INTO tidak memberikan nilai untuk kolom ini, maka secara default, kolom ini akan ditetapkan ke 5000.00.
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL DEFAULT 50000.00
);Kendala UNIK
Batasan UNIK mencegah dua rekaman memiliki nilai yang identik dalam kolom tertentu. Dalam tabel PERUSAHAAN, misalnya, Anda mungkin ingin mencegah dua orang atau lebih memiliki usia yang sama.
Contoh
Misalnya, pernyataan SQLite berikut membuat tabel baru bernama PERUSAHAAN dan menambahkan lima kolom. Di sini, kolom USIA diatur ke UNIK, sehingga Anda tidak bisa memiliki dua catatan dengan usia yang sama -
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL UNIQUE,
ADDRESS CHAR(50),
SALARY REAL DEFAULT 50000.00
);Kendala KUNCI UTAMA
Batasan PRIMARY KEY secara unik mengidentifikasi setiap record dalam tabel database. Ada lebih banyak kolom UNIK, tapi hanya satu kunci utama dalam sebuah tabel. Kunci utama penting saat mendesain tabel database. Kunci utama adalah ID unik.
Kami menggunakannya untuk merujuk ke baris tabel. Kunci utama menjadi kunci asing di tabel lain, saat membuat relasi antar tabel. Karena 'pengawasan pengkodean yang sudah berlangsung lama', kunci utama dapat berupa NULL di SQLite. Ini tidak terjadi dengan database lain.
Kunci utama adalah bidang dalam tabel yang secara unik mengidentifikasi setiap baris / rekaman dalam tabel database. Kunci utama harus berisi nilai unik. Kolom kunci utama tidak boleh memiliki nilai NULL.
Tabel hanya dapat memiliki satu kunci utama, yang mungkin terdiri dari satu atau beberapa bidang. Ketika beberapa bidang digunakan sebagai kunci utama, mereka disebut acomposite key.
Jika tabel memiliki kunci utama yang ditentukan di bidang mana pun, Anda tidak dapat memiliki dua rekaman yang memiliki nilai yang sama dari bidang itu.
Contoh
Anda sudah melihat berbagai contoh di atas dimana kami telah membuat tabel PERUSAHAAN dengan ID sebagai kunci utama.
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);PERIKSA Kendala
PERIKSA Batasan memungkinkan kondisi untuk memeriksa nilai yang dimasukkan ke dalam catatan. Jika kondisi bernilai false, record melanggar batasan dan tidak dimasukkan ke dalam tabel.
Contoh
Misalnya, SQLite berikut membuat tabel baru bernama PERUSAHAAN dan menambahkan lima kolom. Di sini, kami menambahkan kolom CHECK with SALARY, sehingga Anda tidak dapat memiliki SALARY Zero.
CREATE TABLE COMPANY3(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL CHECK(SALARY > 0)
);Menjatuhkan Kendala
SQLite mendukung subset terbatas dari ALTER TABLE. Perintah ALTER TABLE di SQLite memungkinkan pengguna untuk mengganti nama tabel atau menambahkan kolom baru ke tabel yang sudah ada. Tidak dimungkinkan untuk mengganti nama kolom, menghapus kolom, atau menambah atau menghapus batasan dari tabel.
SQLite Joinsklausa digunakan untuk menggabungkan rekaman dari dua atau lebih tabel dalam database. JOIN adalah cara untuk menggabungkan bidang dari dua tabel dengan menggunakan nilai yang sama untuk masing-masing.
SQL mendefinisikan tiga tipe utama gabungan -
- The CROSS JOIN
- The INNER JOIN
- OUTER JOIN
Sebelum kita melanjutkan, mari kita pertimbangkan dua tabel PERUSAHAAN dan DEPARTEMEN. Kita telah melihat pernyataan INSERT untuk mengisi tabel COMPANY. Jadi anggap saja daftar record yang tersedia di tabel COMPANY -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Tabel lain adalah DEPARTMENT dengan definisi berikut -
CREATE TABLE DEPARTMENT(
ID INT PRIMARY KEY NOT NULL,
DEPT CHAR(50) NOT NULL,
EMP_ID INT NOT NULL
);Berikut adalah daftar pernyataan INSERT untuk mengisi tabel DEPARTMENT -
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );Terakhir, kami memiliki daftar record berikut yang tersedia di tabel DEPARTMENT -
ID DEPT EMP_ID
---------- ---------- ----------
1 IT Billing 1
2 Engineering 2
3 Finance 7The CROSS JOIN
CROSS JOIN mencocokkan setiap baris dari tabel pertama dengan setiap baris dari tabel kedua. Jika tabel input masing-masing memiliki baris x dan y, tabel yang dihasilkan akan memiliki baris x * y. Karena CROSS JOINs memiliki potensi untuk menghasilkan tabel yang sangat besar, kehati-hatian harus dilakukan untuk hanya menggunakannya jika diperlukan.
Berikut adalah sintaks CROSS JOIN -
SELECT ... FROM table1 CROSS JOIN table2 ...Berdasarkan tabel di atas, Anda dapat menulis CROSS JOIN sebagai berikut -
sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;Kueri di atas akan menghasilkan hasil sebagai berikut -
EMP_ID NAME DEPT
---------- ---------- ----------
1 Paul IT Billing
2 Paul Engineering
7 Paul Finance
1 Allen IT Billing
2 Allen Engineering
7 Allen Finance
1 Teddy IT Billing
2 Teddy Engineering
7 Teddy Finance
1 Mark IT Billing
2 Mark Engineering
7 Mark Finance
1 David IT Billing
2 David Engineering
7 David Finance
1 Kim IT Billing
2 Kim Engineering
7 Kim Finance
1 James IT Billing
2 James Engineering
7 James FinanceThe INNER JOIN
INNER JOIN membuat tabel hasil baru dengan menggabungkan nilai kolom dari dua tabel (tabel1 dan tabel2) berdasarkan predikat gabungan. Kueri membandingkan setiap baris tabel1 dengan setiap baris tabel2 untuk menemukan semua pasangan baris yang memenuhi predikat gabungan. Jika predikat gabungan terpenuhi, nilai kolom untuk setiap pasangan baris A dan B yang cocok digabungkan menjadi baris hasil.
INNER JOIN adalah jenis gabungan yang paling umum dan default. Anda dapat menggunakan kata kunci INNER secara opsional.
Berikut ini adalah sintaks INNER JOIN -
SELECT ... FROM table1 [INNER] JOIN table2 ON conditional_expression ...Untuk menghindari redundansi dan mempersingkat frase, ketentuan INNER JOIN dapat dinyatakan dengan a USINGekspresi. Ekspresi ini menetapkan daftar satu atau beberapa kolom.
SELECT ... FROM table1 JOIN table2 USING ( column1 ,... ) ...A NATURAL JOIN mirip dengan a JOIN...USING, hanya itu secara otomatis menguji kesetaraan antara nilai setiap kolom yang ada di kedua tabel -
SELECT ... FROM table1 NATURAL JOIN table2...Berdasarkan tabel di atas, Anda dapat menulis INNER JOIN sebagai berikut -
sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;Kueri di atas akan menghasilkan hasil sebagai berikut -
EMP_ID NAME DEPT
---------- ---------- ----------
1 Paul IT Billing
2 Allen Engineering
7 James FinanceOUTER JOIN
OUTER JOIN adalah perpanjangan dari INNER JOIN. Meskipun standar SQL mendefinisikan tiga jenis OUTER JOIN: LEFT, RIGHT, dan FULL, SQLite hanya mendukungLEFT OUTER JOIN.
OUTER JOINs memiliki kondisi yang identik dengan INNER JOINs, diekspresikan menggunakan kata kunci ON, USING, atau NATURAL. Tabel hasil awal dihitung dengan cara yang sama. Setelah JOIN utama dihitung, OUTER JOIN akan mengambil baris yang tidak digabungkan dari satu atau kedua tabel, mengisi baris tersebut dengan NULL, dan menambahkannya ke tabel yang dihasilkan.
Berikut ini adalah sintaks LEFT OUTER JOIN -
SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...Untuk menghindari redundansi dan membuat frase lebih pendek, kondisi OUTER JOIN dapat dideklarasikan dengan ekspresi USING. Ekspresi ini menetapkan daftar satu atau beberapa kolom.
SELECT ... FROM table1 LEFT OUTER JOIN table2 USING ( column1 ,... ) ...Berdasarkan tabel di atas, Anda dapat menulis inner join sebagai berikut -
sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;Kueri di atas akan menghasilkan hasil sebagai berikut -
EMP_ID NAME DEPT
---------- ---------- ----------
1 Paul IT Billing
2 Allen Engineering
Teddy
Mark
David
Kim
7 James FinanceSQLite UNION klausa / operator digunakan untuk menggabungkan hasil dari dua atau lebih pernyataan SELECT tanpa mengembalikan baris duplikat.
Untuk menggunakan UNION, setiap SELECT harus memiliki jumlah kolom yang sama yang dipilih, jumlah ekspresi kolom yang sama, tipe data yang sama, dan memiliki urutan yang sama, tetapi mereka tidak harus memiliki panjang yang sama.
Sintaksis
Berikut ini adalah sintaks dasar UNION.
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]Di sini kondisi yang diberikan dapat berupa ekspresi apa pun berdasarkan kebutuhan Anda.
Contoh
Pertimbangkan dua tabel berikut, (a) tabel PERUSAHAAN sebagai berikut -
sqlite> select * from COMPANY;
ID NAME AGE ADDRESS SALARY
---------- -------------------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0(b) Tabel lainnya adalah DEPARTMENT sebagai berikut -
ID DEPT EMP_ID
---------- -------------------- ----------
1 IT Billing 1
2 Engineering 2
3 Finance 7
4 Engineering 3
5 Finance 4
6 Engineering 5
7 Finance 6Sekarang mari kita gabungkan dua tabel ini menggunakan pernyataan SELECT bersama dengan klausa UNION sebagai berikut -
sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID
UNION
SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;Ini akan menghasilkan hasil sebagai berikut.
EMP_ID NAME DEPT
---------- -------------------- ----------
1 Paul IT Billing
2 Allen Engineering
3 Teddy Engineering
4 Mark Finance
5 David Engineering
6 Kim Finance
7 James FinanceKlausul UNION ALL
Operator UNION ALL digunakan untuk menggabungkan hasil dari dua pernyataan SELECT termasuk baris duplikat.
Aturan yang sama yang berlaku untuk UNION juga berlaku untuk operator UNION ALL.
Sintaksis
Berikut ini adalah sintaks dasar UNION ALL.
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION ALL
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]Di sini kondisi yang diberikan dapat berupa ekspresi apa pun berdasarkan kebutuhan Anda.
Contoh
Sekarang, mari kita gabungkan dua tabel yang disebutkan di atas dalam pernyataan SELECT kita sebagai berikut -
sqlite> SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID
UNION ALL
SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;Ini akan menghasilkan hasil sebagai berikut.
EMP_ID NAME DEPT
---------- -------------------- ----------
1 Paul IT Billing
2 Allen Engineering
3 Teddy Engineering
4 Mark Finance
5 David Engineering
6 Kim Finance
7 James Finance
1 Paul IT Billing
2 Allen Engineering
3 Teddy Engineering
4 Mark Finance
5 David Engineering
6 Kim Finance
7 James FinanceSQLite NULLadalah istilah yang digunakan untuk mewakili nilai yang hilang. Nilai NULL dalam tabel adalah nilai di bidang yang tampaknya kosong.
Bidang dengan nilai NULL adalah bidang tanpa nilai. Sangat penting untuk memahami bahwa nilai NULL berbeda dari nilai nol atau bidang yang berisi spasi.
Sintaksis
Berikut ini adalah sintaks dasar penggunaan NULL sambil membuat tabel.
SQLite> CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);Sini, NOT NULLmenandakan bahwa kolom harus selalu menerima nilai eksplisit dari tipe data yang diberikan. Ada dua kolom di mana kami tidak menggunakan NOT NULL yang berarti kolom ini bisa menjadi NULL.
Bidang dengan nilai NULL adalah bidang yang dibiarkan kosong selama pembuatan catatan.
Contoh
Nilai NULL dapat menyebabkan masalah ketika memilih data, karena ketika membandingkan nilai yang tidak diketahui dengan nilai lain, hasilnya selalu tidak diketahui dan tidak termasuk dalam hasil akhir. Pertimbangkan tabel berikut, PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mari kita gunakan pernyataan UPDATE untuk menetapkan beberapa nilai nullable sebagai NULL sebagai berikut -
sqlite> UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);Sekarang, tabel COMPANY akan memiliki record berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22
7 James 24Selanjutnya, mari kita lihat penggunaan IS NOT NULL operator untuk mendaftar semua record di mana GAJI bukan NULL.
sqlite> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM COMPANY
WHERE SALARY IS NOT NULL;Pernyataan SQLite di atas akan menghasilkan hasil sebagai berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Berikut adalah penggunaan IS NULL operator, yang akan mencantumkan semua record di mana SALARY adalah NULL.
sqlite> SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM COMPANY
WHERE SALARY IS NULL;Pernyataan SQLite di atas akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
6 Kim 22
7 James 24Anda dapat mengganti nama tabel atau kolom untuk sementara dengan memberikan nama lain, yang dikenal sebagai ALIAS. Penggunaan alias tabel berarti mengganti nama tabel dalam pernyataan SQLite tertentu. Mengganti nama adalah perubahan sementara dan nama tabel sebenarnya tidak berubah di database.
Alias ​​kolom digunakan untuk mengganti nama kolom tabel untuk tujuan kueri SQLite tertentu.
Sintaksis
Berikut ini adalah sintaks dasar table alias.
SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];Berikut ini adalah sintaks dasar column alias.
SELECT column_name AS alias_name
FROM table_name
WHERE [condition];Contoh
Perhatikan dua tabel berikut, (a) tabel PERUSAHAAN adalah sebagai berikut -
sqlite> select * from COMPANY;
ID NAME AGE ADDRESS SALARY
---------- -------------------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0(b) Tabel lainnya adalah DEPARTMENT sebagai berikut -
ID DEPT EMP_ID
---------- -------------------- ----------
1 IT Billing 1
2 Engineering 2
3 Finance 7
4 Engineering 3
5 Finance 4
6 Engineering 5
7 Finance 6Sekarang, berikut adalah penggunaan TABLE ALIAS di mana kami menggunakan C dan D sebagai alias untuk tabel PERUSAHAAN dan DEPARTEMEN masing-masing -
sqlite> SELECT C.ID, C.NAME, C.AGE, D.DEPT
FROM COMPANY AS C, DEPARTMENT AS D
WHERE C.ID = D.EMP_ID;Pernyataan SQLite di atas akan menghasilkan hasil sebagai berikut -
ID NAME AGE DEPT
---------- ---------- ---------- ----------
1 Paul 32 IT Billing
2 Allen 25 Engineering
3 Teddy 23 Engineering
4 Mark 25 Finance
5 David 27 Engineering
6 Kim 22 Finance
7 James 24 FinancePerhatikan contoh penggunaan COLUMN ALIAS di mana COMPANY_ID adalah alias kolom ID dan COMPANY_NAME adalah alias kolom nama.
sqlite> SELECT C.ID AS COMPANY_ID, C.NAME AS COMPANY_NAME, C.AGE, D.DEPT
FROM COMPANY AS C, DEPARTMENT AS D
WHERE C.ID = D.EMP_ID;Pernyataan SQLite di atas akan menghasilkan hasil sebagai berikut -
COMPANY_ID COMPANY_NAME AGE DEPT
---------- ------------ ---------- ----------
1 Paul 32 IT Billing
2 Allen 25 Engineering
3 Teddy 23 Engineering
4 Mark 25 Finance
5 David 27 Engineering
6 Kim 22 Finance
7 James 24 FinanceSQLite Triggersadalah fungsi callback database, yang secara otomatis dijalankan / dipanggil ketika peristiwa database tertentu terjadi. Berikut adalah poin penting tentang pemicu SQLite -
Pemicu SQLite dapat ditentukan untuk diaktifkan setiap kali terjadi DELETE, INSERT atau UPDATE dari tabel database tertentu atau setiap kali UPDATE terjadi pada satu atau beberapa kolom tertentu dari sebuah tabel.
Saat ini, SQLite hanya mendukung pemicu UNTUK SETIAP ROW, bukan pemicu UNTUK SETIAP PERNYATAAN. Karenanya, menentukan secara eksplisit UNTUK SETIAP BARIS adalah opsional.
Klausa WHEN dan tindakan pemicu dapat mengakses elemen baris yang sedang disisipkan, dihapus, atau diperbarui menggunakan referensi formulir NEW.column-name dan OLD.column-name, dengan nama kolom adalah nama kolom dari tabel yang terkait dengan pemicu.
Jika klausa WHEN diberikan, pernyataan SQL yang ditentukan hanya dieksekusi untuk baris yang klausa WHEN-nya benar. Jika tidak ada klausa WHEN yang diberikan, pernyataan SQL dijalankan untuk semua baris.
Kata kunci BEFORE atau AFTER menentukan kapan tindakan pemicu akan dijalankan relatif terhadap penyisipan, modifikasi, atau penghapusan baris terkait.
Pemicu secara otomatis dihilangkan saat tabel yang terkait dengan dijatuhkan.
Tabel yang akan dimodifikasi harus ada dalam database yang sama dengan tabel atau tampilan tempat pemicu dilampirkan dan harus digunakan saja tablename tidak database.tablename.
Fungsi SQL khusus RAISE () dapat digunakan dalam program pemicu untuk memunculkan pengecualian.
Sintaksis
Berikut ini adalah sintaks dasar pembuatan file trigger.
CREATE TRIGGER trigger_name [BEFORE|AFTER] event_name
ON table_name
BEGIN
-- Trigger logic goes here....
END;Sini, event_namebisa berupa operasi database INSERT, DELETE, dan UPDATE pada tabel yang disebutkantable_name. Anda secara opsional dapat menentukan UNTUK SETIAP BARIS setelah nama tabel.
Berikut ini adalah sintaks untuk membuat pemicu pada operasi UPDATE pada satu atau beberapa kolom tertentu dari sebuah tabel.
CREATE TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name
ON table_name
BEGIN
-- Trigger logic goes here....
END;Contoh
Mari kita pertimbangkan kasus di mana kita ingin menyimpan uji coba audit untuk setiap catatan yang dimasukkan ke dalam tabel PERUSAHAAN, yang baru kita buat sebagai berikut (Hapus tabel PERUSAHAAN jika Anda sudah memilikinya).
sqlite> CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);Untuk menjaga uji coba audit, kami akan membuat tabel baru bernama AUDIT di mana pesan log akan disisipkan, setiap kali ada entri dalam tabel PERUSAHAAN untuk catatan baru.
sqlite> CREATE TABLE AUDIT(
EMP_ID INT NOT NULL,
ENTRY_DATE TEXT NOT NULL
);Di sini, ID adalah ID record AUDIT, dan EMP_ID adalah ID yang akan berasal dari tabel COMPANY dan DATE akan menyimpan stempel waktu kapan record akan dibuat di tabel COMPANY. Sekarang mari kita buat pemicu pada tabel PERUSAHAAN sebagai berikut -
sqlite> CREATE TRIGGER audit_log AFTER INSERT
ON COMPANY
BEGIN
INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, datetime('now'));
END;Sekarang, kita akan memulai pekerjaan yang sebenarnya, Mari mulai memasukkan catatan ke dalam tabel PERUSAHAAN yang seharusnya menghasilkan catatan log audit di tabel AUDIT. Buat satu record dalam tabel COMPANY sebagai berikut -
sqlite> INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );Ini akan membuat satu record dalam tabel COMPANY, yaitu sebagai berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0Pada waktu yang sama, satu record akan dibuat dalam tabel AUDIT. Record ini adalah hasil dari sebuah trigger, yang telah kita buat pada operasi INSERT di tabel COMPANY. Demikian pula, Anda dapat membuat pemicu pada operasi UPDATE dan DELETE berdasarkan kebutuhan Anda.
EMP_ID ENTRY_DATE
---------- -------------------
1 2013-04-05 06:26:00Daftar Pemicu
Anda dapat mencantumkan semua pemicu dari sqlite_master tabel sebagai berikut -
sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger';Pernyataan SQLite di atas hanya akan mencantumkan satu entri sebagai berikut -
name
----------
audit_logJika Anda ingin membuat daftar pemicu pada tabel tertentu, gunakan klausa AND dengan nama tabel sebagai berikut -
sqlite> SELECT name FROM sqlite_master
WHERE type = 'trigger' AND tbl_name = 'COMPANY';Pernyataan SQLite di atas juga akan mencantumkan hanya satu entri sebagai berikut -
name
----------
audit_logMenjatuhkan Pemicu
Berikut adalah perintah DROP, yang dapat digunakan untuk menjatuhkan pemicu yang ada.
sqlite> DROP TRIGGER trigger_name;Indeks adalah tabel pencarian khusus yang dapat digunakan mesin pencari database untuk mempercepat pengambilan data. Sederhananya, sebuahindexadalah penunjuk ke data dalam tabel. Indeks dalam database sangat mirip dengan indeks di bagian belakang buku.
Misalnya, jika Anda ingin mereferensikan semua halaman dalam buku yang membahas topik tertentu, pertama-tama Anda merujuk ke indeks, yang mencantumkan semua topik menurut abjad dan kemudian merujuk ke satu atau beberapa nomor halaman tertentu.
Indeks membantu mempercepat kueri SELECT dan klausa WHERE, tetapi memperlambat input data, dengan pernyataan UPDATE dan INSERT. Indeks dapat dibuat atau dihapus tanpa berpengaruh pada data.
Membuat indeks melibatkan pernyataan CREATE INDEX, yang memungkinkan Anda memberi nama indeks, menentukan tabel dan kolom atau kolom mana yang akan diindeks, dan untuk menunjukkan apakah indeks dalam urutan naik atau turun.
Indeks juga bisa unik, mirip dengan batasan UNIK, di mana indeks mencegah entri duplikat dalam kolom atau kombinasi kolom yang memiliki indeks.
Perintah CREATE INDEX
Berikut ini adalah sintaks dasar CREATE INDEX.
CREATE INDEX index_name ON table_name;Indeks Kolom Tunggal
Indeks satu kolom adalah indeks yang dibuat hanya berdasarkan satu kolom tabel. Sintaks dasarnya adalah sebagai berikut -
CREATE INDEX index_name
ON table_name (column_name);Indeks Unik
Indeks unik digunakan tidak hanya untuk kinerja, tetapi juga untuk integritas data. Indeks unik tidak mengizinkan nilai duplikat dimasukkan ke dalam tabel. Sintaks dasarnya adalah sebagai berikut -
CREATE UNIQUE INDEX index_name
on table_name (column_name);Indeks Komposit
Indeks komposit adalah indeks pada dua atau lebih kolom dari sebuah tabel. Sintaks dasarnya adalah sebagai berikut -
CREATE INDEX index_name
on table_name (column1, column2);Apakah akan membuat indeks kolom tunggal atau indeks gabungan, pertimbangkan kolom yang mungkin sering Anda gunakan dalam klausa WHERE kueri sebagai kondisi filter.
Jika hanya ada satu kolom yang digunakan, indeks satu kolom harus menjadi pilihan. Jika ada dua atau lebih kolom yang sering digunakan di klausa WHERE sebagai filter, indeks komposit akan menjadi pilihan terbaik.
Indeks Implisit
Indeks implisit adalah indeks yang secara otomatis dibuat oleh server database saat objek dibuat. Indeks secara otomatis dibuat untuk batasan kunci utama dan batasan unik.
Example
Berikut adalah contoh di mana kita akan membuat indeks di tabel PERUSAHAAN untuk kolom gaji -
sqlite> CREATE INDEX salary_index ON COMPANY (salary);Sekarang, mari kita daftarkan semua indeks yang tersedia di tabel PERUSAHAAN menggunakan .indices perintah sebagai berikut -
sqlite> .indices COMPANYIni akan menghasilkan hasil sebagai berikut, di mana sqlite_autoindex_COMPANY_1 adalah indeks implisit yang dibuat saat tabel itu sendiri dibuat.
salary_index
sqlite_autoindex_COMPANY_1Anda dapat membuat daftar semua database indeks sebagai berikut -
sqlite> SELECT * FROM sqlite_master WHERE type = 'index';Perintah DROP INDEX
Indeks dapat dihapus menggunakan SQLite DROPperintah. Perhatian harus diberikan saat menurunkan indeks karena kinerja mungkin melambat atau ditingkatkan.
Berikut ini adalah sintaks dasarnya sebagai berikut -
DROP INDEX index_name;Anda dapat menggunakan pernyataan berikut untuk menghapus indeks yang dibuat sebelumnya.
sqlite> DROP INDEX salary_index;Kapan Indeks Harus Dihindari?
Meskipun indeks dimaksudkan untuk meningkatkan kinerja database, ada kalanya indeks harus dihindari. Panduan berikut menunjukkan kapan penggunaan indeks harus dipertimbangkan kembali.
Indeks tidak boleh digunakan di -
- Meja kecil.
- Tabel yang memiliki operasi penyisipan atau pembaruan batch besar yang sering.
- Kolom yang berisi nilai NULL dalam jumlah tinggi.
- Kolom yang sering dimanipulasi.
Klausa "INDEXED BY index-name" menetapkan bahwa indeks bernama harus digunakan untuk mencari nilai pada tabel sebelumnya.
Jika nama indeks tidak ada atau tidak dapat digunakan untuk kueri, maka persiapan pernyataan SQLite gagal.
Klausul "NOT INDEXED" menentukan bahwa tidak ada indeks yang digunakan saat mengakses tabel sebelumnya, termasuk indeks tersirat yang dibuat oleh batasan UNIQUE dan PRIMARY KEY.
Namun, INTEGER PRIMARY KEY masih dapat digunakan untuk mencari entri meskipun "NOT INDEXED" ditentukan.
Sintaksis
Berikut ini adalah sintaks untuk klausa INDEXED BY dan dapat digunakan dengan pernyataan DELETE, UPDATE atau SELECT.
SELECT|DELETE|UPDATE column1, column2...
INDEXED BY (index_name)
table_name
WHERE (CONDITION);Contoh
Pertimbangkan tabel PERUSAHAAN Kami akan membuat indeks dan menggunakannya untuk melakukan operasi INDEXED BY.
sqlite> CREATE INDEX salary_index ON COMPANY(salary);
sqlite>Sekarang memilih data dari tabel PERUSAHAAN Anda dapat menggunakan klausa INDEXED BY sebagai berikut -
sqlite> SELECT * FROM COMPANY INDEXED BY salary_index WHERE salary > 5000;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
7 James 24 Houston 10000.0
2 Allen 25 Texas 15000.0
1 Paul 32 California 20000.0
3 Teddy 23 Norway 20000.0
6 Kim 22 South-Hall 45000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0SQLite ALTER TABLEperintah mengubah tabel yang ada tanpa melakukan dump penuh dan memuat ulang data. Anda dapat mengganti nama tabel menggunakan pernyataan ALTER TABLE dan kolom tambahan dapat ditambahkan dalam tabel yang sudah ada menggunakan pernyataan ALTER TABLE.
Tidak ada operasi lain yang didukung oleh perintah ALTER TABLE di SQLite kecuali mengganti nama tabel dan menambahkan kolom di tabel yang sudah ada.
Sintaksis
Berikut ini adalah sintaks dasar ALTER TABLE untuk MENGGANTI nama tabel yang sudah ada.
ALTER TABLE database_name.table_name RENAME TO new_table_name;Berikut ini adalah sintaks dasar ALTER TABLE untuk menambahkan kolom baru di tabel yang sudah ada.
ALTER TABLE database_name.table_name ADD COLUMN column_def...;Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Sekarang, mari kita coba mengganti nama tabel ini menggunakan pernyataan ALTER TABLE sebagai berikut -
sqlite> ALTER TABLE COMPANY RENAME TO OLD_COMPANY;Pernyataan SQLite di atas akan mengganti nama tabel COMPANY menjadi OLD_COMPANY. Sekarang, mari kita coba menambahkan kolom baru di tabel OLD_COMPANY sebagai berikut -
sqlite> ALTER TABLE OLD_COMPANY ADD COLUMN SEX char(1);Tabel COMPANY sekarang berubah dan berikut akan menjadi output dari pernyataan SELECT.
ID NAME AGE ADDRESS SALARY SEX
---------- ---------- ---------- ---------- ---------- ---
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Perlu dicatat bahwa kolom yang baru ditambahkan diisi dengan nilai NULL.
Sayangnya, kami tidak memiliki perintah TRUNCATE TABLE di SQLite, tetapi Anda dapat menggunakan SQLite DELETE perintah untuk menghapus data lengkap dari tabel yang ada, meskipun disarankan untuk menggunakan perintah DROP TABLE untuk menghapus tabel lengkap dan membuatnya kembali.
Sintaksis
Berikut ini adalah sintaks dasar dari perintah DELETE.
sqlite> DELETE FROM table_name;Berikut ini adalah sintaks dasar dari DROP TABLE.
sqlite> DROP TABLE table_name;Jika Anda menggunakan perintah DELETE TABLE untuk menghapus semua record, disarankan untuk menggunakan VACUUM perintah untuk membersihkan ruang yang tidak digunakan.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut contoh pemotongan tabel di atas -
SQLite> DELETE FROM COMPANY;
SQLite> VACUUM;Sekarang, tabel COMPANY terpotong sepenuhnya dan tidak ada yang akan menjadi output dari pernyataan SELECT.
Tampilan tidak lebih dari pernyataan SQLite yang disimpan dalam database dengan nama terkait. Ini sebenarnya adalah komposisi tabel dalam bentuk kueri SQLite yang telah ditentukan sebelumnya.
Tampilan dapat berisi semua baris tabel atau baris yang dipilih dari satu atau beberapa tabel. Tampilan dapat dibuat dari satu atau banyak tabel yang bergantung pada kueri SQLite tertulis untuk membuat tampilan.
Tampilan yang merupakan jenis tabel virtual, memungkinkan pengguna untuk -
Membuat struktur data dengan cara yang menurut pengguna atau kelas pengguna alami atau intuitif.
Batasi akses ke data sedemikian rupa sehingga pengguna hanya dapat melihat data terbatas, bukan tabel lengkap.
Meringkas data dari berbagai tabel, yang dapat digunakan untuk menghasilkan laporan.
Tampilan SQLite bersifat hanya baca dan karenanya Anda mungkin tidak dapat menjalankan pernyataan DELETE, INSERT atau UPDATE pada tampilan. Namun, Anda bisa membuat pemicu pada tampilan yang diaktifkan saat mencoba MENGHAPUS, MENYISIPKAN, atau MEMPERBARUI tampilan dan melakukan apa yang Anda perlukan dalam isi pemicu.
Membuat Tampilan
Tampilan SQLite dibuat menggunakan CREATE VIEWpernyataan. Tampilan SQLite dapat dibuat dari satu tabel, beberapa tabel, atau tampilan lain.
Berikut ini adalah sintaks dasar CREATE VIEW.
CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];Anda dapat menyertakan beberapa tabel dalam pernyataan SELECT Anda dengan cara yang sama seperti Anda menggunakannya dalam kueri SQL SELECT normal. Jika kata kunci TEMP atau TEMPORARY opsional ada, tampilan akan dibuat dalam database temp.
Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Berikut adalah contoh membuat view dari tabel COMPANY. Tampilan ini hanya akan digunakan untuk memiliki beberapa kolom dari tabel PERUSAHAAN.
sqlite> CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM COMPANY;Anda sekarang dapat membuat kueri COMPANY_VIEW dengan cara yang sama seperti Anda membuat kueri tabel sebenarnya. Berikut adalah contohnya -
sqlite> SELECT * FROM COMPANY_VIEW;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE
---------- ---------- ----------
1 Paul 32
2 Allen 25
3 Teddy 23
4 Mark 25
5 David 27
6 Kim 22
7 James 24Menjatuhkan Tampilan
Untuk melepaskan tampilan, cukup gunakan pernyataan DROP VIEW dengan view_name. Sintaks dasar DROP VIEW adalah sebagai berikut -
sqlite> DROP VIEW view_name;Perintah berikut akan menghapus tampilan COMPANY_VIEW, yang kita buat di bagian terakhir.
sqlite> DROP VIEW COMPANY_VIEW;Transaksi adalah unit kerja yang dilakukan terhadap database. Transaksi adalah unit atau urutan pekerjaan yang diselesaikan dalam urutan logis, baik secara manual oleh pengguna atau secara otomatis oleh beberapa jenis program database.
Transaksi adalah penyebaran satu atau lebih perubahan ke database. Misalnya, jika Anda membuat, memperbarui, atau menghapus record dari tabel, maka Anda sedang melakukan transaksi di atas tabel. Penting untuk mengontrol transaksi untuk memastikan integritas data dan untuk menangani kesalahan database.
Praktisnya, Anda akan menggabungkan banyak kueri SQLite ke dalam sebuah grup dan Anda akan mengeksekusi semuanya bersama sebagai bagian dari transaksi.
Sifat Transaksi
Transaksi memiliki empat sifat standar berikut, biasanya disebut dengan singkatan ACID.
Atomicity- Memastikan bahwa semua operasi dalam unit kerja diselesaikan dengan sukses; jika tidak, transaksi dibatalkan pada titik kegagalan dan operasi sebelumnya digulung kembali ke keadaan semula.
Consistency - Memastikan bahwa database dengan benar mengubah status setelah transaksi berhasil dilakukan.
Isolation - Memungkinkan transaksi untuk beroperasi secara independen dan transparan satu sama lain.
Durability - Memastikan bahwa hasil atau efek dari transaksi yang dilakukan tetap ada jika terjadi kegagalan sistem.
Kontrol Transaksi
Berikut adalah perintah berikut yang digunakan untuk mengontrol transaksi:
BEGIN TRANSACTION - Untuk memulai transaksi.
COMMIT - Untuk menyimpan perubahan, Anda dapat menggunakan alternatif END TRANSACTION perintah.
ROLLBACK - Untuk mengembalikan perubahan.
Perintah kontrol transaksional hanya digunakan dengan perintah DML INSERT, UPDATE, dan DELETE. Mereka tidak dapat digunakan saat membuat tabel atau menjatuhkannya karena operasi ini secara otomatis dilakukan dalam database.
MULAI Perintah TRANSAKSI
Transaksi dapat dimulai menggunakan BEGIN TRANSACTION atau cukup BEGIN perintah. Transaksi seperti itu biasanya bertahan sampai perintah COMMIT atau ROLLBACK berikutnya ditemukan. Namun, transaksi juga akan ROLLBACK jika database ditutup atau jika terjadi kesalahan. Berikut ini adalah sintaks sederhana untuk memulai transaksi.
BEGIN;
or
BEGIN TRANSACTION;KOMIT KOMIT
Perintah COMMIT adalah perintah transaksional yang digunakan untuk menyimpan perubahan yang dilakukan oleh transaksi ke database.
Perintah COMMIT menyimpan semua transaksi ke database sejak perintah COMMIT atau ROLLBACK terakhir.
Berikut adalah sintaks untuk perintah COMMIT.
COMMIT;
or
END TRANSACTION;Perintah ROLLBACK
Perintah ROLLBACK adalah perintah transaksional yang digunakan untuk membatalkan transaksi yang belum disimpan ke database.
Perintah ROLLBACK hanya dapat digunakan untuk membatalkan transaksi sejak perintah COMMIT atau ROLLBACK terakhir dikeluarkan.
Berikut ini adalah sintaks untuk perintah ROLLBACK.
ROLLBACK;Example
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Sekarang, mari kita mulai transaksi dan menghapus record dari tabel yang memiliki age = 25. Kemudian, gunakan perintah ROLLBACK untuk membatalkan semua perubahan.
sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> ROLLBACK;Sekarang, jika Anda memeriksa tabel PERUSAHAAN, masih ada catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Mari kita mulai transaksi lain dan hapus catatan dari tabel yang memiliki age = 25 dan terakhir kita menggunakan perintah COMMIT untuk melakukan semua perubahan.
sqlite> BEGIN;
sqlite> DELETE FROM COMPANY WHERE AGE = 25;
sqlite> COMMIT;Jika Anda sekarang memeriksa tabel PERUSAHAAN masih memiliki catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
3 Teddy 23 Norway 20000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Kueri Subkueri atau Dalam atau Kueri bersarang adalah kueri dalam kueri SQLite lain dan disematkan di dalam klausa WHERE.
Sebuah subquery digunakan untuk mengembalikan data yang akan digunakan dalam query utama sebagai syarat untuk lebih membatasi data yang akan diambil.
Subkueri dapat digunakan dengan pernyataan SELECT, INSERT, UPDATE, dan DELETE bersama dengan operator seperti =, <,>,> =, <=, IN, BETWEEN, dll.
Ada beberapa aturan yang harus diikuti subkueri -
Subkueri harus diapit dalam tanda kurung.
Subkueri hanya dapat memiliki satu kolom di klausa SELECT, kecuali beberapa kolom berada di kueri utama untuk subkueri untuk membandingkan kolom yang dipilihnya.
ORDER BY tidak dapat digunakan dalam subkueri, meskipun kueri utama dapat menggunakan ORDER BY. GROUP BY dapat digunakan untuk melakukan fungsi yang sama seperti ORDER BY di subkueri.
Subkueri yang mengembalikan lebih dari satu baris hanya dapat digunakan dengan beberapa operator nilai, seperti operator IN.
BETWEEN operator tidak dapat digunakan dengan subquery; namun, BETWEEN dapat digunakan dalam subquery.
Subkueri dengan Pernyataan SELECT
Subkueri paling sering digunakan dengan pernyataan SELECT. Sintaks dasarnya adalah sebagai berikut -
SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
(SELECT column_name [, column_name ]
FROM table1 [, table2 ]
[WHERE])Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Sekarang, mari kita periksa sub-query berikut dengan pernyataan SELECT.
sqlite> SELECT *
FROM COMPANY
WHERE ID IN (SELECT ID
FROM COMPANY
WHERE SALARY > 45000) ;Ini akan menghasilkan hasil sebagai berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0Subkueri dengan Pernyataan INSERT
Subkueri juga bisa digunakan dengan pernyataan INSERT. Pernyataan INSERT menggunakan data yang dikembalikan dari subkueri untuk dimasukkan ke dalam tabel lain. Data yang dipilih di subkueri dapat dimodifikasi dengan salah satu fungsi karakter, tanggal, atau angka.
Berikut ini adalah sintaks dasarnya sebagai berikut -
INSERT INTO table_name [ (column1 [, column2 ]) ]
SELECT [ *|column1 [, column2 ]
FROM table1 [, table2 ]
[ WHERE VALUE OPERATOR ]Contoh
Pertimbangkan tabel COMPANY_BKP dengan struktur yang mirip dengan tabel COMPANY dan dapat dibuat menggunakan CREATE TABLE yang sama menggunakan COMPANY_BKP sebagai nama tabel. Untuk menyalin tabel COMPANY lengkap ke COMPANY_BKP, berikut adalah sintaksnya -
sqlite> INSERT INTO COMPANY_BKP
SELECT * FROM COMPANY
WHERE ID IN (SELECT ID
FROM COMPANY) ;Subkueri dengan Pernyataan UPDATE
Subkueri dapat digunakan bersama dengan pernyataan UPDATE. Salah satu atau beberapa kolom dalam tabel dapat diperbarui saat menggunakan subkueri dengan pernyataan UPDATE.
Berikut ini adalah sintaks dasarnya sebagai berikut -
UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]Contoh
Dengan asumsi, kami memiliki tabel COMPANY_BKP yang merupakan cadangan dari tabel COMPANY.
Contoh berikut memperbarui GAJI sebesar 0,50 kali dalam tabel PERUSAHAAN untuk semua pelanggan, yang AGE-nya lebih besar dari atau sama dengan 27.
sqlite> UPDATE COMPANY
SET SALARY = SALARY * 0.50
WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
WHERE AGE >= 27 );Ini akan berdampak pada dua baris dan akhirnya tabel COMPANY akan memiliki record berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 10000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 42500.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Subkueri dengan Pernyataan DELETE
Subquery dapat digunakan bersama dengan pernyataan DELETE seperti pernyataan lain yang disebutkan di atas.
Berikut ini adalah sintaks dasarnya sebagai berikut -
DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]Contoh
Dengan asumsi, kami memiliki tabel COMPANY_BKP yang merupakan cadangan dari tabel COMPANY.
Contoh berikut menghapus catatan dari tabel PERUSAHAAN untuk semua pelanggan yang AGE-nya lebih besar dari atau sama dengan 27.
sqlite> DELETE FROM COMPANY
WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
WHERE AGE > 27 );Ini akan memengaruhi dua baris dan akhirnya tabel COMPANY akan memiliki record berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 42500.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0SQLite AUTOINCREMENTadalah kata kunci yang digunakan untuk menambah nilai bidang secara otomatis di tabel. Kita dapat menaikkan nilai bidang secara otomatis dengan menggunakanAUTOINCREMENT kata kunci saat membuat tabel dengan nama kolom tertentu untuk penambahan otomatis.
Kata kunci AUTOINCREMENT hanya dapat digunakan dengan bidang INTEGER.
Sintaksis
Penggunaan dasar AUTOINCREMENT kata kunci adalah sebagai berikut -
CREATE TABLE table_name(
column1 INTEGER AUTOINCREMENT,
column2 datatype,
column3 datatype,
.....
columnN datatype,
);Contoh
Pertimbangkan tabel COMPANY yang akan dibuat sebagai berikut -
sqlite> CREATE TABLE COMPANY(
ID INTEGER PRIMARY KEY AUTOINCREMENT,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);Sekarang, masukkan record berikut ke dalam tabel COMPANY -
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Allen', 25, 'Texas', 15000.00 );
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ('Teddy', 23, 'Norway', 20000.00 );
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Mark', 25, 'Rich-Mond ', 65000.00 );
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'David', 27, 'Texas', 85000.00 );
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'Kim', 22, 'South-Hall', 45000.00 );
INSERT INTO COMPANY (NAME,AGE,ADDRESS,SALARY)
VALUES ( 'James', 24, 'Houston', 10000.00 );Ini akan memasukkan 7 tupel ke dalam tabel PERUSAHAAN dan PERUSAHAAN akan memiliki catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Jika Anda mengambil input pengguna melalui halaman web dan memasukkannya ke dalam database SQLite, ada kemungkinan Anda membiarkan diri Anda terbuka lebar untuk masalah keamanan yang dikenal sebagai SQL Injection. Di bab ini, Anda akan mempelajari cara membantu mencegah hal ini terjadi dan membantu Anda mengamankan skrip dan pernyataan SQLite Anda.
Injeksi biasanya terjadi saat Anda meminta masukan dari pengguna, seperti nama mereka, dan alih-alih nama, mereka memberi Anda pernyataan SQLite yang akan Anda jalankan tanpa sadar di database Anda.
Jangan pernah mempercayai data yang diberikan pengguna, proses data ini hanya setelah validasi; biasanya, ini dilakukan dengan pencocokan pola. Dalam contoh berikut, nama pengguna dibatasi untuk karakter alfanumerik ditambah garis bawah dan dengan panjang antara 8 dan 20 karakter - ubah aturan ini sesuai kebutuhan.
if (preg_match("/^\w{8,20}$/", $_GET['username'], $matches)){ $db = new SQLiteDatabase('filename');
$result = @$db->query("SELECT * FROM users WHERE username = $matches[0]");
} else {
echo "username not accepted";
}Untuk mendemonstrasikan masalahnya, pertimbangkan kutipan ini -
$name = "Qadir'; DELETE FROM users;";
@$db->query("SELECT * FROM users WHERE username = '{$name}'");Panggilan fungsi seharusnya mengambil catatan dari tabel pengguna di mana kolom nama cocok dengan nama yang ditentukan oleh pengguna. Dalam keadaan normal,$namehanya akan berisi karakter alfanumerik dan mungkin spasi, seperti string ilia. Namun dalam kasus ini, dengan menambahkan kueri yang sepenuhnya baru ke $ name, panggilan ke database berubah menjadi bencana: kueri DELETE yang dimasukkan menghapus semua rekaman dari pengguna.
Ada antarmuka database yang tidak mengizinkan penumpukan kueri atau menjalankan beberapa kueri dalam satu panggilan fungsi. Jika Anda mencoba menumpuk kueri, panggilan gagal tetapi SQLite dan PostgreSQL, dengan senang hati menjalankan kueri bertumpuk, mengeksekusi semua kueri yang disediakan dalam satu string dan membuat masalah keamanan yang serius.
Mencegah Injeksi SQL
Anda dapat menangani semua karakter escape dengan cerdas dalam bahasa skrip seperti PERL dan PHP. Bahasa pemrograman PHP menyediakan fungsi tersebutstring sqlite_escape_string() untuk menghindari karakter masukan yang khusus untuk SQLite.
if (get_magic_quotes_gpc()) {
$name = sqlite_escape_string($name);
}
$result = @$db->query("SELECT * FROM users WHERE username = '{$name}'");Meskipun pengkodean membuatnya aman untuk memasukkan data, itu akan membuat perbandingan teks sederhana dan LIKE klausa dalam kueri Anda tidak dapat digunakan untuk kolom yang berisi data biner.
Note - addslashes()TIDAK boleh digunakan untuk mengutip string Anda untuk kueri SQLite; itu akan menyebabkan hasil yang aneh saat mengambil data Anda.
Pernyataan SQLite dapat diawali dengan kata kunci "MENJELASKAN" atau dengan frasa "MENJELASKAN RENCANA KUERI" yang digunakan untuk menjelaskan rincian tabel.
Salah satu modifikasi menyebabkan pernyataan SQLite berperilaku sebagai kueri dan mengembalikan informasi tentang bagaimana pernyataan SQLite akan beroperasi jika JELASKAN kata kunci atau frase telah dihilangkan.
Keluaran dari EXPLAIN and EXPLAIN QUERY PLAN dimaksudkan untuk analisis interaktif dan pemecahan masalah saja.
Detail format keluaran dapat berubah dari satu rilis SQLite ke rilis berikutnya.
Aplikasi tidak boleh menggunakan EXPLAIN or EXPLAIN QUERY PLAN karena perilaku persisnya bervariasi dan hanya didokumentasikan sebagian.
Sintaksis
sintaks untuk EXPLAIN adalah sebagai berikut -
EXPLAIN [SQLite Query]sintaks untuk EXPLAIN QUERY PLAN adalah sebagai berikut -
EXPLAIN QUERY PLAN [SQLite Query]Contoh
Pertimbangkan tabel PERUSAHAAN dengan catatan berikut -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Sekarang, mari kita periksa sub-query berikut dengan pernyataan SELECT -
sqlite> EXPLAIN SELECT * FROM COMPANY WHERE Salary >= 20000;Ini akan menghasilkan hasil sebagai berikut.
addr opcode p1 p2 p3
---------- ---------- ---------- ---------- ----------
0 Goto 0 19
1 Integer 0 0
2 OpenRead 0 8
3 SetNumColu 0 5
4 Rewind 0 17
5 Column 0 4
6 RealAffini 0 0
7 Integer 20000 0
8 Lt 357 16 collseq(BI
9 Rowid 0 0
10 Column 0 1
11 Column 0 2
12 Column 0 3
13 Column 0 4
14 RealAffini 0 0
15 Callback 5 0
16 Next 0 5
17 Close 0 0
18 Halt 0 0
19 Transactio 0 0
20 VerifyCook 0 38
21 Goto 0 1
22 Noop 0 0Sekarang, mari kita periksa yang berikut ini Explain Query Plan dengan pernyataan SELECT -
SQLite> EXPLAIN QUERY PLAN SELECT * FROM COMPANY WHERE Salary >= 20000;
order from detail
---------- ---------- -------------
0 0 TABLE COMPANYPerintah VACUUM membersihkan database utama dengan menyalin isinya ke file database sementara dan memuat ulang file database asli dari salinan. Ini menghilangkan halaman gratis, menyelaraskan data tabel menjadi bersebelahan, dan sebaliknya membersihkan struktur file database.
Perintah VACUUM dapat mengubah ROWID entri dalam tabel yang tidak memiliki INTEGER PRIMARY KEY eksplisit. Perintah VACUUM hanya bekerja pada database utama. Tidak mungkin untuk VACUUM file database terlampir.
Perintah VACUUM akan gagal jika ada transaksi yang aktif. Perintah VACUUM adalah no-op untuk database dalam memori. Saat perintah VACUUM membangun kembali file database dari awal, VACUUM juga dapat digunakan untuk mengubah banyak parameter konfigurasi khusus database.
VAKUM Manual
Berikut ini adalah sintaks sederhana untuk mengeluarkan perintah VACUUM untuk seluruh database dari command prompt -
$sqlite3 database_name "VACUUM;"Anda dapat menjalankan VACUUM dari prompt SQLite juga sebagai berikut -
sqlite> VACUUM;Anda juga dapat menjalankan VACUUM pada tabel tertentu sebagai berikut -
sqlite> VACUUM table_name;VAKSUM Otomatis
SQLite Auto-VACUUM tidak melakukan hal yang sama seperti VACUUM melainkan hanya memindahkan halaman gratis ke akhir database sehingga mengurangi ukuran database. Dengan demikian, VACUUM dapat secara signifikan memecah database sementara VACUUM memastikan defragmentasi. Karenanya, Auto-VACUUM hanya membuat database kecil.
Anda dapat mengaktifkan / menonaktifkan penyedotan otomatis SQLite dengan pragma berikut yang berjalan di prompt SQLite -
sqlite> PRAGMA auto_vacuum = NONE; -- 0 means disable auto vacuum
sqlite> PRAGMA auto_vacuum = FULL; -- 1 means enable full auto vacuum
sqlite> PRAGMA auto_vacuum = INCREMENTAL; -- 2 means enable incremental vacuumAnda dapat menjalankan perintah berikut dari command prompt untuk memeriksa pengaturan vakum otomatis -
$sqlite3 database_name "PRAGMA auto_vacuum;"SQLite mendukung lima fungsi tanggal dan waktu sebagai berikut -
| Sr.No. | Fungsi | Contoh |
|---|---|---|
| 1 | tanggal (timestring, pengubah ...) | Ini mengembalikan tanggal dalam format ini: YYYY-MM-DD |
| 2 | waktu (timestring, pengubah ...) | Ini mengembalikan waktu sebagai HH: MM: SS |
| 3 | datetime (timestring, pengubah ...) | Ini mengembalikan YYYY-MM-DD HH: MM: SS |
| 4 | julianday (timestring, pengubah ...) | Ini mengembalikan jumlah hari sejak tengah hari di Greenwich pada 24 November 4714 SM |
| 5 | strftime (timestring, pengubah ...) | Ini mengembalikan tanggal yang diformat sesuai dengan format string yang ditentukan sebagai argumen pertama yang diformat sesuai format yang dijelaskan di bawah ini. |
Kelima fungsi tanggal dan waktu di atas menggunakan string waktu sebagai argumen. String waktu diikuti oleh nol atau lebih pengubah. Fungsi strftime () juga menggunakan string format sebagai argumen pertamanya. Bagian berikut akan memberi Anda detail tentang berbagai jenis string waktu dan pengubah.
Time Strings
String waktu bisa dalam salah satu format berikut -
| Sr.No. | String Waktu | Contoh |
|---|---|---|
| 1 | TTTT-BB-HH | 2010-12-30 |
| 2 | TTTT-BB-HH JJ: MM | 2010-12-30 12:10 |
| 3 | TTTT-BB-HH JJ: MM: SS.SSS | 2010-12-30 12: 10: 04.100 |
| 4 | BB-HH-TTTT JJ: MM | 30-12-2010 12:10 |
| 5 | HH: MM | 12:10 |
| 6 | TTTT-BB-HHTHH: MM | 2010-12-30 12:10 |
| 7 | HH: MM: SS | 12:10:01 |
| 8 | YYYYMMDD HHMMSS | 20101230 121001 |
| 9 | sekarang | 2013-05-07 |
Anda dapat menggunakan "T" sebagai karakter literal yang memisahkan tanggal dan waktu.
Pengubah
Rangkaian waktu dapat diikuti oleh nol atau lebih pengubah yang akan mengubah tanggal dan / atau waktu yang dikembalikan oleh salah satu dari lima fungsi di atas. Pengubah diterapkan dari kiri ke kanan.
Pengubah berikut tersedia di SQLite -
- NNN hari
- Jam NNN
- NNN menit
- NNN.NNNN detik
- NNN bulan
- NNN tahun
- awal bulan
- awal tahun
- awal hari
- hari kerja N
- unixepoch
- localtime
- utc
Format
SQLite menyediakan fungsi yang sangat berguna strftime()untuk memformat tanggal dan waktu apa pun. Anda dapat menggunakan substitusi berikut untuk memformat tanggal dan waktu Anda.
| Pengganti | Deskripsi |
|---|---|
| % d | Hari dalam sebulan, 01-31 |
| % f | Detik pecahan, SS.SSS |
| % H | Jam, 00-23 |
| % j | Hari dalam setahun, 001-366 |
| % J | Nomor hari Julian, DDDD.DDDD |
| % m | Bulan, 00-12 |
| % M | Menit, 00-59 |
| % s | Detik sejak 1970-01-01 |
| % S | Detik, 00-59 |
| % w | Hari dalam seminggu, 0-6 (0 adalah Minggu) |
| % W | Minggu dalam setahun, 01-53 |
| % Y | Tahun, YYYY |
| %% | % simbol |
Contoh
Mari kita coba berbagai contoh sekarang menggunakan prompt SQLite. Perintah berikut menghitung tanggal saat ini.
sqlite> SELECT date('now');
2013-05-07Perintah berikut menghitung hari terakhir bulan ini.
sqlite> SELECT date('now','start of month','+1 month','-1 day');
2013-05-31Perintah berikut menghitung tanggal dan waktu untuk stempel waktu UNIX 1092941466.
sqlite> SELECT datetime(1092941466, 'unixepoch');
2004-08-19 18:51:06Perintah berikut menghitung tanggal dan waktu untuk stempel waktu UNIX 1092941466 dan mengkompensasi zona waktu lokal Anda.
sqlite> SELECT datetime(1092941466, 'unixepoch', 'localtime');
2004-08-19 13:51:06Perintah berikut menghitung stempel waktu UNIX saat ini.
sqlite> SELECT strftime('%s','now');
1393348134Perintah berikut menghitung jumlah hari sejak penandatanganan Deklarasi Kemerdekaan AS.
sqlite> SELECT julianday('now') - julianday('1776-07-04');
86798.7094695023Perintah berikut menghitung jumlah detik sejak momen tertentu pada tahun 2004.
sqlite> SELECT strftime('%s','now') - strftime('%s','2004-01-01 02:34:56');
295001572Perintah berikut menghitung tanggal Selasa pertama bulan Oktober untuk tahun berjalan.
sqlite> SELECT date('now','start of year','+9 months','weekday 2');
2013-10-01Perintah berikut menghitung waktu sejak epoch UNIX dalam hitungan detik (seperti strftime ('% s', 'now') kecuali termasuk bagian pecahan).
sqlite> SELECT (julianday('now') - 2440587.5)*86400.0;
1367926077.12598Untuk mengonversi antara UTC dan nilai waktu lokal saat memformat tanggal, gunakan utc atau pengubah waktu lokal sebagai berikut -
sqlite> SELECT time('12:00', 'localtime');
05:00:00sqlite> SELECT time('12:00', 'utc');
19:00:00SQLite memiliki banyak fungsi bawaan untuk melakukan pemrosesan pada data string atau numerik. Berikut adalah daftar beberapa fungsi built-in SQLite yang berguna dan semuanya case-in-sensitive yang berarti Anda dapat menggunakan fungsi-fungsi ini baik dalam bentuk huruf kecil atau huruf besar atau dalam bentuk campuran. Untuk lebih jelasnya, Anda dapat memeriksa dokumentasi resmi untuk SQLite.
| Sr.No. | Deskripsi fungsi |
|---|---|
| 1 | SQLite COUNT Function Fungsi agregat COUNT SQLite digunakan untuk menghitung jumlah baris dalam tabel database. |
| 2 | SQLite MAX Function Fungsi agregat SQLite MAX memungkinkan kita untuk memilih nilai tertinggi (maksimum) untuk kolom tertentu. |
| 3 | SQLite MIN Function Fungsi agregat SQLite MIN memungkinkan kita untuk memilih nilai terendah (minimum) untuk kolom tertentu. |
| 4 | SQLite AVG Function Fungsi agregat AVG SQLite memilih nilai rata-rata untuk kolom tabel tertentu. |
| 5 | SQLite SUM Function Fungsi agregat SUM SQLite memungkinkan memilih total untuk kolom numerik. |
| 6 | SQLite RANDOM Function Fungsi SQLite RANDOM mengembalikan bilangan bulat pseudo-random antara -9223372036854775808 dan +9223372036854775807. |
| 7 | SQLite ABS Function Fungsi SQLite ABS mengembalikan nilai absolut dari argumen numerik. |
| 8 | SQLite UPPER Function Fungsi SQLite UPPER mengubah string menjadi huruf besar. |
| 9 | SQLite LOWER Function Fungsi SQLite LOWER mengubah string menjadi huruf kecil. |
| 10 | SQLite LENGTH Function Fungsi SQLite LENGTH mengembalikan panjang string. |
| 11 | SQLite sqlite_version Function Fungsi SQLite sqlite_version mengembalikan versi pustaka SQLite. |
Sebelum kita mulai memberikan contoh pada fungsi yang disebutkan di atas, pertimbangkan tabel PERUSAHAAN dengan catatan berikut.
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0Fungsi SQLite COUNT
Fungsi agregat COUNT SQLite digunakan untuk menghitung jumlah baris dalam tabel database. Berikut adalah contohnya -
sqlite> SELECT count(*) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
count(*)
----------
7Fungsi SQLite MAX
Fungsi agregat SQLite MAX memungkinkan kita untuk memilih nilai tertinggi (maksimum) untuk kolom tertentu. Berikut adalah contohnya -
sqlite> SELECT max(salary) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
max(salary)
-----------
85000.0Fungsi SQLite MIN
Fungsi agregat SQLite MIN memungkinkan kita untuk memilih nilai terendah (minimum) untuk kolom tertentu. Berikut adalah contohnya -
sqlite> SELECT min(salary) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
min(salary)
-----------
10000.0Fungsi AVG SQLite
Fungsi agregat AVG SQLite memilih nilai rata-rata untuk kolom tabel tertentu. Berikut adalah contohnya -
sqlite> SELECT avg(salary) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
avg(salary)
----------------
37142.8571428572Fungsi SQLite SUM
Fungsi agregat SUM SQLite memungkinkan memilih total untuk kolom numerik. Berikut adalah contohnya -
sqlite> SELECT sum(salary) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
sum(salary)
-----------
260000.0Fungsi SQLite ACAK
Fungsi SQLite RANDOM mengembalikan bilangan bulat pseudo-random antara -9223372036854775808 dan +9223372036854775807. Berikut adalah contohnya -
sqlite> SELECT random() AS Random;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
Random
-------------------
5876796417670984050Fungsi SQLite ABS
Fungsi SQLite ABS mengembalikan nilai absolut dari argumen numerik. Berikut adalah contohnya -
sqlite> SELECT abs(5), abs(-15), abs(NULL), abs(0), abs("ABC");Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
abs(5) abs(-15) abs(NULL) abs(0) abs("ABC")
---------- ---------- ---------- ---------- ----------
5 15 0 0.0Fungsi SQLite UPPER
Fungsi SQLite UPPER mengubah string menjadi huruf besar. Berikut adalah contohnya -
sqlite> SELECT upper(name) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
upper(name)
-----------
PAUL
ALLEN
TEDDY
MARK
DAVID
KIM
JAMESFungsi SQLite LOWER
Fungsi SQLite LOWER mengubah string menjadi huruf kecil. Berikut adalah contohnya -
sqlite> SELECT lower(name) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
lower(name)
-----------
paul
allen
teddy
mark
david
kim
jamesFungsi SQLite LENGTH
Fungsi SQLite LENGTH mengembalikan panjang string. Berikut adalah contohnya -
sqlite> SELECT name, length(name) FROM COMPANY;Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
NAME length(name)
---------- ------------
Paul 4
Allen 5
Teddy 5
Mark 4
David 5
Kim 3
James 5Fungsi SQLite sqlite_version
Fungsi SQLite sqlite_version mengembalikan versi pustaka SQLite. Berikut adalah contohnya -
sqlite> SELECT sqlite_version() AS 'SQLite Version';Pernyataan SQLite SQL di atas akan menghasilkan yang berikut ini.
SQLite Version
--------------
3.6.20Di bab ini, Anda akan mempelajari cara menggunakan SQLite dalam program C / C ++.
Instalasi
Sebelum mulai menggunakan SQLite di program C / C ++ kami, Anda harus memastikan bahwa library SQLite telah disiapkan di mesin. Anda dapat memeriksa bab Instalasi SQLite untuk memahami proses instalasi.
C / C ++ Interface API
Berikut ini adalah rutinitas antarmuka C / C ++ SQLite yang penting, yang dapat memenuhi persyaratan Anda untuk bekerja dengan database SQLite dari program C / C ++ Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi SQLite.
| Sr.No. | API & Deskripsi |
|---|---|
| 1 | sqlite3_open(const char *filename, sqlite3 **ppDb) Rutinitas ini membuka koneksi ke file database SQLite dan mengembalikan objek koneksi database untuk digunakan oleh rutinitas SQLite lainnya. Jika argumen nama file adalah NULL atau ': memory:', sqlite3_open () akan membuat database dalam memori dalam RAM yang hanya bertahan selama sesi. Jika nama file bukan NULL, sqlite3_open () mencoba membuka file database dengan menggunakan nilainya. Jika tidak ada file dengan nama itu, sqlite3_open () akan membuka file database baru dengan nama itu. |
| 2 | sqlite3_exec(sqlite3*, const char *sql, sqlite_callback, void *data, char **errmsg) Rutinitas ini menyediakan cara cepat dan mudah untuk menjalankan perintah SQL yang disediakan oleh argumen sql yang dapat terdiri dari lebih dari satu perintah SQL. Di sini, argumen pertama sqlite3 adalah objek database terbuka, sqlite_callback adalah panggilan balik yang datanya adalah argumen pertama dan errmsg akan dikembalikan untuk menangkap setiap kesalahan yang dimunculkan oleh rutinitas. SQLite3_exec () melakukan parsing rutin dan mengeksekusi setiap perintah yang diberikan di sql argumen hingga mencapai akhir string atau menemui kesalahan. |
| 3 | sqlite3_close(sqlite3*) Rutin ini menutup koneksi database yang sebelumnya dibuka oleh panggilan ke sqlite3_open (). Semua pernyataan yang disiapkan terkait dengan koneksi harus diselesaikan sebelum menutup koneksi. Jika masih ada pertanyaan yang belum diselesaikan, sqlite3_close () akan mengembalikan SQLITE_BUSY dengan pesan kesalahan Tidak dapat ditutup karena pernyataan yang tidak diselesaikan. |
Terhubung ke Database
Mengikuti segmen kode C menunjukkan cara menyambungkan ke database yang sudah ada. Jika database tidak ada, maka akan dibuatkan dan akhirnya objek database akan dikembalikan.
#include <stdio.h>
#include <sqlite3.h>
int main(int argc, char* argv[]) {
sqlite3 *db;
char *zErrMsg = 0;
int rc;
rc = sqlite3_open("test.db", &db);
if( rc ) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
return(0);
} else {
fprintf(stderr, "Opened database successfully\n");
}
sqlite3_close(db);
}Sekarang, mari kita kompilasi dan jalankan program di atas untuk membuat database kita test.dbdi direktori saat ini. Anda dapat mengubah jalur Anda sesuai kebutuhan Anda.
$gcc test.c -l sqlite3
$./a.out
Opened database successfullyJika Anda akan menggunakan kode sumber C ++, maka Anda dapat mengompilasi kode Anda sebagai berikut -
$g++ test.c -l sqlite3Di sini, kami menghubungkan program kami dengan pustaka sqlite3 untuk menyediakan fungsi yang diperlukan ke program C. Ini akan membuat file database test.db di direktori Anda dan Anda akan mendapatkan hasil sebagai berikut.
-rwxr-xr-x. 1 root root 7383 May 8 02:06 a.out
-rw-r--r--. 1 root root 323 May 8 02:05 test.c
-rw-r--r--. 1 root root 0 May 8 02:06 test.dbBuat Tabel
Segmen kode C berikut akan digunakan untuk membuat tabel di database yang dibuat sebelumnya -
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
int i;
for(i = 0; i<argc; i++) {
printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
}
printf("\n");
return 0;
}
int main(int argc, char* argv[]) {
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char *sql;
/* Open database */
rc = sqlite3_open("test.db", &db);
if( rc ) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
return(0);
} else {
fprintf(stdout, "Opened database successfully\n");
}
/* Create SQL statement */
sql = "CREATE TABLE COMPANY(" \
"ID INT PRIMARY KEY NOT NULL," \
"NAME TEXT NOT NULL," \
"AGE INT NOT NULL," \
"ADDRESS CHAR(50)," \
"SALARY REAL );";
/* Execute SQL statement */
rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
if( rc != SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
} else {
fprintf(stdout, "Table created successfully\n");
}
sqlite3_close(db);
return 0;
}Ketika program di atas dikompilasi dan dijalankan, itu akan membuat tabel PERUSAHAAN di test.db Anda dan daftar akhir dari file tersebut adalah sebagai berikut -
-rwxr-xr-x. 1 root root 9567 May 8 02:31 a.out
-rw-r--r--. 1 root root 1207 May 8 02:31 test.c
-rw-r--r--. 1 root root 3072 May 8 02:31 test.dbOperasi INSERT
Segmen kode C berikut menunjukkan bagaimana Anda dapat membuat catatan dalam tabel PERUSAHAAN yang dibuat pada contoh di atas -
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
static int callback(void *NotUsed, int argc, char **argv, char **azColName) {
int i;
for(i = 0; i<argc; i++) {
printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
}
printf("\n");
return 0;
}
int main(int argc, char* argv[]) {
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char *sql;
/* Open database */
rc = sqlite3_open("test.db", &db);
if( rc ) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
return(0);
} else {
fprintf(stderr, "Opened database successfully\n");
}
/* Create SQL statement */
sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " \
"VALUES (1, 'Paul', 32, 'California', 20000.00 ); " \
"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " \
"VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); " \
"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
"VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );" \
"INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)" \
"VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";
/* Execute SQL statement */
rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
if( rc != SQLITE_OK ){
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
} else {
fprintf(stdout, "Records created successfully\n");
}
sqlite3_close(db);
return 0;
}Ketika program di atas dikompilasi dan dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut -
Opened database successfully
Records created successfullyPILIH Operasi
Sebelum melanjutkan dengan contoh aktual untuk mengambil record, mari kita lihat beberapa detail tentang fungsi callback, yang kita gunakan dalam contoh kita. Callback ini menyediakan cara untuk mendapatkan hasil dari pernyataan SELECT. Ini memiliki deklarasi berikut -
typedef int (*sqlite3_callback)(
void*, /* Data provided in the 4th argument of sqlite3_exec() */
int, /* The number of columns in row */
char**, /* An array of strings representing fields in the row */
char** /* An array of strings representing column names */
);Jika callback di atas disediakan dalam rutin sqlite_exec () sebagai argumen ketiga, SQLite akan memanggil fungsi callback ini untuk setiap record yang diproses dalam setiap pernyataan SELECT yang dieksekusi dalam argumen SQL.
Segmen kode C berikut menunjukkan bagaimana Anda dapat mengambil dan menampilkan catatan dari tabel PERUSAHAAN yang dibuat pada contoh di atas -
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
static int callback(void *data, int argc, char **argv, char **azColName){
int i;
fprintf(stderr, "%s: ", (const char*)data);
for(i = 0; i<argc; i++){
printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
}
printf("\n");
return 0;
}
int main(int argc, char* argv[]) {
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char *sql;
const char* data = "Callback function called";
/* Open database */
rc = sqlite3_open("test.db", &db);
if( rc ) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
return(0);
} else {
fprintf(stderr, "Opened database successfully\n");
}
/* Create SQL statement */
sql = "SELECT * from COMPANY";
/* Execute SQL statement */
rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
if( rc != SQLITE_OK ) {
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
} else {
fprintf(stdout, "Operation done successfully\n");
}
sqlite3_close(db);
return 0;
}Ketika program di atas dikompilasi dan dijalankan, maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0
Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0
Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0
Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyUPDATE Operasi
Segmen kode C berikut menunjukkan bagaimana kita dapat menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN.
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
static int callback(void *data, int argc, char **argv, char **azColName){
int i;
fprintf(stderr, "%s: ", (const char*)data);
for(i = 0; i<argc; i++) {
printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
}
printf("\n");
return 0;
}
int main(int argc, char* argv[]) {
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char *sql;
const char* data = "Callback function called";
/* Open database */
rc = sqlite3_open("test.db", &db);
if( rc ) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
return(0);
} else {
fprintf(stderr, "Opened database successfully\n");
}
/* Create merged SQL statement */
sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1; " \
"SELECT * from COMPANY";
/* Execute SQL statement */
rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
if( rc != SQLITE_OK ) {
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
} else {
fprintf(stdout, "Operation done successfully\n");
}
sqlite3_close(db);
return 0;
}Ketika program di atas dikompilasi dan dijalankan, maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0
Callback function called: ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0
Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0
Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyHAPUS Operasi
Segmen kode C berikut menunjukkan bagaimana Anda dapat menggunakan pernyataan DELETE untuk menghapus catatan apa pun dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN.
#include <stdio.h>
#include <stdlib.h>
#include <sqlite3.h>
static int callback(void *data, int argc, char **argv, char **azColName) {
int i;
fprintf(stderr, "%s: ", (const char*)data);
for(i = 0; i<argc; i++) {
printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
}
printf("\n");
return 0;
}
int main(int argc, char* argv[]) {
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char *sql;
const char* data = "Callback function called";
/* Open database */
rc = sqlite3_open("test.db", &db);
if( rc ) {
fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
return(0);
} else {
fprintf(stderr, "Opened database successfully\n");
}
/* Create merged SQL statement */
sql = "DELETE from COMPANY where ID=2; " \
"SELECT * from COMPANY";
/* Execute SQL statement */
rc = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
if( rc != SQLITE_OK ) {
fprintf(stderr, "SQL error: %s\n", zErrMsg);
sqlite3_free(zErrMsg);
} else {
fprintf(stdout, "Operation done successfully\n");
}
sqlite3_close(db);
return 0;
}Ketika program di atas dikompilasi dan dijalankan, maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Callback function called: ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0
Callback function called: ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0
Callback function called: ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyDi bab ini, Anda akan mempelajari cara menggunakan SQLite di program Java.
Instalasi
Sebelum Anda mulai menggunakan SQLite di program Java kami, Anda harus memastikan bahwa Anda telah menyiapkan Driver JDBC SQLite dan Java di mesin. Anda dapat memeriksa tutorial Java untuk instalasi Java di komputer Anda. Sekarang, mari kita periksa cara mengatur driver SQLite JDBC.
Unduh versi terbaru sqlite-jdbc- (VERSION) .jar dari repositori sqlite-jdbc .
Tambahkan file jar yang diunduh sqlite-jdbc- (VERSION) .jar di jalur kelas Anda, atau Anda dapat menggunakannya bersama dengan opsi -classpath seperti yang dijelaskan dalam contoh berikut.
Bagian berikut mengasumsikan Anda memiliki sedikit pengetahuan tentang konsep Java JDBC. Jika tidak, maka disarankan untuk menghabiskan setengah jam dengan Tutorial JDBC agar terbiasa dengan konsep yang dijelaskan di bawah ini.
Hubungkan ke Database
Program Java berikut menunjukkan cara menyambungkan ke database yang sudah ada. Jika database tidak ada, maka akan dibuatkan dan akhirnya objek database akan dikembalikan.
import java.sql.*;
public class SQLiteJDBC {
public static void main( String args[] ) {
Connection c = null;
try {
Class.forName("org.sqlite.JDBC");
c = DriverManager.getConnection("jdbc:sqlite:test.db");
} catch ( Exception e ) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
System.exit(0);
}
System.out.println("Opened database successfully");
}
}Sekarang, mari kita kompilasi dan jalankan program di atas untuk membuat database kita test.dbdi direktori saat ini. Anda dapat mengubah jalur Anda sesuai kebutuhan Anda. Kami mengasumsikan versi driver JDBC sqlite-jdbc-3.7.2.jar saat ini tersedia di jalur saat ini.
$javac SQLiteJDBC.java $java -classpath ".:sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Open database successfullyJika Anda akan menggunakan mesin Windows, maka Anda dapat mengkompilasi dan menjalankan kode Anda sebagai berikut -
$javac SQLiteJDBC.java $java -classpath ".;sqlite-jdbc-3.7.2.jar" SQLiteJDBC
Opened database successfullyBuat Tabel
Program Java berikut akan digunakan untuk membuat tabel pada database yang telah dibuat sebelumnya.
import java.sql.*;
public class SQLiteJDBC {
public static void main( String args[] ) {
Connection c = null;
Statement stmt = null;
try {
Class.forName("org.sqlite.JDBC");
c = DriverManager.getConnection("jdbc:sqlite:test.db");
System.out.println("Opened database successfully");
stmt = c.createStatement();
String sql = "CREATE TABLE COMPANY " +
"(ID INT PRIMARY KEY NOT NULL," +
" NAME TEXT NOT NULL, " +
" AGE INT NOT NULL, " +
" ADDRESS CHAR(50), " +
" SALARY REAL)";
stmt.executeUpdate(sql);
stmt.close();
c.close();
} catch ( Exception e ) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
System.exit(0);
}
System.out.println("Table created successfully");
}
}Ketika program di atas dikompilasi dan dijalankan, itu akan membuat tabel PERUSAHAAN di Anda test.db dan daftar akhir file adalah sebagai berikut -
-rw-r--r--. 1 root root 3201128 Jan 22 19:04 sqlite-jdbc-3.7.2.jar
-rw-r--r--. 1 root root 1506 May 8 05:43 SQLiteJDBC.class
-rw-r--r--. 1 root root 832 May 8 05:42 SQLiteJDBC.java
-rw-r--r--. 1 root root 3072 May 8 05:43 test.dbOperasi INSERT
Program Java berikut menunjukkan cara membuat catatan di tabel PERUSAHAAN yang dibuat pada contoh di atas.
import java.sql.*;
public class SQLiteJDBC {
public static void main( String args[] ) {
Connection c = null;
Statement stmt = null;
try {
Class.forName("org.sqlite.JDBC");
c = DriverManager.getConnection("jdbc:sqlite:test.db");
c.setAutoCommit(false);
System.out.println("Opened database successfully");
stmt = c.createStatement();
String sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
"VALUES (1, 'Paul', 32, 'California', 20000.00 );";
stmt.executeUpdate(sql);
sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
"VALUES (2, 'Allen', 25, 'Texas', 15000.00 );";
stmt.executeUpdate(sql);
sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
"VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );";
stmt.executeUpdate(sql);
sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) " +
"VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );";
stmt.executeUpdate(sql);
stmt.close();
c.commit();
c.close();
} catch ( Exception e ) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
System.exit(0);
}
System.out.println("Records created successfully");
}
}Ketika program di atas dikompilasi dan dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut -
Opened database successfully
Records created successfullyPILIH Operasi
Program Java berikut ini menunjukkan cara mengambil dan menampilkan record dari tabel COMPANY yang dibuat pada contoh di atas.
import java.sql.*;
public class SQLiteJDBC {
public static void main( String args[] ) {
Connection c = null;
Statement stmt = null;
try {
Class.forName("org.sqlite.JDBC");
c = DriverManager.getConnection("jdbc:sqlite:test.db");
c.setAutoCommit(false);
System.out.println("Opened database successfully");
stmt = c.createStatement();
ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
while ( rs.next() ) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
String address = rs.getString("address");
float salary = rs.getFloat("salary");
System.out.println( "ID = " + id );
System.out.println( "NAME = " + name );
System.out.println( "AGE = " + age );
System.out.println( "ADDRESS = " + address );
System.out.println( "SALARY = " + salary );
System.out.println();
}
rs.close();
stmt.close();
c.close();
} catch ( Exception e ) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
System.exit(0);
}
System.out.println("Operation done successfully");
}
}Ketika program di atas dikompilasi dan dijalankan, maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 20000.0
ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0
ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0
ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyUPDATE Operasi
Kode Java berikut menunjukkan bagaimana menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN.
import java.sql.*;
public class SQLiteJDBC {
public static void main( String args[] ) {
Connection c = null;
Statement stmt = null;
try {
Class.forName("org.sqlite.JDBC");
c = DriverManager.getConnection("jdbc:sqlite:test.db");
c.setAutoCommit(false);
System.out.println("Opened database successfully");
stmt = c.createStatement();
String sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1;";
stmt.executeUpdate(sql);
c.commit();
ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
while ( rs.next() ) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
String address = rs.getString("address");
float salary = rs.getFloat("salary");
System.out.println( "ID = " + id );
System.out.println( "NAME = " + name );
System.out.println( "AGE = " + age );
System.out.println( "ADDRESS = " + address );
System.out.println( "SALARY = " + salary );
System.out.println();
}
rs.close();
stmt.close();
c.close();
} catch ( Exception e ) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
System.exit(0);
}
System.out.println("Operation done successfully");
}
}Ketika program di atas dikompilasi dan dijalankan, maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0
ID = 2
NAME = Allen
AGE = 25
ADDRESS = Texas
SALARY = 15000.0
ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0
ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyHAPUS Operasi
Kode Java berikut menunjukkan bagaimana menggunakan pernyataan use DELETE untuk menghapus record apapun dan kemudian mengambil dan menampilkan record yang tersisa dari tabel COMPANY kami.
import java.sql.*;
public class SQLiteJDBC {
public static void main( String args[] ) {
Connection c = null;
Statement stmt = null;
try {
Class.forName("org.sqlite.JDBC");
c = DriverManager.getConnection("jdbc:sqlite:test.db");
c.setAutoCommit(false);
System.out.println("Opened database successfully");
stmt = c.createStatement();
String sql = "DELETE from COMPANY where ID=2;";
stmt.executeUpdate(sql);
c.commit();
ResultSet rs = stmt.executeQuery( "SELECT * FROM COMPANY;" );
while ( rs.next() ) {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age");
String address = rs.getString("address");
float salary = rs.getFloat("salary");
System.out.println( "ID = " + id );
System.out.println( "NAME = " + name );
System.out.println( "AGE = " + age );
System.out.println( "ADDRESS = " + address );
System.out.println( "SALARY = " + salary );
System.out.println();
}
rs.close();
stmt.close();
c.close();
} catch ( Exception e ) {
System.err.println( e.getClass().getName() + ": " + e.getMessage() );
System.exit(0);
}
System.out.println("Operation done successfully");
}
}Ketika program di atas dikompilasi dan dijalankan, maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0
ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0
ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyDi bab ini, Anda akan mempelajari cara menggunakan SQLite dalam program PHP.
Instalasi
Ekstensi SQLite3 diaktifkan secara default pada PHP 5.3.0. Dimungkinkan untuk menonaktifkannya dengan menggunakan--without-sqlite3 pada waktu kompilasi.
Pengguna Windows harus mengaktifkan php_sqlite3.dll untuk menggunakan ekstensi ini. DLL ini disertakan dengan distribusi PHP Windows pada PHP 5.3.0.
Untuk instruksi instalasi terperinci, silakan periksa tutorial PHP kami dan situs resminya.
API Antarmuka PHP
Berikut ini adalah rutinitas PHP penting yang dapat memenuhi kebutuhan Anda untuk bekerja dengan database SQLite dari program PHP Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi PHP.
| Sr.No. | API & Deskripsi |
|---|---|
| 1 | public void SQLite3::open ( filename, flags, encryption_key ) Membuka Database SQLite 3. Jika build menyertakan enkripsi, maka build akan mencoba menggunakan kunci tersebut. Jika nama file diberikan sebagai':memory:', SQLite3 :: open () akan membuat database dalam memori dalam RAM yang hanya bertahan selama sesi. Jika nama file adalah nama file perangkat yang sebenarnya, SQLite3 :: open () mencoba untuk membuka file database dengan menggunakan nilainya. Jika tidak ada file dengan nama itu, maka file database baru dengan nama itu akan dibuat. Bendera opsional yang digunakan untuk menentukan cara membuka database SQLite. Secara default, buka menggunakan SQLITE3_OPEN_READWRITE | SQLITE3_OPEN_CREATE. |
| 2 | public bool SQLite3::exec ( string $query ) Rutinitas ini menyediakan cara cepat dan mudah untuk menjalankan perintah SQL yang disediakan oleh argumen sql, yang dapat terdiri dari lebih dari satu perintah SQL. Rutin ini digunakan untuk menjalankan kueri tanpa hasil terhadap database tertentu. |
| 3 | public SQLite3Result SQLite3::query ( string $query ) Rutinitas ini mengeksekusi kueri SQL, mengembalikan SQLite3Result objek jika kueri mengembalikan hasil. |
| 4 | public int SQLite3::lastErrorCode ( void ) Rutinitas ini mengembalikan kode hasil numerik dari permintaan SQLite terbaru yang gagal. |
| 5 | public string SQLite3::lastErrorMsg ( void ) Rutinitas ini mengembalikan teks bahasa Inggris yang menjelaskan permintaan SQLite terbaru yang gagal. |
| 6 | public int SQLite3::changes ( void ) Rutinitas ini mengembalikan jumlah baris database yang diperbarui, disisipkan, atau dihapus oleh pernyataan SQL terbaru. |
| 7 | public bool SQLite3::close ( void ) Rutin ini menutup koneksi database yang sebelumnya dibuka oleh panggilan ke SQLite3 :: open (). |
| 8 | public string SQLite3::escapeString ( string $value ) Rutin ini mengembalikan string yang telah lolos dengan benar untuk penyertaan yang aman dalam pernyataan SQL. |
Hubungkan ke Database
Kode PHP berikut menunjukkan bagaimana menghubungkan ke database yang sudah ada. Jika database tidak ada, maka akan dibuat dan akhirnya objek database akan dikembalikan.
<?php
class MyDB extends SQLite3 {
function __construct() {
$this->open('test.db');
}
}
$db = new MyDB(); if(!$db) {
echo $db->lastErrorMsg();
} else {
echo "Opened database successfully\n";
}
?>Sekarang, mari kita jalankan program di atas untuk membuat database kita test.dbdi direktori saat ini. Anda dapat mengubah jalur Anda sesuai kebutuhan Anda. Jika database berhasil dibuat, maka akan muncul pesan berikut -
Open database successfullyBuat Tabel
Program PHP berikut akan digunakan untuk membuat tabel pada database yang telah dibuat sebelumnya.
<?php
class MyDB extends SQLite3 {
function __construct() {
$this->open('test.db');
}
}
$db = new MyDB(); if(!$db) {
echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
CREATE TABLE COMPANY
(ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL);
EOF;
$ret = $db->exec($sql); if(!$ret){
echo $db->lastErrorMsg(); } else { echo "Table created successfully\n"; } $db->close();
?>Ketika program di atas dijalankan, itu akan membuat tabel PERUSAHAAN di Anda test.db dan itu akan menampilkan pesan berikut -
Opened database successfully
Table created successfullyOperasi INSERT
Program PHP berikut menunjukkan cara membuat record di tabel COMPANY yang dibuat pada contoh di atas.
<?php
class MyDB extends SQLite3 {
function __construct() {
$this->open('test.db'); } } $db = new MyDB();
if(!$db){ echo $db->lastErrorMsg();
} else {
echo "Opened database successfully\n";
}
$sql =<<<EOF INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (2, 'Allen', 25, 'Texas', 15000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 ); INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ); EOF; $ret = $db->exec($sql);
if(!$ret) { echo $db->lastErrorMsg();
} else {
echo "Records created successfully\n";
}
$db->close();
?>Ketika program di atas dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut.
Opened database successfully
Records created successfullyPILIH Operasi
Program PHP berikut menunjukkan cara mengambil dan menampilkan catatan dari tabel PERUSAHAAN yang dibuat pada contoh di atas -
<?php
class MyDB extends SQLite3 {
function __construct() {
$this->open('test.db');
}
}
$db = new MyDB(); if(!$db) {
echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n"; } $sql =<<<EOF
SELECT * from COMPANY;
EOF;
$ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000
ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000
Operation done successfullyUPDATE Operasi
Kode PHP berikut menunjukkan bagaimana menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN.
<?php
class MyDB extends SQLite3 {
function __construct() {
$this->open('test.db'); } } $db = new MyDB();
if(!$db) { echo $db->lastErrorMsg();
} else {
echo "Opened database successfully\n";
}
$sql =<<<EOF UPDATE COMPANY set SALARY = 25000.00 where ID=1; EOF; $ret = $db->exec($sql);
if(!$ret) { echo $db->lastErrorMsg();
} else {
echo $db->changes(), " Record updated successfully\n"; } $sql =<<<EOF
SELECT * from COMPANY;
EOF;
$ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
1 Record updated successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000
ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000
Operation done successfullyHAPUS Operasi
Kode PHP berikut menunjukkan bagaimana menggunakan pernyataan DELETE untuk menghapus record apapun dan kemudian mengambil dan menampilkan record yang tersisa dari tabel COMPANY.
<?php
class MyDB extends SQLite3 {
function __construct() {
$this->open('test.db'); } } $db = new MyDB();
if(!$db) { echo $db->lastErrorMsg();
} else {
echo "Opened database successfully\n";
}
$sql =<<<EOF DELETE from COMPANY where ID = 2; EOF; $ret = $db->exec($sql);
if(!$ret){ echo $db->lastErrorMsg();
} else {
echo $db->changes(), " Record deleted successfully\n"; } $sql =<<<EOF
SELECT * from COMPANY;
EOF;
$ret = $db->query($sql); while($row = $ret->fetchArray(SQLITE3_ASSOC) ) { echo "ID = ". $row['ID'] . "\n";
echo "NAME = ". $row['NAME'] ."\n"; echo "ADDRESS = ". $row['ADDRESS'] ."\n";
echo "SALARY = ".$row['SALARY'] ."\n\n"; } echo "Operation done successfully\n"; $db->close();
?>Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
1 Record deleted successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000
Operation done successfullyDi bab ini, Anda akan mempelajari cara menggunakan SQLite di program Perl.
Instalasi
SQLite3 dapat diintegrasikan dengan Perl menggunakan modul Perl DBI, yang merupakan modul akses database untuk bahasa pemrograman Perl. Ini mendefinisikan satu set metode, variabel, dan konvensi yang menyediakan antarmuka database standar.
Berikut adalah langkah-langkah sederhana untuk menginstal modul DBI di mesin Linux / UNIX Anda -
$ wget http://search.cpan.org/CPAN/authors/id/T/TI/TIMB/DBI-1.625.tar.gz $ tar xvfz DBI-1.625.tar.gz
$ cd DBI-1.625 $ perl Makefile.PL
$ make $ make installJika Anda perlu menginstal driver SQLite untuk DBI, maka dapat diinstal sebagai berikut -
$ wget http://search.cpan.org/CPAN/authors/id/M/MS/MSERGEANT/DBD-SQLite-1.11.tar.gz $ tar xvfz DBD-SQLite-1.11.tar.gz
$ cd DBD-SQLite-1.11 $ perl Makefile.PL
$ make $ make installAPI Antarmuka DBI
Berikut adalah rutinitas DBI yang penting, yang dapat memenuhi kebutuhan Anda untuk bekerja dengan database SQLite dari program Perl Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi Perl DBI.
| Sr.No. | API & Deskripsi |
|---|---|
| 1 | DBI->connect($data_source, "", "", \%attr) Membuat koneksi database, atau sesi, ke $ data_source yang diminta. Mengembalikan objek pegangan database jika koneksi berhasil. Sumber data memiliki bentuk seperti - DBI:SQLite:dbname = 'test.db'di mana SQLite adalah nama driver SQLite dan test.db adalah nama file database SQLite. Jika nama file diberikan sebagai':memory:', ini akan membuat database dalam memori dalam RAM yang hanya bertahan selama sesi. Jika nama file adalah nama file perangkat yang sebenarnya, maka ia mencoba untuk membuka file database dengan menggunakan nilainya. Jika tidak ada file dengan nama itu, maka file database baru dengan nama itu akan dibuat. Anda membiarkan parameter kedua dan ketiga sebagai string kosong dan parameter terakhir adalah meneruskan berbagai atribut seperti yang ditunjukkan pada contoh berikut. |
| 2 | $dbh->do($sql) Rutinitas ini mempersiapkan dan menjalankan satu pernyataan SQL. Mengembalikan jumlah baris yang terpengaruh atau undef pada kesalahan. Nilai kembali -1 berarti jumlah baris tidak diketahui, tidak berlaku, atau tidak tersedia. Di sini, $ dbh adalah handle yang dikembalikan oleh panggilan DBI-> connect (). |
| 3 | $dbh->prepare($sql) Rutin ini menyiapkan pernyataan untuk dieksekusi nanti oleh mesin database dan mengembalikan referensi ke objek pegangan pernyataan. |
| 4 | $sth->execute() Rutin ini melakukan pemrosesan apa pun yang diperlukan untuk menjalankan pernyataan yang disiapkan. Undef dikembalikan jika terjadi kesalahan. Eksekusi yang berhasil selalu mengembalikan nilai true terlepas dari jumlah baris yang terpengaruh. Sini,$sth is a statement handle returned by $dbh-> siapkan panggilan ($ sql). |
| 5 | $sth->fetchrow_array() Rutinitas ini mengambil baris data berikutnya dan mengembalikannya sebagai daftar yang berisi nilai bidang. Bidang kosong dikembalikan sebagai nilai undef dalam daftar. |
| 6 | $DBI::err Ini sama dengan $ h-> err, di mana $h is any of the handle types like $dbh, $sth, or $drh. Ini mengembalikan kode kesalahan mesin database asli dari metode driver terakhir yang dipanggil. |
| 7 | $DBI::errstr Ini sama dengan $ h-> errstr, di mana $h is any of the handle types like $dbh, $sth, or $drh. Ini mengembalikan pesan kesalahan mesin database asli dari metode DBI terakhir yang dipanggil. |
| 8 | $dbh->disconnect() Rutin ini menutup koneksi database yang sebelumnya dibuka oleh panggilan ke DBI-> connect (). |
Terhubung ke Database
Kode Perl berikut menunjukkan cara menyambung ke database yang sudah ada. Jika database tidak ada, maka akan dibuatkan dan akhirnya objek database akan dikembalikan.
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
or die $DBI::errstr;
print "Opened database successfully\n";Sekarang, mari kita jalankan program di atas untuk membuat database test.db di direktori saat ini. Anda dapat mengubah jalur Anda sesuai kebutuhan Anda. Simpan kode di atas dalam file sqlite.pl dan jalankan seperti yang ditunjukkan di bawah ini. Jika database berhasil dibuat, maka akan muncul pesan berikut -
$ chmod +x sqlite.pl
$ ./sqlite.pl
Open database successfullyBuat Tabel
Mengikuti program Perl digunakan untuk membuat tabel pada database yang telah dibuat sebelumnya.
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(CREATE TABLE COMPANY
(ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL););
my $rv = $dbh->do($stmt); if($rv < 0) {
print $DBI::errstr; } else { print "Table created successfully\n"; } $dbh->disconnect();Ketika program di atas dijalankan, itu akan membuat tabel PERUSAHAAN di test.db Anda dan akan menampilkan pesan berikut -
Opened database successfully
Table created successfullyNOTE - Jika Anda melihat kesalahan berikut di salah satu operasi -
DBD::SQLite::st execute failed: not an error(21) at dbdimp.c line 398Dalam kasus seperti itu, buka dbdimp.c file tersedia di instalasi DBD-SQLite dan cari tahu sqlite3_prepare() berfungsi dan mengubah argumen ketiganya menjadi -1 bukannya 0. Terakhir, instal DBD :: SQLite menggunakan make dan lakukan make install untuk menyelesaikan masalah.
Operasi INSERT
Mengikuti program Perl menunjukkan bagaimana membuat record dalam tabel COMPANY yang dibuat pada contoh di atas.
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";
my $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (1, 'Paul', 32, 'California', 20000.00 )); my $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (2, 'Allen', 25, 'Texas', 15000.00 ));
$rv = $dbh->do($stmt) or die $DBI::errstr;
$stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )); $rv = $dbh->do($stmt) or die $DBI::errstr; $stmt = qq(INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 ););
$rv = $dbh->do($stmt) or die $DBI::errstr;
print "Records created successfully\n";
$dbh->disconnect();Ketika program di atas dijalankan, itu akan membuat catatan yang diberikan di tabel PERUSAHAAN dan akan menampilkan dua baris berikut -
Opened database successfully
Records created successfullyPILIH Operasi
Mengikuti program Perl menunjukkan bagaimana mengambil dan menampilkan record dari tabel COMPANY yang dibuat pada contoh di atas.
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); my $rv = $sth->execute() or die $DBI::errstr;
if($rv < 0) { print $DBI::errstr;
}
while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
print "SALARY = ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000
ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000
Operation done successfullyUPDATE Operasi
Kode Perl berikut menunjukkan bagaimana pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN.
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "SQLite"; my $database = "test.db";
my $dsn = "DBI:$driver:dbname=$database"; my $userid = "";
my $password = ""; my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) or die $DBI::errstr;
print "Opened database successfully\n";
my $stmt = qq(UPDATE COMPANY set SALARY = 25000.00 where ID=1;); my $rv = $dbh->do($stmt) or die $DBI::errstr; if( $rv < 0 ) {
print $DBI::errstr; } else { print "Total number of rows updated : $rv\n";
}
$stmt = qq(SELECT id, name, address, salary from COMPANY;); my $sth = $dbh->prepare( $stmt );
$rv = $sth->execute() or die $DBI::errstr; if($rv < 0) {
print $DBI::errstr; } while(my @row = $sth->fetchrow_array()) {
print "ID = ". $row[0] . "\n"; print "NAME = ". $row[1] ."\n";
print "ADDRESS = ". $row[2] ."\n"; print "SALARY = ". $row[3] ."\n\n";
}
print "Operation done successfully\n";
$dbh->disconnect();Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000
ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000
Operation done successfullyHAPUS Operasi
Mengikuti kode Perl menunjukkan bagaimana menggunakan pernyataan DELETE untuk menghapus semua catatan dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN -
#!/usr/bin/perl
use DBI;
use strict;
my $driver = "SQLite";
my $database = "test.db"; my $dsn = "DBI:$driver:dbname=$database";
my $userid = ""; my $password = "";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 })
or die $DBI::errstr; print "Opened database successfully\n"; my $stmt = qq(DELETE from COMPANY where ID = 2;);
my $rv = $dbh->do($stmt) or die $DBI::errstr;
if( $rv < 0 ) { print $DBI::errstr;
} else {
print "Total number of rows deleted : $rv\n"; } $stmt = qq(SELECT id, name, address, salary from COMPANY;);
my $sth = $dbh->prepare( $stmt ); $rv = $sth->execute() or die $DBI::errstr;
if($rv < 0) { print $DBI::errstr;
}
while(my @row = $sth->fetchrow_array()) { print "ID = ". $row[0] . "\n";
print "NAME = ". $row[1] ."\n"; print "ADDRESS = ". $row[2] ."\n";
print "SALARY = ". $row[3] ."\n\n"; } print "Operation done successfully\n"; $dbh->disconnect();Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000
Operation done successfullyDi bab ini, Anda akan mempelajari cara menggunakan SQLite dengan program Python.
Instalasi
SQLite3 dapat diintegrasikan dengan Python menggunakan modul sqlite3 yang ditulis oleh Gerhard Haring. Ini menyediakan antarmuka SQL yang sesuai dengan spesifikasi DB-API 2.0 yang dijelaskan oleh PEP 249. Anda tidak perlu menginstal modul ini secara terpisah karena modul ini dikirimkan secara default bersama dengan Python versi 2.5.x dan seterusnya.
Untuk menggunakan modul sqlite3, Anda harus terlebih dahulu membuat objek koneksi yang mewakili database dan kemudian secara opsional Anda dapat membuat objek kursor, yang akan membantu Anda dalam menjalankan semua pernyataan SQL.
API modul Python sqlite3
Berikut adalah rutinitas modul sqlite3 yang penting, yang dapat mencukupi kebutuhan Anda untuk bekerja dengan database SQLite dari program Python Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi modul Python sqlite3.
| Sr.No. | API & Deskripsi |
|---|---|
| 1 | sqlite3.connect(database [,timeout ,other optional arguments]) API ini membuka koneksi ke file database SQLite. Anda dapat menggunakan ": memory:" untuk membuka koneksi database ke database yang berada di RAM, bukan di disk. Jika database berhasil dibuka, itu mengembalikan objek koneksi. Ketika database diakses oleh beberapa koneksi, dan salah satu proses memodifikasi database, database SQLite dikunci hingga transaksi tersebut dilakukan. Parameter waktu tunggu menentukan berapa lama koneksi harus menunggu sampai kunci hilang sampai memunculkan pengecualian. Default untuk parameter batas waktu adalah 5.0 (lima detik). Jika nama database yang diberikan tidak ada maka panggilan ini akan membuat database. Anda juga dapat menentukan nama file dengan jalur yang diperlukan jika Anda ingin membuat database di tempat lain kecuali di direktori saat ini. |
| 2 | connection.cursor([cursorClass]) Rutinitas ini menciptakan file cursoryang akan digunakan di seluruh pemrograman database Anda dengan Python. Metode ini menerima satu parameter cursorClass opsional. Jika disediakan, ini harus berupa kelas kursor kustom yang memperluas sqlite3.Cursor. |
| 3 | cursor.execute(sql [, optional parameters]) Rutinitas ini menjalankan pernyataan SQL. Pernyataan SQL dapat diparameterisasi (yaitu placeholder, bukan literal SQL). Modul sqlite3 mendukung dua jenis placeholder: tanda tanya dan placeholder bernama (gaya bernama). For example - cursor.execute ("masukkan ke dalam nilai orang (?,?)", (Siapa, umur)) |
| 4 | connection.execute(sql [, optional parameters]) Rutin ini adalah jalan pintas dari metode eksekusi di atas yang disediakan oleh objek kursor dan itu membuat objek kursor perantara dengan memanggil metode kursor, kemudian memanggil metode eksekusi kursor dengan parameter yang diberikan. |
| 5 | cursor.executemany(sql, seq_of_parameters) Rutin ini mengeksekusi perintah SQL terhadap semua urutan parameter atau pemetaan yang ditemukan di urutan sql. |
| 6 | connection.executemany(sql[, parameters]) Rutin ini adalah jalan pintas yang membuat objek kursor perantara dengan memanggil metode kursor, kemudian memanggil metode eksekusi cursor.s dengan parameter yang diberikan. |
| 7 | cursor.executescript(sql_script) Rutinitas ini mengeksekusi beberapa pernyataan SQL sekaligus yang disediakan dalam bentuk script. Ini mengeluarkan pernyataan COMMIT terlebih dahulu, kemudian mengeksekusi skrip SQL yang didapatnya sebagai parameter. Semua pernyataan SQL harus dipisahkan dengan titik koma (;). |
| 8 | connection.executescript(sql_script) Rutin ini adalah pintasan yang membuat objek kursor perantara dengan memanggil metode kursor, lalu memanggil metode skrip eksekusi kursor dengan parameter yang diberikan. |
| 9 | connection.total_changes() Rutinitas ini mengembalikan jumlah baris database yang telah dimodifikasi, disisipkan, atau dihapus sejak koneksi database dibuka. |
| 10 | connection.commit() Metode ini melakukan transaksi saat ini. Jika Anda tidak memanggil metode ini, apa pun yang Anda lakukan sejak panggilan terakhir ke commit () tidak akan terlihat dari koneksi database lain. |
| 11 | connection.rollback() Metode ini mengembalikan setiap perubahan ke database sejak panggilan terakhir ke commit (). |
| 12 | connection.close() Metode ini menutup koneksi database. Perhatikan bahwa ini tidak secara otomatis memanggil commit (). Jika Anda baru saja menutup koneksi database tanpa memanggil commit () terlebih dahulu, perubahan Anda akan hilang! |
| 13 | cursor.fetchone() Metode ini mengambil baris berikutnya dari kumpulan hasil kueri, mengembalikan satu urutan, atau Tidak ada saat tidak ada lagi data yang tersedia. |
| 14 | cursor.fetchmany([size = cursor.arraysize]) Rutinitas ini mengambil rangkaian baris berikutnya dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan ketika tidak ada lagi baris yang tersedia. Metode ini mencoba mengambil baris sebanyak yang ditunjukkan oleh parameter ukuran. |
| 15 | cursor.fetchall() Rutinitas ini mengambil semua baris (tersisa) dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan jika tidak ada baris yang tersedia. |
Terhubung ke Database
Kode Python berikut menunjukkan bagaimana menghubungkan ke database yang sudah ada. Jika database tidak ada, maka akan dibuatkan dan akhirnya objek database akan dikembalikan.
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('test.db')
print "Opened database successfully";Di sini, Anda juga dapat memberikan nama database sebagai nama khusus :memory:untuk membuat database dalam RAM. Sekarang, mari kita jalankan program di atas untuk membuat database kitatest.dbdi direktori saat ini. Anda dapat mengubah jalur Anda sesuai kebutuhan Anda. Simpan kode di atas dalam file sqlite.py dan jalankan seperti yang ditunjukkan di bawah ini. Jika database berhasil dibuat, maka akan muncul pesan berikut.
$chmod +x sqlite.py $./sqlite.py
Open database successfullyBuat Tabel
Program Python berikut akan digunakan untuk membuat tabel pada database yang telah dibuat sebelumnya.
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('test.db')
print "Opened database successfully";
conn.execute('''CREATE TABLE COMPANY
(ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL);''')
print "Table created successfully";
conn.close()Ketika program di atas dijalankan, itu akan membuat tabel PERUSAHAAN di Anda test.db dan itu akan menampilkan pesan berikut -
Opened database successfully
Table created successfullyOperasi INSERT
Program Python berikut menunjukkan cara membuat record di tabel COMPANY yang dibuat pada contoh di atas.
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('test.db')
print "Opened database successfully";
conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
VALUES (1, 'Paul', 32, 'California', 20000.00 )");
conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");
conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");
conn.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 )");
conn.commit()
print "Records created successfully";
conn.close()Ketika program di atas dijalankan, itu akan membuat catatan yang diberikan di tabel PERUSAHAAN dan akan menampilkan dua baris berikut -
Opened database successfully
Records created successfullyPILIH Operasi
Program Python berikut menunjukkan bagaimana mengambil dan menampilkan record dari tabel COMPANY yang dibuat pada contoh di atas.
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('test.db')
print "Opened database successfully";
cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
print "ID = ", row[0]
print "NAME = ", row[1]
print "ADDRESS = ", row[2]
print "SALARY = ", row[3], "\n"
print "Operation done successfully";
conn.close()Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0
ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyUPDATE Operasi
Kode Python berikut menunjukkan bagaimana menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN.
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('test.db')
print "Opened database successfully";
conn.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", conn.total_changes
cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
print "ID = ", row[0]
print "NAME = ", row[1]
print "ADDRESS = ", row[2]
print "SALARY = ", row[3], "\n"
print "Operation done successfully";
conn.close()Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Total number of rows updated : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 25000.0
ID = 2
NAME = Allen
ADDRESS = Texas
SALARY = 15000.0
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfullyHAPUS Operasi
Kode Python berikut menunjukkan bagaimana menggunakan pernyataan DELETE untuk menghapus catatan apapun dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN.
#!/usr/bin/python
import sqlite3
conn = sqlite3.connect('test.db')
print "Opened database successfully";
conn.execute("DELETE from COMPANY where ID = 2;")
conn.commit()
print "Total number of rows deleted :", conn.total_changes
cursor = conn.execute("SELECT id, name, address, salary from COMPANY")
for row in cursor:
print "ID = ", row[0]
print "NAME = ", row[1]
print "ADDRESS = ", row[2]
print "SALARY = ", row[3], "\n"
print "Operation done successfully";
conn.close()Jika program diatas dijalankan maka akan menghasilkan hasil sebagai berikut.
Opened database successfully
Total number of rows deleted : 1
ID = 1
NAME = Paul
ADDRESS = California
SALARY = 20000.0
ID = 3
NAME = Teddy
ADDRESS = Norway
SALARY = 20000.0
ID = 4
NAME = Mark
ADDRESS = Rich-Mond
SALARY = 65000.0
Operation done successfully