Tutorial SQL untuk Pemula

Dalam tutorial SQL untuk pemula ini, Anda akan membuat database Anda sendiri, memasukkan data ke dalam database tersebut, dan kemudian menjalankan kueri terhadap database tersebut.

Tutorial SQL ini akan membuat Anda menjalankan kueri SQL dalam waktu singkat!

Contoh SQL

Berikut ini contoh pernyataan SQL:

SELECT * 
FROM Pets;

Ini adalah contoh sempurna betapa mudahnya menulis SQL. Pernyataan SQL sederhana ini sebenarnya banyak manfaatnya. Ini mengembalikan seluruh tabel. Ini mengembalikan semua kolom dan semua baris dari tabel yang disebut Pets .

Tanda bintang (* ) adalah karakter wildcard, yang berarti "semua kolom". Ini adalah cara cepat dan mudah untuk mendapatkan semua kolom tanpa harus mengetik semuanya.

Itulah salah satu hal indah tentang SQL. Kueri SQL paling sederhana biasanya yang paling kuat. Jika kita ingin mengembalikan lebih sedikit data, kita sebenarnya perlu menulis lebih banyak .

Misalnya, jika kita hanya menginginkan hewan peliharaan bernama Ambil , kita akan menambahkan WHERE klausul yang menetapkan persyaratan itu.

Seperti ini:

SELECT * 
FROM Pets
WHERE PetName = 'Fetch';

WHERE klausa memfilter kueri kami hanya ke baris tempat PetName kolom memiliki nilai Fetch .

Kueri ini mengasumsikan bahwa ada kolom bernama PetName dan sebuah meja bernama Pets dalam database.

Dalam tutorial SQL ini, saya akan menunjukkan cara membuat database seperti itu menggunakan SQL.

Saya juga akan menunjukkan cara memasukkan data ke dalam database itu, memperbarui data, menghapus data, dan menjalankan kueri terhadapnya.

Apa itu SQL?

SQL adalah singkatan dari Structured Query Language.

SQL adalah bahasa query standar yang digunakan untuk bekerja dengan database relasional.

SQL digunakan oleh semua Relational Database Management System (RDBMS) utama, termasuk:

Akses Microsoft
SQL Server
Oracle
PostgreSQL
MySQL
SQLite

Apa yang Dapat Saya Lakukan dengan SQL?

Anda dapat menggunakan SQL untuk menjalankan kueri terhadap database, menyisipkan catatan, memperbarui catatan, dan menghapus catatan. Anda juga dapat membuat objek database baru seperti database dan tabel. Anda juga dapat melakukan tugas administrasi database, seperti membuat login, pekerjaan otomatis, backup database, dan banyak lagi.

Bahkan ketika Anda melakukan hal-hal menggunakan Graphical User Interface (GUI), Sistem Manajemen Basis Data (DBMS) Anda hampir pasti akan menggunakan SQL di belakang layar untuk melakukan tugas itu.

Misalnya, saat Anda membuat database dengan mengklik Buat Database dan memasukkan detail database baru ke dalam kotak dialog, setelah Anda mengklik OK atau Buat atau apa pun yang dibaca tombol, sistem basis data Anda akan menggunakan SQL CREATE DATABASE pernyataan untuk melanjutkan dan membuat database seperti yang ditentukan.

Hal yang sama berlaku untuk tugas lain, seperti menjalankan kueri, memasukkan data, dll.

SQL juga memungkinkan Anda untuk melakukan tindakan lebih lanjut seperti membuat prosedur tersimpan (skrip mandiri), tampilan (kueri yang dibuat sebelumnya), dan mengatur izin pada objek database (seperti tabel, prosedur tersimpan, dan tampilan).

Karena itu, Anda tidak perlu mempelajari semua hal tingkat lanjut untuk memulai SQL. Hal yang baik tentang SQL adalah, beberapa tugas yang paling umum adalah yang paling mudah untuk ditulis.

Standar SQL

SQL distandarisasi dalam ANSI X3.135 pada tahun 1986, dan, dalam beberapa bulan, diadopsi oleh ISO sebagai ISO 9075-1987. Standar internasional (sekarang ISO/IEC 9075) telah direvisi secara berkala sejak saat itu, dan saat ini ada dalam 9 bagian.

Sebagian besar vendor database utama cenderung mematuhi standar SQL. Hal baiknya adalah Anda tidak perlu mempelajari bahasa kueri baru setiap kali Anda mempelajari DBMS baru.

Namun dalam praktiknya, ada variasi antara bagaimana setiap vendor database mengimplementasikan standar SQL. Oleh karena itu, kode yang Anda tulis di satu DBMS mungkin tidak selalu berfungsi di yang lain tanpa perlu modifikasi.

Kabar baiknya adalah bahwa semua DBMS utama mendukung tugas-tugas yang paling umum secara umum dengan cara yang sama.

Pengucapan SQL

SQL biasanya diucapkan dengan salah satu dari dua cara:

“ess-que-el ” (yaitu mengeja setiap huruf)
“sekuel ” (seperti dalam ejaan/pelafalan aslinya).

Lihat Apakah Diucapkan S-Q-L atau Sekuel jika Anda bertanya-tanya mengapa.

Apa yang Saya Butuhkan untuk Tutorial SQL ini?

Untuk benar-benar mendapat manfaat dari tutorial SQL ini, Anda harus mengikuti contoh-contohnya. Itu berarti Anda perlu tempat untuk memasukkan kueri SQL. Anda harus memiliki sesuatu seperti ini:

Jika Anda akan menjalankan kueri SQL, Anda memerlukan:

RDBMS terinstal (seperti SQL Server, MySQL, PostgreSQL, SQLite, dll).
Alat database yang memungkinkan Anda menjalankan kueri SQL terhadap RDBMS tersebut (seperti MySQL WorkBench, Azure Data Studio (gambar), DBeaver, dan SSMS).

Jika Anda sudah memiliki salah satu dari masing-masing terinstal, bagus! Anda dapat melanjutkan dengan tutorial.

Jika Anda belum menginstal ini, lihat Apa yang Saya Perlukan untuk Menjalankan SQL? untuk instruksi tentang menginstal RDBMS dan alat manajemen database yang relevan, sebelum kembali ke tutorial SQL ini.

Buat Basis Data

Setelah Anda menginstal RDBMS dan alat database yang sesuai, Anda siap untuk membuat database:

CREATE DATABASE PetHotel;

Selesai!

Pernyataan itu sebenarnya membuat database. Basis data kosong, tetapi basis data tetap.

Database ini akan berisi tabel dan data yang digunakan dalam tutorial SQL ini. Saat kita membuat tabel atau menyisipkan data, kita akan melakukannya di dalam database ini.

Saya harus menyebutkan bahwa SQLite menggunakan sintaks yang berbeda untuk membuat database. Jika Anda menggunakan SQLite, berikut cara membuat database di SQLite.

Hubungkan ke Basis Data

Sebelum Anda mulai membuat tabel, menyisipkan data, dan sebagainya, Anda harus yakin bahwa Anda berada di database yang benar. Membuat database (seperti yang baru saja kita lakukan) tidak serta merta menghubungkan Anda ke database tersebut.

Di banyak DBMS (seperti SQL Server , MySQL dan MariaDB ), kita dapat menggunakan yang berikut ini untuk beralih ke database yang ditentukan:

USE PetHotel;

Itu membuat PetHotel database saat ini.

Di SQLite , Anda mungkin sudah berada di database setelah membuatnya. Jika tidak, Anda dapat melampirkan database (yang juga akan membuatnya jika belum ada):

ATTACH DATABASE 'PetHotel.db' AS Pets;

Di PostgreSQL , jika Anda menggunakan alat psql, Anda dapat menggunakan yang berikut ini:

\connect PetHotel

Atau versi singkatnya:

\c PetHotel

Saya harus menyebutkan bahwa proses membuat dan menghubungkan ke database dapat sangat berbeda antara DBMS.

Untungnya, sebagian besar alat GUI memungkinkan Anda terhubung ke database dengan mengklik dua kali pada database, atau mengklik kanan pada nama database dan memilih tab kueri baru dari menu konteks. Jika Anda terjebak pada langkah ini, cukup gunakan GUI untuk membuat dan/atau menyambungkan ke DB Anda.

Buat Tabel

Sekarang setelah Anda terhubung ke database yang tepat, Anda dapat melanjutkan dan membuat beberapa tabel.

Untuk membuat tabel di SQL, gunakan CREATE TABLE pernyataan.

Saat Anda membuat tabel, Anda perlu menentukan kolom apa yang akan ada di tabel, serta tipe datanya. Anda juga dapat menentukan detail lainnya, tetapi jangan terburu-buru.

Mari kita buat tabel:

CREATE TABLE PetTypes
(
    PetTypeId   int NOT NULL PRIMARY KEY,
    PetType     varchar(60) NOT NULL
);

Dalam hal ini kita membuat tabel bernama PetTypes . Kita tahu itu, karena nama tabel muncul tepat setelah CREATE TABLE sedikit.

Setelah itu muncul daftar kolom, diapit dalam tanda kurung.

Tabel di atas berisi kolom berikut:

PetIdId
PetType

Setiap kolom diikuti oleh tipe datanya:

int berarti kolom ini menerima bilangan bulat. Sejauh yang saya ketahui, sebagian besar DBMS utama mendukung deklarasi kolom sebagai int . Jika Anda memiliki masalah, coba gunakan integer .
varchar(60) berarti kolom ini menerima string hingga 60 karakter. varchar kolom adalah string dengan panjang variabel. Tipe data string lainnya adalah char (yang merupakan string dengan panjang tetap). Jika Anda mengalami masalah saat mencoba mendefinisikan kolom sebagai varchar(60) , coba gunakan char(60) .

`NOT NULL` Batasan

Dalam contoh ini, kedua kolom didefinisikan dengan NOT NULL kendala. NOT NULL kendala berarti kolom ini tidak boleh kosong. Saat baris baru dimasukkan, NOT NULL any kolom harus mengandung suatu nilai. Kolom lain dapat tetap kosong jika tidak ada data untuk kolom tersebut.

Jika NULL nilai diperbolehkan di kolom, Anda dapat menghilangkan NOT NULL bagian, atau mendeklarasikannya sebagai NULL (artinya, NULL nilai diperbolehkan di kolom ini).

Beberapa DBMS (seperti DB2) tidak mendukung NULL kata kunci, jadi Anda harus menghilangkannya saat bekerja dengan DBMS semacam itu.

Kunci Utama

Kami juga membuat PetTypeId kolom kunci utama. Kunci utama adalah satu atau lebih kolom yang secara unik mengidentifikasi setiap baris dalam tabel. Anda menentukan kolom yang Anda pilih sebagai kunci utama dengan menggunakan batasan kunci utama. Anda dapat melakukannya di CREATE TABLE pernyataan (seperti yang kami lakukan di sini), atau Anda dapat menambahkannya nanti dengan ALTER TABLE penyataan.

Kunci utama harus berisi nilai unik. Artinya, untuk setiap baris dalam tabel itu, nilai di kolom kunci utama/s harus berbeda di setiap baris. Ini bisa sesederhana memiliki angka yang bertambah (seperti 1, 2, 3… dll) atau bisa juga kode produk (seperti pr4650, pr2784, pr5981… dll).

Juga, kunci utama harus berisi nilai. Tidak boleh NULL .

Meskipun kunci utama tidak diperlukan, umumnya dianggap sebagai praktik yang baik untuk mendefinisikan kunci utama di setiap tabel.

Buat Lebih Banyak Tabel

Mari buat dua tabel lagi:

CREATE TABLE Owners
(
    OwnerId     int NOT NULL PRIMARY KEY,
    FirstName   varchar(60) NOT NULL,
    LastName    varchar(60) NOT NULL,
    Phone       varchar(20) NOT NULL,
    Email       varchar(254)
);

CREATE TABLE Pets
(
    PetId       int NOT NULL PRIMARY KEY,
    PetTypeId   int NOT NULL REFERENCES PetTypes (PetTypeId),
    OwnerId     int NOT NULL REFERENCES Owners (OwnerId),
    PetName     varchar(60) NOT NULL,
    DOB         date NULL
);

Kedua tabel ini mirip dengan yang pertama, kecuali bahwa mereka memiliki lebih banyak baris, dan beberapa bagian tambahan, yang akan saya jelaskan di bawah.

Jika Anda tertarik, lihat SQL CREATE TABLE untuk Pemula untuk beberapa contoh sederhana membuat tabel di SQL.

Hubungan

Saat kami membuat Pets tabel, kami benar-benar membuat hubungan antara tiga tabel.

Hubungan tersebut digambarkan dalam diagram berikut.

Hubungan database adalah bagian penting dari SQL. Hubungan memungkinkan kami untuk membuat kueri beberapa tabel untuk data terkait dan mendapatkan hasil yang akurat dan konsisten.

Dalam kasus kami, kami ingin dapat mencari hewan peliharaan berdasarkan pemiliknya, atau hewan peliharaan berdasarkan jenis hewan peliharaan, dll. Dan kami ingin hasil kami akurat dan konsisten.

Untuk mencapai ini, kita perlu bersikeras bahwa semua hewan peliharaan dimasukkan bersama dengan pemilik dan jenis hewan peliharaan mereka. Oleh karena itu kita perlu memastikan bahwa, setiap kali hewan peliharaan baru ditambahkan ke Pets tabel, sudah ada pemilik yang sesuai di Owners tabel, dan jenis hewan peliharaan yang sesuai di PetTypes meja.

Pada dasarnya, persyaratan kami adalah sebagai berikut:

Nilai apa pun dalam Pets.PetTypeId kolom harus cocok dengan nilai di PetTypes.PetTypeId kolom.
Nilai apa pun di Pets.OwnerId kolom harus cocok dengan nilai di Owners.OwnerId kolom.

Kami dapat memastikan persyaratan di atas dengan membuat batasan kunci asing terhadap kolom yang berlaku. Kunci asing batasan digunakan untuk menentukan bahwa kolom tertentu mereferensikan kunci utama dari tabel lain.

Kode di atas memang membuat dua batasan kunci asing pada Pets tabel.

Perhatikan bahwa PetTypeId dan OwnerId kolom memiliki beberapa kode tambahan yang dimulai dengan REFERENCES... . Itu adalah bagian yang menciptakan dua kunci asing.

Saat kami membuat Pets tabel, PetTypeId kolom memiliki sedikit yang masuk REFERENCES PetTypes (PetTypeId) . Ini berarti bahwa Pets.PetTypeId kolom mereferensikan PetTypeId kolom di PetTypes tabel.

Ini adalah kesepakatan yang sama untuk OwnerId kolom. Ini merujuk pada OwnerId kolom Owners tabel.

Di sebagian besar DBMS, kunci asing juga dapat dibuat pada tabel yang ada, dengan menggunakan ALTER TABLE pernyataan, tetapi kami tidak akan membahasnya di sini. Lihat Cara Membuat Hubungan di SQL untuk mengetahui lebih lanjut tentang itu.

Bagaimanapun, kunci asing kami telah dibuat. Sekarang, setiap kali seseorang memasukkan hewan peliharaan baru ke dalam Pets tabel, PetTypeId dan OwnerId nilai harus memiliki nilai yang sesuai di PetTypes dan Owners tabel masing-masing. Jika salah satu dari mereka tidak, database akan mengembalikan kesalahan.

Ini adalah manfaat dari kunci asing. Ini membantu untuk mencegah data buruk yang dimasukkan. Ini membantu menjaga integritas data dan lebih khusus lagi, integritas referensial.

Periksa Batasan

memeriksa batasan adalah jenis kendala lain yang harus Anda waspadai. Batasan pemeriksaan memeriksa data sebelum memasuki database. Saat tabel memiliki batasan pemeriksaan yang diaktifkan, data hanya bisa masuk ke tabel jika tidak melanggar batasan itu. Data yang melanggar batasan tidak dapat masuk ke tabel.

Misalnya, Anda dapat membuat batasan pemeriksaan pada Price kolom untuk memastikan bahwa itu hanya menerima nilai yang lebih besar dari nol. Atau kita bisa menerapkan batasan cek ke Pets our tabel untuk memastikan bahwa DOB kolom tidak ada di masa mendatang.

Sebagai contoh, lihat Apa yang dimaksud dengan CHECK Constraint?

Spasi Putih

Anda mungkin telah memperhatikan bahwa contoh saya termasuk spasi. Misalnya, saya telah memberi spasi kode di beberapa baris, dan saya telah menggunakan tab untuk membuat indentasi tipe data, dll.

Ini benar-benar valid dalam SQL. Anda dapat melakukan ini dengan aman, dan itu tidak akan memengaruhi hasilnya. SQL memungkinkan Anda untuk menyebarkan kode di beberapa baris jika diinginkan, dan memungkinkan Anda menggunakan banyak spasi atau tab untuk meningkatkan keterbacaan.

Komentar

Anda juga dapat memasukkan komentar dalam kode Anda. Komentar dapat berguna setelah Anda mulai menulis skrip SQL yang lebih panjang. Setelah skrip menjadi cukup panjang, komentar dapat mempermudah untuk mengidentifikasi dengan cepat apa yang dilakukan setiap bagian.

Komentar Sebaris

Anda dapat membuat komentar sebaris dengan mengawali komentar Anda dengan dua karakter tanda hubung (-- ):

SELECT * FROM Pets; --This is a comment

-- This is a comment
SELECT * FROM Owners;

Dalam contoh ini, kedua kueri akan berjalan tanpa masalah. Komentar akan diabaikan oleh DBMS.

Komentar Multibaris

Anda dapat menyebarkan komentar ke beberapa baris dengan mengelilingi komentar dengan /* dan */ :

/*
This is a longer comment so
it's spread across multiple lines
*/
SELECT * FROM Pets;

Dalam contoh ini, kedua kueri akan berjalan tanpa masalah. Komentar akan diabaikan oleh DBMS.

MySQL

Jika Anda menggunakan MySQL, Anda juga dapat menggunakan tanda angka/tanda hash (# ) untuk komentar satu baris.

# This is a comment
SELECT * FROM Pets;

Kode Komentar

Manfaat keren lainnya dari komentar adalah Anda dapat berkomentar kode. Misalnya, jika Anda memiliki skrip SQL panjang yang melakukan banyak hal, tetapi Anda hanya ingin menjalankan satu atau dua bagian saja, Anda dapat berkomentar sisa skrip.

Ini contohnya:

-- SELECT * FROM Pets;

SELECT * FROM Owners;

Dalam hal ini, SELECT first pertama pernyataan telah dikomentari, dan hanya SELECT . kedua pernyataan akan dijalankan.

Anda juga dapat menggunakan komentar multibaris untuk teknik ini.

Sisipkan Data

Sekarang kita telah membuat tiga tabel dan membuat kunci asing yang sesuai, kita dapat melanjutkan dan menambahkan data.

Cara paling umum untuk menyisipkan data dalam SQL adalah dengan INSERT penyataan. Kurang lebih seperti ini:

INSERT INTO MyTable( Column1, Column2, Column3, ... )
VALUES( Value1, Value2, Value3, ... );

Anda cukup mengganti MyTable dengan nama tabel tempat Anda memasukkan data. Demikian juga, Anda mengganti Column1 , dll dengan nama kolom, dan Value1 , dll dengan nilai yang masuk ke kolom tersebut.

Misalnya, kita bisa melakukan ini:

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Setiap nilai berada dalam urutan yang sama dengan kolom yang ditentukan.

Perhatikan bahwa nama kolom cocok dengan nama yang kita gunakan saat membuat tabel.

Anda dapat menghilangkan nama kolom jika Anda memasukkan data ke semua kolom. Jadi kita bisa mengubah contoh di atas menjadi seperti ini:

INSERT INTO Pets
VALUES( 1, 2, 3, 'Fluffy', '2020-12-20' );

Untuk tutorial ini, kami akan menambahkan beberapa baris lagi, jadi kami akan menambahkan lebih banyak INSERT INTO pernyataan – satu untuk setiap baris yang ingin kita sisipkan.

Jadi mari kita lanjutkan dan isi tabel kita.

INSERT INTO Owners( OwnerId, FirstName, LastName, Phone, Email )
VALUES( 1, 'Homer', 'Connery', '(308) 555-0100', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone, Email)
VALUES( 2, 'Bart', 'Pitt', '(231) 465-3497', '[email protected]' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 3, 'Nancy', 'Simpson', '(489) 591-0408' );
INSERT INTO Owners(OwnerId, FirstName, LastName, Phone)
VALUES( 4, 'Boris', 'Trump', '(349) 611-8908' ); 

INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 1, 'Bird' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 2, 'Cat' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 3, 'Dog' );
INSERT INTO PetTypes( PetTypeId, PetType )
VALUES( 4, 'Rabbit' );

INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 1, 2, 3, 'Fluffy', '2020-11-20' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 2, 3, 3, 'Fetch', '2019-08-16' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 3, 2, 2, 'Scratch', '2018-10-01' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 4, 3, 3, 'Wag', '2020-03-15' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 5, 1, 1, 'Tweet', '2020-11-28' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName, DOB )
VALUES( 6, 3, 4, 'Fluffy', '2020-09-17' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 7, 3, 2, 'Bark' );
INSERT INTO Pets( PetId, PetTypeId, OwnerId, PetName )
VALUES( 8, 2, 4, 'Meow' );

Perhatikan bahwa kami mengisi Pets meja terakhir. Ada alasan untuk ini.

Jika kami telah mencoba memasukkan data ke dalam Pets tabel sebelum mengisi dua lainnya, kami akan menerima kesalahan, karena batasan kunci asing kami. Dan untuk alasan yang bagus. Lagi pula, kami akan mencoba memasukkan nilai di kolom kunci asing yang belum ada di kolom kunci utama di tabel lain. Itu adalah "tidak tidak" yang besar dalam hal kunci asing.

Jadi dengan mengisi Owners dan PetType tabel terlebih dahulu, kami memastikan bahwa nilai yang sesuai sudah ada di kolom kunci utama sebelum kami mengisi kolom kunci asing di Pets tabel.

Lihat SQL INSERT untuk Pemula untuk lebih banyak contoh memasukkan data ke dalam tabel.

Periksa Data Kami

Fiuh! Akhirnya kita bisa mulai menjalankan query terhadap database kita.

Mari kita periksa data di semua tabel kita.

SELECT * FROM Pets;
SELECT * FROM PetTypes;
SELECT * FROM Owners;

Hasil:

+---------+-------------+-----------+-----------+------------+
| PetId   | PetTypeId   | OwnerId   | PetName   | DOB        |
|---------+-------------+-----------+-----------+------------|
| 1       | 2           | 3         | Fluffy    | 2020-11-20 |
| 2       | 3           | 3         | Fetch     | 2019-08-16 |
| 3       | 2           | 2         | Scratch   | 2018-10-01 |
| 4       | 3           | 3         | Wag       | 2020-03-15 |
| 5       | 1           | 1         | Tweet     | 2020-11-28 |
| 6       | 3           | 4         | Fluffy    | 2020-09-17 |
| 7       | 3           | 2         | Bark      | NULL       |
| 8       | 2           | 4         | Meow      | NULL       |
+---------+-------------+-----------+-----------+------------+
(8 rows affected)
+-------------+-----------+
| PetTypeId   | PetType   |
|-------------+-----------|
| 1           | Bird      |
| 2           | Cat       |
| 3           | Dog       |
| 4           | Rabbit    |
+-------------+-----------+
(4 rows affected)
+-----------+-------------+------------+----------------+-------------------+
| OwnerId   | FirstName   | LastName   | Phone          | Email             |
|-----------+-------------+------------+----------------+-------------------|
| 1         | Homer       | Connery    | (308) 555-0100 | [email protected] |
| 2         | Bart        | Pitt       | (231) 465-3497 | [email protected]  |
| 3         | Nancy       | Simpson    | (489) 591-0408 | NULL              |
| 4         | Boris       | Trump      | (349) 611-8908 | NULL              |
+-----------+-------------+------------+----------------+-------------------+
(4 rows affected)

Bagus, jadi sepertinya data berhasil dimasukkan.

Pilih Kolom Tertentu

Ini umumnya dianggap praktik yang buruk untuk memilih semua baris dan semua kolom dari tabel (seperti yang kami lakukan pada contoh sebelumnya), kecuali jika Anda benar-benar perlu. Melakukan hal ini dapat berdampak pada kinerja server database Anda, terutama jika ada banyak baris dalam tabel.

Ini bukan masalah ketika Anda menggunakan kumpulan data kecil seperti kami di sini, atau jika Anda berada di lingkungan pengembangan atau serupa. Jika tidak, biasanya lebih baik memilih kolom yang Anda butuhkan saja.

Oleh karena itu, jika kita menginginkan ID, nama, dan tanggal lahir semua hewan peliharaan, kita dapat melakukan ini:

SELECT PetId, PetName, DOB 
FROM Pets;

Hasil:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 3       | Scratch   | 2018-10-01 |
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 6       | Fluffy    | 2020-09-17 |
| 7       | Bark      | NULL       |
| 8       | Meow      | NULL       |
+---------+-----------+------------+

Jika kita menginginkan ID, dan tanggal lahir semua hewan peliharaan bernama Fluffy, kita bisa menggunakan ini:

SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy';

Hasil:

+---------+------------+
| PetId   | DOB        |
|---------+------------|
| 1       | 2020-11-20 |
| 6       | 2020-09-17 |
+---------+------------+

Anda juga dapat menggunakan SELECT pernyataan untuk mengembalikan data tanpa tabel. Artinya, dapat mengembalikan data yang tidak disimpan dalam tabel. Lihat SQL SELECT Pernyataan untuk Pemula untuk melihat contoh.

Penyortiran

SQL menyediakan ORDER BY klausa yang memungkinkan kita untuk mengurutkan data.

Kita dapat menambahkan ORDER BY klausa untuk contoh kami sebelumnya sehingga hewan peliharaan diurutkan berdasarkan namanya:

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName ASC;

Hasil:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 7       | Bark      | NULL       |
| 2       | Fetch     | 2019-08-16 |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 8       | Meow      | NULL       |
| 3       | Scratch   | 2018-10-01 |
| 5       | Tweet     | 2020-11-28 |
| 4       | Wag       | 2020-03-15 |
+---------+-----------+------------+

ASC bagian berarti naik . Saat Anda menggunakan ORDER BY klausa, defaultnya naik, jadi Anda bisa menghilangkan ASC bagian jika Anda mau.

Untuk mengurutkannya dalam descending pesan, gunakan DESC .

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC;

Hasil:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 1       | Fluffy    | 2020-11-20 |
| 6       | Fluffy    | 2020-09-17 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Anda juga dapat mengurutkan hasil menggunakan beberapa kolom. Ini akan mengurutkan berdasarkan kolom pertama yang ditentukan, kemudian jika ada duplikat di kolom itu, itu akan mengurutkan duplikat tersebut berdasarkan kolom kedua yang ditentukan, dan seterusnya.

SELECT PetId, PetName, DOB 
FROM Pets
ORDER BY PetName DESC, DOB ASC;

Hasil:

+---------+-----------+------------+
| PetId   | PetName   | DOB        |
|---------+-----------+------------|
| 4       | Wag       | 2020-03-15 |
| 5       | Tweet     | 2020-11-28 |
| 3       | Scratch   | 2018-10-01 |
| 8       | Meow      | NULL       |
| 6       | Fluffy    | 2020-09-17 |
| 1       | Fluffy    | 2020-11-20 |
| 2       | Fetch     | 2019-08-16 |
| 7       | Bark      | NULL       |
+---------+-----------+------------+

Lihat bagaimana kedua Fluffy bertukar posisi.

Jika Anda tidak menggunakan ORDER BY klausa, tidak ada jaminan urutan hasil Anda nantinya. Meskipun mungkin terlihat seperti database Anda mengurutkan hasil berdasarkan kolom tertentu, ini mungkin tidak benar-benar terjadi. Secara umum, tanpa ORDER BY klausa, data akan diurutkan dalam urutan yang dimuat ke dalam tabel. Namun, jika baris telah dihapus atau diperbarui, urutannya akan dipengaruhi oleh cara DBMS menggunakan kembali ruang penyimpanan yang direklamasi.

Oleh karena itu, jangan mengandalkan DBMS untuk mengurutkan hasil dalam urutan yang berarti.

Intinya:Jika Anda ingin hasil Anda diurutkan, gunakan ORDER BY .

Lihat SQL ORDER BY Klausa untuk Pemula untuk contoh lainnya.

Hitung Baris dalam Kumpulan Hasil

Anda dapat menggunakan COUNT() fungsi agregat untuk menghitung baris yang akan dikembalikan dalam kueri.

SELECT COUNT(*) AS Count
FROM Pets;

Hasil:

+---------+
| Count   |
|---------|
| 8       |
+---------+

Ini memberitahu kita bahwa ada 8 baris dalam tabel. Kami tahu itu karena kami memilih semua baris dan semua kolom.

Anda dapat menggunakan COUNT() pada kueri apa pun, misalnya kueri yang menggunakan WHERE klausa untuk memfilter hasil.

Anda juga dapat menentukan kolom tertentu untuk dihitung. COUNT() fungsi hanya menghitung non-NULL hasil, jadi jika Anda menentukan kolom yang berisi NULL nilai, nilai tersebut tidak akan dihitung.

Berikut adalah contoh untuk menunjukkan apa yang saya maksud.

SELECT COUNT(DOB) AS Count
FROM Pets;

Hasil:

+---------+
| Count   |
|---------|
| 6       |
+---------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Anda mungkin ingat bahwa Pets tabel berisi dua NULL nilai dalam DOB kolom (dua hewan peliharaan belum memberikan tanggal lahir mereka), jadi COUNT(DOB) mengembalikan 6, bukannya 8 saat kita menggunakan COUNT(*) . Alasan COUNT(*) mengembalikan semua baris, karena kedua baris itu melakukannya memiliki data di kolom lain.

Dalam contoh saya, DBMS saya juga mengembalikan peringatan tentang ini. Anda mungkin mendapatkan peringatan atau tidak, tergantung pada DBMS dan konfigurasi spesifik Anda.

Lihat SQL COUNT untuk Pemula untuk lebih banyak contoh.

Fungsi agregat lainnya termasuk:AVG() , SUM() , MIN() , dan MAX() .

Kelompokkan Menurut

Klausa lain yang berguna adalah GROUP BY ayat. Ini melakukan cukup banyak apa yang dijanjikan namanya. Ini memungkinkan Anda untuk mengelompokkan hasil berdasarkan kolom tertentu.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
ORDER BY Count DESC;

Hasil:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
| 1           | 1       |
+-------------+---------+

Dalam contoh ini, kita menghitung berapa banyak hewan peliharaan yang kita miliki untuk setiap jenis hewan peliharaan, lalu mengurutkannya dalam urutan menurun (dengan jumlah tertinggi di bagian atas).

Lihat SQL GROUP BY Klausa untuk Pemula untuk contoh lainnya.

The `HAVING` Klausa

Kita dapat menggunakan HAVING klausa untuk memfilter hasil dalam GROUP BY ayat. Kode HAVING klausa mengembalikan baris di mana nilai agregat memenuhi kondisi yang ditentukan.

Ini contohnya.

SELECT 
    PetTypeId, 
    COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;

Hasil:

+-------------+---------+
| PetTypeId   | Count   |
|-------------+---------|
| 3           | 4       |
| 2           | 3       |
+-------------+---------+

Dalam hal ini, kami mengembalikan data hanya untuk jenis hewan peliharaan yang memiliki lebih dari 2 hewan peliharaan yang ditetapkan untuk jenis tersebut.

Lihat SQL HAVING Klausa untuk Pemula untuk contoh lainnya.

Bergabung

Dalam SQL, gabung adalah tempat Anda menjalankan kueri yang menggabungkan data dari beberapa tabel.

Dua contoh sebelumnya boleh saja, tetapi akan lebih baik jika mereka menampilkan jenis hewan peliharaan yang sebenarnya (misalnya Kucing, Anjing, Burung, dll) daripada ID (misalnya 1, 2, 3, dll).

Satu-satunya masalah adalah, Pets tabel tidak berisi data itu. Data itu ada di PetTypes tabel.

Untungnya bagi kami, kami dapat melakukan gabungan antara dua tabel ini. Berikut adalah contoh yang menggunakan LEFT JOIN :

SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType
ORDER BY Count DESC;

Hasil:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Kumpulan hasil ini jauh lebih mudah dibaca daripada yang sebelumnya. Lebih mudah untuk memahami berapa banyak dari setiap jenis hewan peliharaan dalam tabel.

Sintaksnya menggunakan tipe join (dalam hal ini LEFT JOIN ), diikuti oleh tabel pertama (kiri), diikuti oleh ON , diikuti dengan kondisi join.

Mari gunakan INNER JOIN untuk mengembalikan semua nama hewan peliharaan dengan jenis hewan peliharaannya masing-masing.

SELECT 
    Pets.PetName,
    PetTypes.PetType
FROM Pets 
INNER JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId;

Hasil:

+-----------+-----------+
| PetName   | PetType   |
|-----------+-----------|
| Fluffy    | Cat       |
| Fetch     | Dog       |
| Scratch   | Cat       |
| Wag       | Dog       |
| Tweet     | Bird      |
| Fluffy    | Dog       |
| Bark      | Dog       |
| Meow      | Cat       |
+-----------+-----------+

Bergabung benar-benar membuka opsi kami, karena kami sekarang dapat mengambil data dari beberapa tabel dan menyajikannya seolah-olah itu adalah satu tabel.

Anda akan melihat bahwa dalam contoh gabungan, kami mengkualifikasikan nama kolom kami dengan nama tabel. Alasan kami melakukan ini adalah untuk menghindari ambiguitas mengenai nama kolom kolom di antara tabel. Kedua tabel dapat memiliki kolom dengan nama yang sama (seperti dalam contoh kami), dan dalam kasus seperti itu, DBMS tidak akan tahu kolom mana yang Anda maksud. Mengawali nama kolom dengan nama tabelnya memastikan bahwa Anda mereferensikan kolom yang benar, dan mencegah kesalahan apa pun yang dapat diakibatkan oleh ambiguitas tentang kolom mana yang Anda maksud.

Lihat Tutorial Bergabung SQL saya untuk lebih banyak contoh dan penjelasan tentang berbagai jenis bergabung.

Alias

Kita dapat melangkah lebih jauh dan menetapkan alias untuk setiap nama tabel dan nama kolom.

SELECT 
    p.PetName AS Pet,
    pt.PetType AS "Pet Type"
FROM PetTypes pt
LEFT JOIN Pets p
ON p.PetTypeId = pt.PetTypeId;

Hasil:

+---------+------------+
| Pet     | Pet Type   |
|---------+------------|
| Tweet   | Bird       |
| Fluffy  | Cat        |
| Scratch | Cat        |
| Meow    | Cat        |
| Fetch   | Dog        |
| Wag     | Dog        |
| Fluffy  | Dog        |
| Bark    | Dog        |
| NULL    | Rabbit     |
+---------+------------+

Ini menghasilkan header kolom baru, ditambah kode yang lebih ringkas.

Alias memungkinkan Anda untuk sementara menetapkan nama lain ke tabel atau kolom selama SELECT pertanyaan. Ini bisa sangat berguna ketika tabel dan/atau kolom memiliki nama yang sangat panjang atau kompleks.

Alias diberikan melalui penggunaan AS kata kunci, meskipun kata kunci ini opsional, sehingga Anda dapat menghilangkannya dengan aman. Perhatikan bahwa Oracle tidak mendukung AS kata kunci pada alias tabel (tetapi tidak pada alias kolom).

Dalam contoh di atas, saya telah menyertakan AS kata kunci saat menetapkan alias kolom, tetapi menghilangkannya saat menetapkan alias tabel.

Nama alias bisa apa saja, tetapi biasanya disingkat agar mudah dibaca.

Dalam kasus kami, kami mengubah dua tabel menjadi p dan pt , dan nama kolom menjadi Pet dan Pet Type . Perhatikan bahwa saya mengelilingi Pet Type dalam tanda kutip ganda. Saya melakukan ini, karena ada spasi di namanya. Untuk alias tanpa spasi, Anda tidak perlu melakukan ini. Di SQL Server, Anda juga dapat menggunakan tanda kurung siku ([] ) alih-alih tanda kutip ganda (meskipun juga mendukung tanda kutip ganda).

Praktik menggunakan spasi dalam kolom dan alias umumnya tidak disarankan, karena dapat menyebabkan segala macam masalah dengan beberapa aplikasi klien.

Perhatikan bahwa kami masih perlu menggunakan nama kolom lengkap saat mereferensikannya di gabungan (setelah ON kata kunci).

Saya harus menunjukkan bahwa menetapkan alias tidak benar-benar mengubah nama kolom atau tabel.

Lihat Penjelasan SQL Alias untuk lebih banyak contoh.

Memperbarui Data

Anda dapat menggunakan UPDATE pernyataan untuk memperbarui data di tabel Anda.

Sintaks dasarnya cukup sederhana:

UPDATE Owners
SET LastName = 'Stallone'
WHERE OwnerId = 3;

Dalam contoh itu, kami memperbarui LastName kolom untuk memiliki nilai baru Stallone di mana OwnerId adalah 3 .

Untuk memperbarui beberapa kolom, gunakan koma untuk memisahkan setiap pasangan kolom/nilai.

Tapi apapun yang kamu lakukan, jangan lupa WHERE klausa (kecuali jika Anda benar-benar ingin memperbarui setiap baris dalam tabel dengan nilai yang sama).

Lihat SQL UPDATE untuk Pemula untuk lebih banyak contoh dan penjelasan lebih rinci.

Menghapus Data

Anda dapat menggunakan DELETE pernyataan untuk menghapus data dari tabel Anda.

Sintaks dasarnya bahkan lebih sederhana daripada UPDATE pernyataan:

DELETE FROM Owners
WHERE OwnerId = 5;

Di sini, kami menghapus pemilik nomor 5 dari Owners tabel.

Seperti halnya UPDATE pernyataan, jangan lupa WHERE klausa (kecuali jika Anda bermaksud menghapus setiap baris dalam tabel ).

Lihat SQL DELETE untuk Pemula untuk lebih banyak contoh dan penjelasan rinci.

Menjatuhkan Objek

Saat kita sedang menghapus sesuatu, saat Anda menghapus objek database (seperti tabel, tampilan, prosedur tersimpan, dll), dikatakan bahwa Anda "menjatuhkan" objek itu. Misalnya, jika Anda tidak lagi membutuhkan meja, Anda “menjatuhkannya”.

Sintaksnya sangat sederhana, seperti ini:

DROP TABLE Customers;

Tiga kata itu sepenuhnya menghapus tabel yang disebut Customers . Tabel dan semua datanya sekarang hilang.

Seperti yang dapat Anda bayangkan, ini bisa menjadi pernyataan yang sangat berbahaya, dan harus digunakan dengan sangat hati-hati.

The same syntax can be used for other object types, except you would replace table with the object type (for example DROP VIEW vPets drops a view called vPets ).

If you try to drop a table that is referenced by a foreign key, you’ll probably get an error. In this case, you’ll need to either drop the foreign key (using the ALTER TABLE statement) or the child table itself.

SQL Operators

In SQL, an operator is a symbol specifying an action that is performed on one or more expressions.

Operators manipulate individual data items and return a result. The data items are called operands or arguments . In SQL, operators are represented by special characters or by keywords.

We’ve already seen some operators in action. Some of our previous example queries had a WHERE clause that included the Equals operator (= ). We also ran a query that used the Greater Than operator (> ). These are both comparison operators – they compare two expressions.

See 12 Commonly Used Operators in SQL for examples of operators that you’re likely to need when working with SQL.

You can also use this list of SQL Operators as a reference for the operators available in SQL.

SQL Views

In SQL, a view is a query that’s saved to the database as a database object (just like a table). The term can also be used to refer to the result set of a stored query. Views are often referred to as virtual tables .

To create a view, you write a query, then save it as a view. You do this using the CREATE VIEW sintaks.

Here’s an example of creating a view:

CREATE VIEW vPetTypeCount AS
SELECT 
    PetTypes.PetType,
    COUNT(Pets.PetTypeId) AS Count
FROM Pets 
LEFT JOIN PetTypes 
ON Pets.PetTypeId = PetTypes.PetTypeId
GROUP BY PetTypes.PetType;

Running that code creates the view and stores it as an object in the database.

We can now query the view, just like we’d query a table.

Hasil:

SELECT * FROM vPetTypeCount;

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Bird      | 1       |
| Cat       | 3       |
| Dog       | 4       |
+-----------+---------+

So we get the same result as we would have got if we’d run the original query, but saving it in a view made it a lot easier to query.

This benefit would become greater, the more complex the query is.

Views and the ORDER BY Clause

One thing I should point out is that the original query had an ORDER BY clause, but I didn’t include that in the view. The SQL standard does not allow the ORDER BY clause in any view definition. Also, most RDBMSs will raise an error if you try to include an ORDER BY klausa.

This isn’t a problem though, because you can sort the results when you query the view. Therefore, we can do something like this:

SELECT * FROM vPetTypeCount
ORDER BY Count DESC;

Hasil:

+-----------+---------+
| PetType   | Count   |
|-----------+---------|
| Dog       | 4       |
| Cat       | 3       |
| Bird      | 1       |
+-----------+---------+

Most RDBMSs also include a large set of system views that you can use to retrieve information about the system.

For more about views, see What is a View?

Stored Procedures

A stored procedure is a series of SQL statements compiled and saved to the database. Stored procedures are similar to views in some respects, but very different in other respects.

One of the benefits of stored procedures is that they allow you to store complex scripts on the server. Stored procedures often contain conditional programming such as IF... ELSE statements, for example. Stored procedures can also accept parameters.

Here’s an example of creating a simple stored procedure in SQL Server to get pet information from our database:

CREATE PROCEDURE uspGetPetById
    @PetId int
AS
    SET NOCOUNT ON;
    SELECT 
        p.PetName, 
        p.DOB, 
        pt.PetType,
        CONCAT(o.FirstName, ' ', o.LastName) AS OwnerName
    FROM Pets p 
    INNER JOIN PetTypes pt 
    ON p.PetTypeId = pt.PetTypeId
    INNER JOIN Owners o 
    ON o.OwnerId = p.OwnerId
    WHERE p.PetId = @PetId;

This stored procedure accepts a parameter called @PetId . This means that when you call the procedure, you need to pass the ID of the pet that you’d like information about. The procedure then selects data from various tables and returns it.

To call the stored procedure, use the EXECUTE penyataan. You can alternatively shorten it to EXEC . In PostgreSQL, use the CALL pernyataan.

EXEC uspGetPetById @PetId = 3;

Hasil:

+-----------+------------+-----------+-------------+
| PetName   | DOB        | PetType   | OwnerName   |
|-----------+------------+-----------+-------------|
| Scratch   | 2018-10-01 | Cat       | Bart Pitt   |
+-----------+------------+-----------+-------------+

In this case I was interested in pet number 3, and so that’s the info that I got.

I should mention that the syntax for creating stored procedures can differ quite significantly between DBMSs (as well as their implementations of various SQL statements and commands that you’d use inside a procedure), so I would suggest that you look at the documentation for your particular DBMS if you want to create a stored procedure.

Most RDBMSs also include a large set of system stored procedures that you can use to perform various administration tasks, and to retrieve information about the system.

For a basic overview of stored procedures, including their benefits, see What is a Stored Procedure?

Also, if you’re interested, see How to Create a Stored Procedure in SQL Server to see another example of creating a stored procedure in SQL Server. That example includes some screenshots.

SQL Triggers

A trigger is a special type of stored procedure that automatically executes when an event occurs in the database server.

Most major RDBMSs support DML triggers, which execute when a user tries to modify data through a data manipulation language (DML) event. DML events are INSERT , UPDATE , or DELETE pernyataan.

Some DBMSs (such as SQL Server and PostgreSQL) allow triggers to be associated with both tables and views. Others only allow triggers to be associated with tables.

SQL Server also supports DDL triggers and logon triggers.

DDL triggers execute in response to DDL events, such as CREATE , ALTER , and DROP statements, and certain system stored procedures that perform DDL-like operations.

Logon triggers are fired in response to the LOGON event that’s raised when a user’s session is being established.

Here are some articles explaining how to do various things with triggers in SQL Server:

Create a DML Trigger in SQL Server
Create a “last modified” column
Automatically send an email when someone tries to delete a record
Update a column’s value whenever another column is updated
Update a column’s value whenever certain other columns are updated

SQL Transactions

SQL transactions are an important part of transactional databases, where data consistency is paramount.

A transaction manages a sequence of SQL statements that must be executed as a single unit of work. This is to ensure that the database never contains the results of partial operations.

When a transaction makes multiple changes to the database, either all the changes succeed when the transaction is committed, or all the changes are undone when the transaction is rolled back.

Transactions help maintain data integrity by ensuring that a sequence of SQL statements execute completely or not at all.

A classic example of a transaction is to move money from one bank account to another. You wouldn’t want money to be deducted from the first bank account, but not appear in the second bank account.

Therefore, you could use a transaction which goes along the lines of this:

START TRANSACTION
Debit account 1
Credit account 2
Record transaction in transaction journal
END TRANSACTION

You could write conditional logic inside that transaction that rolls back the transaction if anything goes wrong.

The end result is that, either the transaction is completed in its entirety, or it’s not completed at all. It’s never half-done.

See my SQL Transactions Tutorial for examples of SQL transactions.

SQL Functions

A function is a routine that can take parameters, perform calculations or other actions, and return a result.

Most DBMSs provide you with the ability to create your own functions, while also providing a range of inbuilt functions.

User-Defined Functions

A user-defined function (UDF) is a function that you create for a specific purpose, and save to the database. You would create such a function for tasks that aren’t catered for by an inbuilt function.

See Introduction to User-Defined Functions in SQL Server for an overview. Although that article is written for SQL Server, most of the general concepts also apply to other DBMSs.

Inbuilt Functions

Most DBMSs have a large range of inbuilt functions that you can use in your SQL queries. For example, there are functions that return the current date and time, functions that format dates and numbers, functions that convert data from one data type to another, and more.

The range of inbuilt functions can be pretty extensive, and depend on the DBMS in use, so I won’t go over them in this SQL tutorial. But I would encourage you to try to find out what inbuilt functions your DBMS supports.

To get you started, the following articles contain some of the most commonly used functions in SQL programming.

SQL Server

SQL Server String Functions
SQL Server Mathematical Functions
SQL Server Date &Time Functions

MySQL

MySQL String Functions
MySQL Mathematical Functions

PostgreSQL

PostgreSQL Date &Time Functions
PostgreSQL Math Functions

SQLite

SQLite Aggregate Functions
SQLite Date &Time Functions

Tutorial SQL untuk Pemula

Contoh SQL

Apa itu SQL?

Apa yang Dapat Saya Lakukan dengan SQL?

Standar SQL

Pengucapan SQL

Apa yang Saya Butuhkan untuk Tutorial SQL ini?

Buat Basis Data

Hubungkan ke Basis Data

Buat Tabel

NOT NULL Batasan

Kunci Utama

Buat Lebih Banyak Tabel

Hubungan

Periksa Batasan

Spasi Putih

Komentar

Komentar Sebaris

Komentar Multibaris

MySQL

Kode Komentar

Sisipkan Data

Periksa Data Kami

Pilih Kolom Tertentu

Penyortiran

Hitung Baris dalam Kumpulan Hasil

Kelompokkan Menurut

The HAVING Klausa

Bergabung

Alias

Memperbarui Data

Menghapus Data

Menjatuhkan Objek

SQL Operators

SQL Views

Views and the ORDER BY Clause

Stored Procedures

SQL Triggers

SQL Transactions

SQL Functions

User-Defined Functions

Inbuilt Functions

SQL Server

MySQL

PostgreSQL

SQLite

`NOT NULL` Batasan

The `HAVING` Klausa