PostgreSQL - Panduan Cepat

PostgreSQL adalah sistem database relasional objek open source yang kuat. Ini memiliki lebih dari 15 tahun fase pengembangan aktif dan arsitektur yang telah terbukti membuatnya mendapatkan reputasi yang kuat untuk keandalan, integritas data, dan kebenaran.

Tutorial ini akan memberi Anda awal yang cepat dengan PostgreSQL dan membuat Anda nyaman dengan pemrograman PostgreSQL.

Apa itu PostgreSQL?

PostgreSQL (diucapkan sebagai post-gress-Q-L) adalah sistem manajemen basis data relasional open source (DBMS) yang dikembangkan oleh tim sukarelawan di seluruh dunia. PostgreSQL tidak dikendalikan oleh perusahaan mana pun atau entitas swasta lainnya dan kode sumber tersedia secara gratis.

Sejarah Singkat PostgreSQL

PostgreSQL, awalnya bernama Postgres, dibuat di UCB oleh seorang profesor ilmu komputer bernama Michael Stonebraker. Stonebraker memulai Postgres pada tahun 1986 sebagai proyek tindak lanjut dari pendahulunya, Ingres, yang sekarang dimiliki oleh Computer Associates.

1977-1985 - Sebuah proyek bernama INGRES dikembangkan.
- Bukti konsep untuk database relasional
- Mendirikan perusahaan Ingres pada tahun 1980
- Dibeli oleh Computer Associates pada tahun 1994
1986-1994 - POSTGRES
- Pengembangan konsep di INGRES dengan fokus pada orientasi objek dan bahasa kueri - Quel
- Basis kode INGRES tidak digunakan sebagai dasar untuk POSTGRES
- Dikomersialkan sebagai Illustra (dibeli oleh Informix, dibeli oleh IBM)
1994-1995 - Postgres95
- Dukungan untuk SQL ditambahkan pada tahun 1994
- Dirilis sebagai Postgres95 pada tahun 1995
- Dirilis ulang sebagai PostgreSQL 6.0 pada tahun 1996
- Pembentukan Tim Pengembangan Global PostgreSQL

Fitur Utama PostgreSQL

PostgreSQL berjalan di semua sistem operasi utama, termasuk Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, Mac OS X, Solaris, Tru64), dan Windows. Ini mendukung teks, gambar, suara, dan video, dan termasuk antarmuka pemrograman untuk C / C ++, Java, Perl, Python, Ruby, Tcl dan Open Database Connectivity (ODBC).

PostgreSQL mendukung sebagian besar standar SQL dan menawarkan banyak fitur modern termasuk berikut ini -

Kueri SQL yang kompleks
SQL Sub-pilih
Kunci asing
Trigger
Views
Transactions
Kontrol konkurensi multiversi (MVCC)
Replikasi Streaming (mulai 9.0)
Siaga Panas (mulai 9.0)

Anda dapat memeriksa dokumentasi resmi PostgreSQL untuk memahami fitur-fitur yang disebutkan di atas. PostgreSQL dapat diperluas oleh pengguna dengan berbagai cara. Misalnya dengan menambahkan baru -

Tipe data
Functions
Operators
Fungsi agregat
Metode indeks

Dukungan Bahasa Prosedural

PostgreSQL mendukung empat bahasa prosedural standar, yang memungkinkan pengguna untuk menulis kode mereka sendiri dalam salah satu bahasa dan dapat dijalankan oleh server database PostgreSQL. Bahasa prosedural ini adalah - PL / pgSQL, PL / Tcl, PL / Perl dan PL / Python. Selain itu, bahasa prosedural non-standar lainnya seperti PL / PHP, PL / V8, PL / Ruby, PL / Java, dll, juga didukung.

Untuk mulai memahami dasar-dasar PostgreSQL, pertama mari kita instal PostgreSQL. Bab ini menjelaskan tentang menginstal PostgreSQL di platform Linux, Windows dan Mac OS.

Menginstal PostgreSQL di Linux / Unix

Ikuti langkah-langkah yang diberikan untuk menginstal PostgreSQL di mesin Linux Anda. Pastikan Anda masuk sebagairoot sebelum Anda melanjutkan untuk penginstalan.

Pilih nomor versi PostgreSQL yang Anda inginkan dan, sedapat mungkin, platform yang Anda inginkan dari EnterpriseDB
Saya mengunduh postgresql-9.2.4-1-linux-x64.rununtuk mesin 64 bit CentOS-6 saya. Sekarang, mari kita jalankan sebagai berikut -

[root@host]# chmod +x postgresql-9.2.4-1-linux-x64.run
[root@host]# ./postgresql-9.2.4-1-linux-x64.run
------------------------------------------------------------------------
Welcome to the PostgreSQL Setup Wizard.

------------------------------------------------------------------------
Please specify the directory where PostgreSQL will be installed.

Installation Directory [/opt/PostgreSQL/9.2]:

Setelah Anda meluncurkan penginstal, ia menanyakan beberapa pertanyaan dasar seperti lokasi penginstalan, kata sandi pengguna yang akan menggunakan database, nomor port, dll. Jadi simpan semuanya pada nilai defaultnya kecuali kata sandi, yang dapat Anda berikan kata sandi sesuai pilihan Anda. Ini akan menginstal PostgreSQL di mesin Linux Anda dan akan menampilkan pesan berikut -

Please wait while Setup installs PostgreSQL on your computer.

 Installing
 0% ______________ 50% ______________ 100%
 #########################################

-----------------------------------------------------------------------
Setup has finished installing PostgreSQL on your computer.

Ikuti langkah-langkah pasca instalasi berikut untuk membuat database Anda -

[root@host]# su - postgres
Password:
bash-4.1$ createdb testdb bash-4.1$ psql testdb
psql (8.4.13, server 9.2.4)

test=#

Anda dapat memulai / memulai ulang server postgres jika tidak berjalan menggunakan perintah berikut -

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Jika instalasi Anda benar, Anda akan melihat prompt PotsgreSQL test=# seperti gambar diatas.

Menginstal PostgreSQL di Windows

Ikuti langkah-langkah yang diberikan untuk menginstal PostgreSQL di mesin Windows Anda. Pastikan Anda telah mematikan Antivirus Pihak Ketiga saat menginstal.

Pilih nomor versi PostgreSQL yang Anda inginkan dan, sedapat mungkin, platform yang Anda inginkan dari EnterpriseDB
Saya mengunduh postgresql-9.2.4-1-windows.exe untuk PC Windows saya yang berjalan dalam mode 32bit, jadi mari kita jalankan postgresql-9.2.4-1-windows.exesebagai administrator untuk menginstal PostgreSQL. Pilih lokasi tempat Anda ingin menginstalnya. Secara default, ini diinstal dalam folder Program Files.

Langkah selanjutnya dari proses instalasi adalah memilih direktori tempat data Anda akan disimpan. Secara default, ini disimpan di bawah direktori "data".

Selanjutnya, pengaturan meminta kata sandi, sehingga Anda dapat menggunakan kata sandi favorit Anda.

Langkah selanjutnya; pertahankan port sebagai default.

Pada langkah berikutnya, ketika ditanya tentang "Lokal", saya memilih "Inggris, Amerika Serikat".
Butuh beberapa saat untuk menginstal PostgreSQL di sistem Anda. Setelah menyelesaikan proses instalasi, Anda akan mendapatkan layar berikut. Hapus centang pada kotak centang dan klik tombol Selesai.

Setelah proses instalasi selesai, Anda dapat mengakses shell pgAdmin III, StackBuilder dan PostgreSQL dari Menu Program Anda di bawah PostgreSQL 9.2.

Menginstal PostgreSQL di Mac

Ikuti langkah-langkah yang diberikan untuk menginstal PostgreSQL di mesin Mac Anda. Pastikan Anda masuk sebagaiadministrator sebelum Anda melanjutkan untuk penginstalan.

Pilih nomor versi terbaru PostgreSQL untuk Mac OS yang tersedia di EnterpriseDB
Saya mengunduh postgresql-9.2.4-1-osx.dmguntuk Mac OS saya yang menjalankan OS X versi 10.8.3. Sekarang, mari kita buka gambar dmg di finder dan cukup klik dua kali yang akan memberi Anda penginstal PostgreSQL di jendela berikut -

Selanjutnya, klik postgres-9.2.4-1-osxikon, yang akan memberikan pesan peringatan. Terima peringatan dan lanjutkan untuk instalasi lebih lanjut. Ini akan meminta kata sandi administrator seperti yang terlihat di jendela berikut -

Masukkan kata sandi, lanjutkan untuk penginstalan, dan setelah langkah ini, mulai ulang mesin Mac Anda. Jika Anda tidak melihat jendela berikut, mulai penginstalan Anda sekali lagi.

Setelah Anda meluncurkan penginstal, ia akan menanyakan beberapa pertanyaan dasar seperti lokasi instalasi, kata sandi pengguna yang akan menggunakan database, nomor port, dll. Oleh karena itu, simpan semuanya pada nilai defaultnya kecuali kata sandi, yang dapat Anda berikan sesuai pilihan Anda. Ini akan menginstal PostgreSQL di mesin Mac Anda di folder Aplikasi yang dapat Anda periksa -

Sekarang, Anda dapat meluncurkan program apa pun untuk memulai. Mari kita mulai dengan SQL Shell. Saat Anda meluncurkan SQL Shell, cukup gunakan semua nilai default yang ditampilkan kecuali, masukkan kata sandi Anda, yang telah Anda pilih pada saat instalasi. Jika semuanya berjalan dengan baik, maka Anda akan berada di dalam database postgres dan filepostgress# prompt akan ditampilkan seperti yang ditunjukkan di bawah ini -

Selamat!!! Sekarang Anda memiliki lingkungan yang siap untuk memulai dengan pemrograman database PostgreSQL.

Bab ini menyediakan daftar perintah SQL PostgreSQL, diikuti dengan aturan sintaks yang tepat untuk setiap perintah ini. Kumpulan perintah ini diambil dari alat baris perintah psql. Sekarang Anda telah menginstal Postgres, buka psql sebagai -

Program Files → PostgreSQL 9.2 → SQL Shell(psql).

Menggunakan psql, Anda dapat membuat daftar lengkap perintah dengan menggunakan perintah \ help. Untuk sintaks dari perintah tertentu, gunakan perintah berikut -

postgres-# \help <command_name>

Pernyataan SQL

Pernyataan SQL terdiri dari token di mana setiap token dapat mewakili kata kunci, pengidentifikasi, pengenal kutipan, konstanta, atau simbol karakter khusus. Tabel yang diberikan di bawah ini menggunakan pernyataan SELECT sederhana untuk mengilustrasikan pernyataan SQL dasar namun lengkap dan komponennya.

	PILIH	id, nama	DARI	negara bagian
Jenis Token	Kata kunci	Pengenal	Kata kunci	Pengenal
Deskripsi	Perintah	Kolom id dan nama	Ayat	Nama tabel

Perintah SQL PostgreSQL

MENGGUGURKAN

Batalkan transaksi saat ini.

ABORT [ WORK | TRANSACTION ]

ALTER AGREGATE

Ubah definisi fungsi agregat.

ALTER AGGREGATE name ( type ) RENAME TO new_name
ALTER AGGREGATE name ( type ) OWNER TO new_owner

ALTER KONVERSI

Ubah definisi konversi.

ALTER CONVERSION name RENAME TO new_name
ALTER CONVERSION name OWNER TO new_owner

ALTER DATABASE

Ubah parameter khusus database.

ALTER DATABASE name SET parameter { TO | = } { value | DEFAULT }
ALTER DATABASE name RESET parameter
ALTER DATABASE name RENAME TO new_name
ALTER DATABASE name OWNER TO new_owner

ALTER DOMAIN

Ubah definisi parameter khusus domain.

ALTER DOMAIN name { SET DEFAULT expression | DROP DEFAULT }
ALTER DOMAIN name { SET | DROP } NOT NULL
ALTER DOMAIN name ADD domain_constraint
ALTER DOMAIN name DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
ALTER DOMAIN name OWNER TO new_owner

ALTER FUNGSI

Ubah definisi suatu fungsi.

ALTER FUNCTION name ( [ type [, ...] ] ) RENAME TO new_name
ALTER FUNCTION name ( [ type [, ...] ] ) OWNER TO new_owner

ALTER GROUP

Ubah grup pengguna.

ALTER GROUP groupname ADD USER username [, ... ]
ALTER GROUP groupname DROP USER username [, ... ]
ALTER GROUP groupname RENAME TO new_name

ALTER INDEX

Ubah definisi indeks.

ALTER INDEX name OWNER TO new_owner
ALTER INDEX name SET TABLESPACE indexspace_name
ALTER INDEX name RENAME TO new_name

ALTER BAHASA

Ubah definisi bahasa prosedural.

ALTER LANGUAGE name RENAME TO new_name

ALTER OPERATOR

Ubah definisi operator.

ALTER OPERATOR name ( { lefttype | NONE }, { righttype | NONE } )
OWNER TO new_owner

ALTER KELAS OPERATOR

Ubah definisi kelas operator.

ALTER OPERATOR CLASS name USING index_method RENAME TO new_name
ALTER OPERATOR CLASS name USING index_method OWNER TO new_owner

ALTER SKEMA

Ubah definisi skema.

ALTER SCHEMA name RENAME TO new_name
ALTER SCHEMA name OWNER TO new_owner

ALTER URUTAN

Ubah definisi generator urutan.

ALTER SEQUENCE name [ INCREMENT [ BY ] increment ]
[ MINVALUE minvalue | NO MINVALUE ]
[ MAXVALUE maxvalue | NO MAXVALUE ]
[ RESTART [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

ALTER TABLE

Ubah definisi tabel.

ALTER TABLE [ ONLY ] name [ * ]
action [, ... ]
ALTER TABLE [ ONLY ] name [ * ]
RENAME [ COLUMN ] column TO new_column
ALTER TABLE name
RENAME TO new_name

Di mana tindakan adalah salah satu dari baris berikut -

ADD [ COLUMN ] column_type [ column_constraint [ ... ] ]
DROP [ COLUMN ] column [ RESTRICT | CASCADE ]
ALTER [ COLUMN ] column TYPE type [ USING expression ]
ALTER [ COLUMN ] column SET DEFAULT expression
ALTER [ COLUMN ] column DROP DEFAULT
ALTER [ COLUMN ] column { SET | DROP } NOT NULL
ALTER [ COLUMN ] column SET STATISTICS integer
ALTER [ COLUMN ] column SET STORAGE { PLAIN | EXTERNAL | EXTENDED | MAIN }
ADD table_constraint
DROP CONSTRAINT constraint_name [ RESTRICT | CASCADE ]
CLUSTER ON index_name
SET WITHOUT CLUSTER
SET WITHOUT OIDS
OWNER TO new_owner
SET TABLESPACE tablespace_name

ALTER TABLESPACE

Ubah definisi tablespace.

ALTER TABLESPACE name RENAME TO new_name
ALTER TABLESPACE name OWNER TO new_owner

ALTER TRIGGER

Ubah definisi pemicu.

ALTER TRIGGER name ON table RENAME TO new_name

ALTER TYPE

Ubah definisi suatu tipe.

ALTER TYPE name OWNER TO new_owner

ALTER PENGGUNA

Ubah akun pengguna database.

ALTER USER name [ [ WITH ] option [ ... ] ]
ALTER USER name RENAME TO new_name
ALTER USER name SET parameter { TO | = } { value | DEFAULT }
ALTER USER name RESET parameter

Di mana opsi bisa -

[ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
| CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| VALID UNTIL 'abstime'

MENGANALISA

Kumpulkan statistik tentang database.

ANALYZE [ VERBOSE ] [ table [ (column [, ...] ) ] ]

MULAI

Mulai blok transaksi.

BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]

Di mana transaction_mode adalah salah satu dari -

ISOLATION LEVEL { 
   SERIALIZABLE | REPEATABLE READ | READ COMMITTED
   | READ UNCOMMITTED
}
READ WRITE | READ ONLY

POS PEMERIKSAAN

Paksa pos pemeriksaan log transaksi.

CHECKPOINT

MENUTUP

Tutup kursor.

CLOSE name

GUGUS

Kelompokkan tabel menurut indeks.

CLUSTER index_name ON table_name
CLUSTER table_name
CLUSTER

KOMENTAR

Tentukan atau ubah komentar suatu objek.

COMMENT ON {
   TABLE object_name |
   COLUMN table_name.column_name |
   AGGREGATE agg_name (agg_type) |
   CAST (source_type AS target_type) |
   CONSTRAINT constraint_name ON table_name |
   CONVERSION object_name |
   DATABASE object_name |
   DOMAIN object_name |
   FUNCTION func_name (arg1_type, arg2_type, ...) |
   INDEX object_name |
   LARGE OBJECT large_object_oid |
   OPERATOR op (left_operand_type, right_operand_type) |
   OPERATOR CLASS object_name USING index_method |
   [ PROCEDURAL ] LANGUAGE object_name |
   RULE rule_name ON table_name |
   SCHEMA object_name |
   SEQUENCE object_name |
   TRIGGER trigger_name ON table_name |
   TYPE object_name |
   VIEW object_name
} 
IS 'text'

MELAKUKAN

Lakukan transaksi saat ini.

COMMIT [ WORK | TRANSACTION ]

SALINAN

Salin data antara file dan tabel.

COPY table_name [ ( column [, ...] ) ]
FROM { 'filename' | STDIN }
[ WITH ]
[ BINARY ]
[ OIDS ]
[ DELIMITER [ AS ] 'delimiter' ]
[ NULL [ AS ] 'null string' ]
[ CSV [ QUOTE [ AS ] 'quote' ]
[ ESCAPE [ AS ] 'escape' ]
[ FORCE NOT NULL column [, ...] ]
COPY table_name [ ( column [, ...] ) ]
TO { 'filename' | STDOUT }
[ [ WITH ]
[ BINARY ]
[ OIDS ]
[ DELIMITER [ AS ] 'delimiter' ]
[ NULL [ AS ] 'null string' ]
[ CSV [ QUOTE [ AS ] 'quote' ]
[ ESCAPE [ AS ] 'escape' ]
[ FORCE QUOTE column [, ...] ]

BUAT AGREGAT

Tentukan fungsi agregat baru.

CREATE AGGREGATE name (
   BASETYPE = input_data_type,
   SFUNC = sfunc,
   STYPE = state_data_type
   [, FINALFUNC = ffunc ]
   [, INITCOND = initial_condition ]
)

BUAT CAST

Tentukan pemeran baru.

CREATE CAST (source_type AS target_type)
WITH FUNCTION func_name (arg_types)
[ AS ASSIGNMENT | AS IMPLICIT ]
CREATE CAST (source_type AS target_type)
WITHOUT FUNCTION
[ AS ASSIGNMENT | AS IMPLICIT ]

BUAT PEMICU BATASAN

Tentukan pemicu batasan baru.

CREATE CONSTRAINT TRIGGER name
AFTER events ON
table_name constraint attributes
FOR EACH ROW EXECUTE PROCEDURE func_name ( args )

BUAT KONVERSI

Tentukan konversi baru.

CREATE [DEFAULT] CONVERSION name
FOR source_encoding TO dest_encoding FROM func_name

BUAT DATABASE

Buat database baru.

CREATE DATABASE name
[ [ WITH ] [ OWNER [=] db_owner ]
   [ TEMPLATE [=] template ]
   [ ENCODING [=] encoding ]
   [ TABLESPACE [=] tablespace ] 
]

BUAT DOMAIN

Tentukan domain baru.

CREATE DOMAIN name [AS] data_type
[ DEFAULT expression ]
[ constraint [ ... ] ]

Di mana kendala adalah -

[ CONSTRAINT constraint_name ]
{ NOT NULL | NULL | CHECK (expression) }

BUAT FUNGSI

Tentukan fungsi baru.

CREATE [ OR REPLACE ] FUNCTION name ( [ [ arg_name ] arg_type [, ...] ] )
RETURNS ret_type
{ LANGUAGE lang_name
   | IMMUTABLE | STABLE | VOLATILE
   | CALLED ON NULL INPUT | RETURNS NULL ON NULL INPUT | STRICT
   | [ EXTERNAL ] SECURITY INVOKER | [ EXTERNAL ] SECURITY DEFINER
   | AS 'definition'
   | AS 'obj_file', 'link_symbol'
} ...
[ WITH ( attribute [, ...] ) ]

MEMBUAT GRUP

Tentukan grup pengguna baru.

CREATE GROUP name [ [ WITH ] option [ ... ] ]
Where option can be:
SYSID gid
| USER username [, ...]

BUAT INDEKS

Tentukan indeks baru.

CREATE [ UNIQUE ] INDEX name ON table [ USING method ]
( { column | ( expression ) } [ opclass ] [, ...] )
[ TABLESPACE tablespace ]
[ WHERE predicate ]

BUAT BAHASA

Tentukan bahasa prosedural baru.

CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
HANDLER call_handler [ VALIDATOR val_function ]

BUAT OPERATOR

Tentukan operator baru.

CREATE OPERATOR name (
   PROCEDURE = func_name
   [, LEFTARG = left_type ] [, RIGHTARG = right_type ]
   [, COMMUTATOR = com_op ] [, NEGATOR = neg_op ]
   [, RESTRICT = res_proc ] [, JOIN = join_proc ]
   [, HASHES ] [, MERGES ]
   [, SORT1 = left_sort_op ] [, SORT2 = right_sort_op ]
   [, LTCMP = less_than_op ] [, GTCMP = greater_than_op ]
)

BUAT KELAS OPERATOR

Tentukan kelas operator baru.

CREATE OPERATOR CLASS name [ DEFAULT ] FOR TYPE data_type
USING index_method AS
{ OPERATOR strategy_number operator_name [ ( op_type, op_type ) ] [ RECHECK ]
   | FUNCTION support_number func_name ( argument_type [, ...] )
   | STORAGE storage_type
} [, ... ]

BUAT ATURAN

Tentukan aturan penulisan ulang baru.

CREATE [ OR REPLACE ] RULE name AS ON event
TO table [ WHERE condition ]
DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }

BUAT SKEMA

Tentukan skema baru.

CREATE SCHEMA schema_name
[ AUTHORIZATION username ] [ schema_element [ ... ] ]
CREATE SCHEMA AUTHORIZATION username
[ schema_element [ ... ] ]

BUAT URUTAN

Tentukan generator urutan baru.

CREATE [ TEMPORARY | TEMP ] SEQUENCE name
[ INCREMENT [ BY ] increment ]
[ MINVALUE minvalue | NO MINVALUE ]
[ MAXVALUE maxvalue | NO MAXVALUE ]
[ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]

BUAT TABEL

Tentukan tabel baru.

CREATE [ [ GLOBAL | LOCAL ] { 
   TEMPORARY | TEMP } ] TABLE table_name ( { 
      column_name data_type [ DEFAULT default_expr ] [ column_constraint [ ... ] ]
      | table_constraint
      | LIKE parent_table [ { INCLUDING | EXCLUDING } DEFAULTS ] 
   } [, ... ]
)
[ INHERITS ( parent_table [, ... ] ) ]
[ WITH OIDS | WITHOUT OIDS ]
[ ON COMMIT { PRESERVE ROWS | DELETE ROWS | DROP } ]
[ TABLESPACE tablespace ]

Di mana batasan_kolom adalah -

[ CONSTRAINT constraint_name ] { 
   NOT NULL |
   NULL |
   UNIQUE [ USING INDEX TABLESPACE tablespace ] |
   PRIMARY KEY [ USING INDEX TABLESPACE tablespace ] |
   CHECK (expression) |
   REFERENCES ref_table [ ( ref_column ) ]
   [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
   [ ON DELETE action ] [ ON UPDATE action ] 
}
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

Dan table_constraint adalah -

[ CONSTRAINT constraint_name ]
{ UNIQUE ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
PRIMARY KEY ( column_name [, ... ] ) [ USING INDEX TABLESPACE tablespace ] |
CHECK ( expression ) |
FOREIGN KEY ( column_name [, ... ] )
REFERENCES ref_table [ ( ref_column [, ... ] ) ]
[ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ]
[ ON DELETE action ] [ ON UPDATE action ] }
[ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ]

BUAT TABEL SEBAGAI

Tentukan tabel baru dari hasil kueri.

CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name
[ (column_name [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ]
AS query

BUAT TABLESPACE

Tentukan tablespace baru.

CREATE TABLESPACE tablespace_name [ OWNER username ] LOCATION 'directory'

BUAT PEMICU

Tentukan pemicu baru.

CREATE TRIGGER name { BEFORE | AFTER } { event [ OR ... ] }
ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
EXECUTE PROCEDURE func_name ( arguments )

BUAT JENIS

Tentukan tipe data baru.

CREATE TYPE name AS
( attribute_name data_type [, ... ] )
CREATE TYPE name (
INPUT = input_function,
OUTPUT = output_function
[, RECEIVE = receive_function ]
[, SEND = send_function ]
[, ANALYZE = analyze_function ]
[, INTERNALLENGTH = { internal_length | VARIABLE } ]
[, PASSEDBYVALUE ]
[, ALIGNMENT = alignment ]
[, STORAGE = storage ]
[, DEFAULT = default ]
[, ELEMENT = element ]
[, DELIMITER = delimiter ]
)

BUAT PENGGUNA

Tentukan akun pengguna database baru.

CREATE USER name [ [ WITH ] option [ ... ] ]

Di mana opsi bisa -

SYSID uid
| [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
| CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| IN GROUP group_name [, ...]
| VALID UNTIL 'abs_time'

BUAT TAMPILAN

Tentukan tampilan baru.

CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ] AS query

DEALLOCATE

Batalkan alokasi pernyataan yang sudah disiapkan.

DEALLOCATE [ PREPARE ] plan_name

MENYATAKAN

Tentukan kursor.

DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
[ FOR { READ ONLY | UPDATE [ OF column [, ...] ] } ]

MENGHAPUS

Hapus baris tabel.

DELETE FROM [ ONLY ] table [ WHERE condition ]

DROP AGREGATE

Hapus fungsi agregat.

DROP AGGREGATE name ( type ) [ CASCADE | RESTRICT ]

TETAPKAN CAST

Hapus pemeran.

DROP CAST (source_type AS target_type) [ CASCADE | RESTRICT ]

JATUHKAN KONVERSI

Hapus konversi.

DROP CONVERSION name [ CASCADE | RESTRICT ]

DROP DATABASE

Hapus database.

DROP DATABASE name

TETAPKAN DOMAIN

Hapus domain.

DROP DOMAIN name [, ...] [ CASCADE | RESTRICT ]

FUNGSI JATUH

Hapus fungsi.

DROP FUNCTION name ( [ type [, ...] ] ) [ CASCADE | RESTRICT ]

DROP GROUP

Hapus grup pengguna.

DROP GROUP name

JATUHKAN INDEKS

Hapus indeks.

DROP INDEX name [, ...] [ CASCADE | RESTRICT ]

LEPAS BAHASA

Hapus bahasa prosedural.

DROP [ PROCEDURAL ] LANGUAGE name [ CASCADE | RESTRICT ]

DROP OPERATOR

Hapus operator.

DROP OPERATOR name ( { left_type | NONE }, { right_type | NONE } )
[ CASCADE | RESTRICT ]

TETAPKAN KELAS OPERATOR

Hapus kelas operator.

DROP OPERATOR CLASS name USING index_method [ CASCADE | RESTRICT ]

TETAPKAN ATURAN

Hapus aturan penulisan ulang.

DROP RULE name ON relation [ CASCADE | RESTRICT ]

JATUH SKEMA

Hapus skema.

DROP SCHEMA name [, ...] [ CASCADE | RESTRICT ]

Jatuhkan URUTAN

Hapus urutan.

DROP SEQUENCE name [, ...] [ CASCADE | RESTRICT ]

DROP TABLE

Hapus tabel.

DROP TABLE name [, ...] [ CASCADE | RESTRICT ]

DROP TABLESPACE

Hapus tablespace.

DROP TABLESPACE tablespace_name

LETAK PEMICU

Hapus pemicu.

DROP TRIGGER name ON table [ CASCADE | RESTRICT ]

JENIS DROP

Hapus tipe data.

DROP TYPE name [, ...] [ CASCADE | RESTRICT ]

LEPASKAN PENGGUNA

Hapus akun pengguna database.

DROP USER name

DROP LIHAT

Hapus tampilan.

DROP VIEW name [, ...] [ CASCADE | RESTRICT ]

AKHIR

Lakukan transaksi saat ini.

END [ WORK | TRANSACTION ]

MENJALANKAN

Jalankan pernyataan yang sudah disiapkan.

EXECUTE plan_name [ (parameter [, ...] ) ]

MENJELASKAN

Tunjukkan rencana eksekusi sebuah pernyataan.

EXPLAIN [ ANALYZE ] [ VERBOSE ] statement

MENGAMBIL

Ambil baris dari kueri menggunakan kursor.

FETCH [ direction { FROM | IN } ] cursor_name

Dimana arah bisa kosong atau salah satu dari -

NEXT
PRIOR
FIRST
LAST
ABSOLUTE count
RELATIVE count
count
ALL
FORWARD
FORWARD count
FORWARD ALL
BACKWARD
BACKWARD count
BACKWARD ALL

HIBAH

Tentukan hak akses.

GRANT { { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] table_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE db_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { CREATE | ALL [ PRIVILEGES ] }
ON TABLESPACE tablespace_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION func_name ([type, ...]) [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { USAGE | ALL [ PRIVILEGES ] }
ON LANGUAGE lang_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

GRANT { { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
ON SCHEMA schema_name [, ...]
TO { username | GROUP group_name | PUBLIC } [, ...] [ WITH GRANT OPTION ]

MEMASUKKAN

Buat baris baru di tabel.

INSERT INTO table [ ( column [, ...] ) ]
{ DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) | query }

MENDENGARKAN

Dengarkan notifikasi.

LISTEN name

BEBAN

Muat atau muat ulang file perpustakaan bersama.

LOAD 'filename'

MENGUNCI

Kunci meja.

LOCK [ TABLE ] name [, ...] [ IN lock_mode MODE ] [ NOWAIT ]

Di mana lock_mode adalah salah satu dari -

ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
| SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE

PINDAH

Posisikan kursor.

MOVE [ direction { FROM | IN } ] cursor_name

MEMBERITAHU

Buat pemberitahuan.

NOTIFY name

MEMPERSIAPKAN

Siapkan pernyataan untuk dieksekusi.

PREPARE plan_name [ (data_type [, ...] ) ] AS statement

REINDEX

Buat ulang indeks.

REINDEX { DATABASE | TABLE | INDEX } name [ FORCE ]

RELEASE SAVEPOINT

Hancurkan titik penyimpanan yang ditentukan sebelumnya.

RELEASE [ SAVEPOINT ] savepoint_name

SETEL ULANG

Kembalikan nilai parameter runtime ke nilai default.

RESET name
RESET ALL

MENCABUT

Hapus hak akses.

REVOKE [ GRANT OPTION FOR ]
{ { SELECT | INSERT | UPDATE | DELETE | RULE | REFERENCES | TRIGGER }
[,...] | ALL [ PRIVILEGES ] }
ON [ TABLE ] table_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ { CREATE | TEMPORARY | TEMP } [,...] | ALL [ PRIVILEGES ] }
ON DATABASE db_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ CREATE | ALL [ PRIVILEGES ] }
ON TABLESPACE tablespace_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ EXECUTE | ALL [ PRIVILEGES ] }
ON FUNCTION func_name ([type, ...]) [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ USAGE | ALL [ PRIVILEGES ] }
ON LANGUAGE lang_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

REVOKE [ GRANT OPTION FOR ]
{ { CREATE | USAGE } [,...] | ALL [ PRIVILEGES ] }
ON SCHEMA schema_name [, ...]
FROM { username | GROUP group_name | PUBLIC } [, ...]
[ CASCADE | RESTRICT ]

ROLLBACK

Batalkan transaksi saat ini.

ROLLBACK [ WORK | TRANSACTION ]

ROLLBACK KE SAVEPOINT

Kembalikan ke savepoint.

ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_name

SAVEPOINT

Tentukan savepoint baru dalam transaksi saat ini.

SAVEPOINT savepoint_name

PILIH

Ambil baris dari tabel atau tampilan.

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ AS output_name ] [, ...]
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
[ FOR UPDATE [ OF table_name [, ...] ] ]

from_item

[ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
function_name ( [ argument [, ...] ] )
[ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ]
function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
from_item [ NATURAL ] join_type from_item
[ ON join_condition | USING ( join_column [, ...] ) ]

PILIH KE

Tentukan tabel baru dari hasil kueri.

SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ]
* | expression [ AS output_name ] [, ...]
INTO [ TEMPORARY | TEMP ] [ TABLE ] new_table
[ FROM from_item [, ...] ]
[ WHERE condition ]
[ GROUP BY expression [, ...] ]
[ HAVING condition [, ...] ]
[ { UNION | INTERSECT | EXCEPT } [ ALL ] select ]
[ ORDER BY expression [ ASC | DESC | USING operator ] [, ...] ]
[ LIMIT { count | ALL } ]
[ OFFSET start ]
[ FOR UPDATE [ OF table_name [, ...] ] ]

SET

Ubah parameter runtime.

SET [ SESSION | LOCAL ] name { TO | = } { value | 'value' | DEFAULT }
SET [ SESSION | LOCAL ] TIME ZONE { time_zone | LOCAL | DEFAULT }

ATUR BATAS

Tetapkan mode pemeriksaan kendala untuk transaksi saat ini.

SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }

SETEL OTORISASI SESI

Tetapkan pengidentifikasi pengguna sesi dan pengidentifikasi pengguna saat ini dari sesi saat ini.

SET [ SESSION | LOCAL ] SESSION AUTHORIZATION username
SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
RESET SESSION AUTHORIZATION

ATUR TRANSAKSI

Tetapkan karakteristik transaksi saat ini.

SET TRANSACTION transaction_mode [, ...]
SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]

Di mana transaction_mode adalah salah satu dari -

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED }
READ WRITE | READ ONLY

MENUNJUKKAN

Tunjukkan nilai parameter runtime.

SHOW name
SHOW ALL

MULAI TRANSAKSI

Mulai blok transaksi.

START TRANSACTION [ transaction_mode [, ...] ]

Di mana transaction_mode adalah salah satu dari -

ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED }
READ WRITE | READ ONLY

MEMOTONG

Kosongkan meja.

TRUNCATE [ TABLE ] name

TIDAK MENDENGARKAN

Berhenti mendengarkan pemberitahuan.

UNLISTEN { name | * }

MEMPERBARUI

Perbarui baris tabel.

UPDATE [ ONLY ] table SET column = { expression | DEFAULT } [, ...]
[ FROM from_list ]
[ WHERE condition ]

KEKOSONGAN

Kumpulkan sampah dan analisis database secara opsional.

VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]

Pada bab ini, kita akan membahas tentang tipe data yang digunakan di PostgreSQL. Saat membuat tabel, untuk setiap kolom, Anda menentukan tipe data, misalnya, jenis data apa yang ingin Anda simpan di bidang tabel.

Ini memungkinkan beberapa manfaat -

Consistency - Operasi terhadap kolom dengan tipe data yang sama memberikan hasil yang konsisten dan biasanya tercepat.
Validation - Penggunaan tipe data yang tepat menyiratkan validasi format data dan penolakan data di luar cakupan tipe data.
Compactness - Karena kolom dapat menyimpan satu jenis nilai, ia disimpan dengan cara yang ringkas.
Performance- Penggunaan tipe data yang tepat memberikan penyimpanan data yang paling efisien. Nilai yang disimpan dapat diproses dengan cepat, yang meningkatkan kinerja.

PostgreSQL mendukung berbagai Jenis Data. Selain itu, pengguna dapat membuat tipe data khusus mereka sendiri menggunakan perintah CREATE TYPE SQL. Ada berbagai kategori tipe data di PostgreSQL. Mereka dibahas di bawah ini.

Jenis Numerik

Jenis numerik terdiri dari bilangan bulat dua-byte, empat-byte, dan delapan-byte, bilangan floating-point empat-byte dan delapan-byte, dan desimal presisi yang dapat dipilih. Tabel berikut mencantumkan tipe yang tersedia.

Nama	Ukuran Penyimpanan	Deskripsi	Jarak
smallint	2 byte	integer jarak kecil	-32768 hingga +32767
bilangan bulat	4 byte	pilihan khas untuk integer	-2147483648 hingga +2147483647
bigint	8 byte	integer jarak besar	-9223372036854775808 hingga 9223372036854775807
desimal	variabel	presisi yang ditentukan pengguna, tepat	hingga 131072 digit sebelum koma desimal; hingga 16383 digit setelah koma desimal
numerik	variabel	presisi yang ditentukan pengguna, tepat	hingga 131072 digit sebelum koma desimal; hingga 16383 digit setelah koma desimal
nyata	4 byte	variabel-presisi, tidak tepat	Ketepatan 6 digit desimal
presisi ganda	8 byte	variabel-presisi, tidak tepat	Presisi 15 digit desimal
smallserial	2 byte	integer autoincrementing kecil	1 hingga 32767
serial	4 byte	integer autoincrementing	1 hingga 2147483647
bigserial	8 byte	bilangan bulat autoincrementing besar	1 hingga 9223372036854775807

Jenis Moneter

The uang tipe menyimpan sejumlah mata uang dengan presisi pecahan tetap. Nilai tipe data numerik, int, dan bigint dapat diubah menjadi uang . Menggunakan angka floating point tidak disarankan untuk menangani uang karena potensi kesalahan pembulatan.

Nama	Ukuran Penyimpanan	Deskripsi	Jarak
uang	8 byte	jumlah mata uang	-92233720368547758.08 hingga +92233720368547758.07

Jenis Karakter

Tabel yang diberikan di bawah ini mencantumkan tipe karakter tujuan umum yang tersedia di PostgreSQL.

No. S.	Nama & Deskripsi
1	character varying(n), varchar(n) variabel-panjang dengan batas
2	character(n), char(n) panjang tetap, empuk kosong
3	text variabel panjang tak terbatas

Tipe Data Biner

The bytea tipe data memungkinkan penyimpanan string biner seperti pada tabel di bawah ini.

Nama	Ukuran Penyimpanan	Deskripsi
bytea	1 atau 4 byte ditambah string biner aktual	string biner panjang variabel

Jenis Tanggal / Waktu

PostgreSQL mendukung set lengkap jenis tanggal dan waktu SQL, seperti yang ditunjukkan pada tabel di bawah ini. Tanggal dihitung menurut kalender Gregorian. Di sini, semua tipe memiliki resolusi1 microsecond / 14 digits kecuali date jenis, yang resolusinya day.

Nama	Ukuran Penyimpanan	Deskripsi	Nilai rendah	Bernilai tinggi
stempel waktu [(p)] [tanpa zona waktu]	8 byte	baik tanggal dan waktu (tanpa zona waktu)	4713 SM	294276 M.
TIMESTAMPTZ	8 byte	baik tanggal dan waktu, dengan zona waktu	4713 SM	294276 M.
tanggal	4 byte	tanggal (tidak ada waktu dalam sehari)	4713 SM	5874897 M.
waktu [(p)] [tanpa zona waktu]	8 byte	waktu hari (tanpa tanggal)	00:00:00	24:00:00
waktu [(p)] dengan zona waktu	12 byte	waktu dalam sehari saja, dengan zona waktu	00: 00: 00 + 1459	24: 00: 00-1459
interval [bidang] [(p)]	12 byte	jarak waktu	-178000000 tahun	178000000 tahun

Jenis Boolean

PostgreSQL menyediakan Boolean tipe SQL standar. Tipe data Boolean dapat memiliki status true , false , dan status ketiga, tidak diketahui , yang diwakili oleh nilai SQL null.

Nama	Ukuran Penyimpanan	Deskripsi
boolean	1 byte	keadaan benar atau salah

Jenis yang Dicacah

Tipe enumerasi (enum) adalah tipe data yang terdiri dari kumpulan nilai statis yang diurutkan. Mereka setara dengan jenis enum yang didukung dalam sejumlah bahasa pemrograman.

Tidak seperti tipe lainnya, Enumerated Type perlu dibuat menggunakan perintah CREATE TYPE. Jenis ini digunakan untuk menyimpan sekumpulan nilai yang statis dan teratur. Misalnya arah kompas, yaitu UTARA, SELATAN, TIMUR, dan BARAT atau hari dalam seminggu seperti gambar di bawah ini -

CREATE TYPE week AS ENUM ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');

Enumerated, setelah dibuat, dapat digunakan seperti tipe lainnya.

Tipe Geometris

Tipe data geometris merepresentasikan objek spasial dua dimensi. Jenis yang paling mendasar, titik, membentuk dasar untuk semua jenis lainnya.

Nama	Ukuran Penyimpanan	Perwakilan	Deskripsi
titik	16 byte	Arahkan ke pesawat	(x, y)
garis	32 byte	Garis tak terbatas (tidak diterapkan sepenuhnya)	((x1, y1), (x2, y2))
lseg	32 byte	Segmen garis hingga	((x1, y1), (x2, y2))
kotak	32 byte	Kotak persegi panjang	((x1, y1), (x2, y2))
jalan	16 + 16n byte	Jalur tertutup (mirip dengan poligon)	((x1, y1), ...)
jalan	16 + 16n byte	Jalan terbuka	[(x1, y1), ...]
poligon	40 + 16n	Poligon (mirip dengan jalur tertutup)	((x1, y1), ...)
lingkaran	24 byte	Lingkaran	<(x, y), r> (titik pusat dan radius)

Jenis Alamat Jaringan

PostgreSQL menawarkan tipe data untuk menyimpan alamat IPv4, IPv6, dan MAC. Lebih baik menggunakan jenis ini daripada jenis teks biasa untuk menyimpan alamat jaringan, karena jenis ini menawarkan pemeriksaan kesalahan masukan serta operator dan fungsi khusus.

Nama	Ukuran Penyimpanan	Deskripsi
cidr	7 atau 19 byte	Jaringan IPv4 dan IPv6
inet	7 atau 19 byte	Host dan jaringan IPv4 dan IPv6
macaddr	6 byte	Alamat MAC

Jenis String Bit

Jenis String Bit digunakan untuk menyimpan bit mask. Mereka bisa 0 atau 1. Ada dua jenis bit SQL:bit(n) dan bit varying(n), di mana n adalah bilangan bulat positif.

Jenis Pencarian Teks

Jenis ini mendukung pencarian teks lengkap, yang merupakan aktivitas mencari melalui kumpulan dokumen bahasa alami untuk menemukan dokumen yang paling cocok dengan kueri. Ada dua Jenis Data untuk ini -

No. S.	Nama & Deskripsi
1	tsvector Ini adalah daftar diurutkan dari kata-kata berbeda yang telah dinormalisasi untuk menggabungkan varian berbeda dari kata yang sama, yang disebut sebagai "lexemes".
2	tsquery Ini menyimpan leksem yang akan dicari, dan menggabungkannya dengan menghormati operator Boolean & (AND), \| (Atau dan ! (TIDAK). Tanda kurung dapat digunakan untuk memberlakukan pengelompokan operator.

Jenis UUID

UUID (Pengenal Unik Universal) ditulis sebagai urutan digit heksadesimal huruf kecil, dalam beberapa kelompok yang dipisahkan oleh tanda hubung, khususnya kelompok delapan digit, diikuti oleh tiga kelompok empat digit, diikuti oleh kelompok 12 digit, untuk total 32 digit mewakili 128 bit.

Contoh UUID adalah - 550e8400-e29b-41d4-a716-446655440000

Jenis XML

Tipe data XML bisa digunakan untuk menyimpan data XML. Untuk menyimpan data XML, pertama-tama Anda harus membuat nilai XML menggunakan fungsi xmlparse sebagai berikut -

XMLPARSE (DOCUMENT '<?xml version="1.0"?>
<tutorial>
<title>PostgreSQL Tutorial </title>
   <topics>...</topics>
</tutorial>')

XMLPARSE (CONTENT 'xyz<foo>bar</foo><bar>foo</bar>')

Jenis JSON

The json tipe data dapat digunakan untuk menyimpan JSON (JavaScript Object Notation) data. Data semacam itu juga dapat disimpan sebagai teks , tetapi tipe data json memiliki keunggulan karena memeriksa bahwa setiap nilai yang disimpan adalah nilai JSON yang valid. Ada juga fungsi dukungan terkait yang tersedia, yang dapat digunakan secara langsung untuk menangani tipe data JSON sebagai berikut.

Contoh	Contoh Hasil
larik_to_json ('{{1,5}, {99,100}}' :: int [])	[[1,5], [99.100]]
row_to_json (baris (1, 'foo'))	{"f1": 1, "f2": "foo"}

Jenis Array

PostgreSQL memberikan kesempatan untuk mendefinisikan kolom tabel sebagai array multidimensi panjang variabel. Array dari tipe dasar bawaan atau yang ditentukan pengguna, tipe enum, atau tipe komposit dapat dibuat.

Deklarasi Array

Jenis array dapat dideklarasikan sebagai

CREATE TABLE monthly_savings (
   name text,
   saving_per_quarter integer[],
   scheme text[][]
);

atau dengan menggunakan kata kunci "ARRAY" sebagai

CREATE TABLE monthly_savings (
   name text,
   saving_per_quarter integer ARRAY[4],
   scheme text[][]
);

Memasukkan nilai

Nilai array dapat disisipkan sebagai konstanta literal, mengapit nilai elemen dalam tanda kurung kurawal dan memisahkannya dengan koma. Contohnya ditunjukkan di bawah ini -

INSERT INTO monthly_savings 
VALUES (‘Manisha’, 
‘{20000, 14600, 23500, 13250}’, 
‘{{“FD”, “MF”}, {“FD”, “Property”}}’);

Mengakses Array

Contoh untuk mengakses Array ditunjukkan di bawah ini. Perintah yang diberikan di bawah ini akan memilih orang-orang yang tabungannya lebih banyak di kuartal kedua daripada kuartal keempat.

SELECT name FROM monhly_savings WHERE saving_per_quarter[2] > saving_per_quarter[4];

Memodifikasi Array

Contoh memodifikasi array seperti yang ditunjukkan di bawah ini.

UPDATE monthly_savings SET saving_per_quarter = '{25000,25000,27000,27000}'
WHERE name = 'Manisha';

atau menggunakan sintaks ekspresi ARRAY -

UPDATE monthly_savings SET saving_per_quarter = ARRAY[25000,25000,27000,27000]
WHERE name = 'Manisha';

Mencari Array

Contoh array pencarian adalah seperti yang ditunjukkan di bawah ini.

SELECT * FROM monthly_savings WHERE saving_per_quarter[1] = 10000 OR
saving_per_quarter[2] = 10000 OR
saving_per_quarter[3] = 10000 OR
saving_per_quarter[4] = 10000;

Jika ukuran array diketahui, metode pencarian yang diberikan di atas dapat digunakan. Lain, contoh berikut menunjukkan bagaimana mencari ketika ukurannya tidak diketahui.

SELECT * FROM monthly_savings WHERE 10000 = ANY (saving_per_quarter);

Jenis Komposit

Tipe ini merepresentasikan daftar nama field dan tipe datanya, yaitu struktur baris atau record tabel.

Deklarasi Jenis Komposit

Contoh berikut menunjukkan cara mendeklarasikan tipe komposit

CREATE TYPE inventory_item AS (
   name text,
   supplier_id integer,
   price numeric
);

Tipe data ini dapat digunakan dalam buat tabel seperti di bawah ini -

CREATE TABLE on_hand (
   item inventory_item,
   count integer
);

Input Nilai Komposit

Nilai komposit dapat disisipkan sebagai konstanta literal, mengapit nilai bidang dalam tanda kurung dan memisahkannya dengan koma. Contohnya ditunjukkan di bawah ini -

INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);

Ini berlaku untuk inventory_item yang ditentukan di atas. Kata kunci ROW sebenarnya opsional selama Anda memiliki lebih dari satu bidang dalam ekspresi.

Mengakses Jenis Komposit

Untuk mengakses bidang kolom komposit, gunakan titik diikuti dengan nama kolom, seperti memilih kolom dari nama tabel. Misalnya, untuk memilih beberapa subbidang dari tabel contoh on_hand kami, kueri akan seperti yang ditunjukkan di bawah ini -

SELECT (item).name FROM on_hand WHERE (item).price > 9.99;

Anda bahkan dapat menggunakan nama tabel juga (misalnya dalam kueri multitabel), seperti ini -

SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;

Jenis Rentang

Tipe rentang mewakili tipe data yang menggunakan rentang data. Jenis rentang dapat berupa rentang diskrit (mis., Semua nilai integer 1 hingga 10) atau rentang kontinu (mis., Titik waktu mana pun antara pukul 10:00 dan 11:00).

Jenis kisaran built-in yang tersedia mencakup kisaran berikut -

int4range - Rentang bilangan bulat
int8range - Berbagai bigint
numrange - Rentang numerik
tsrange - Rentang cap waktu tanpa zona waktu
tstzrange - Rentang cap waktu dengan zona waktu
daterange - Rentang tanggal

Jenis rentang kustom dapat dibuat untuk membuat jenis rentang baru tersedia, seperti rentang alamat IP menggunakan jenis inet sebagai basis, atau rentang float menggunakan tipe data float sebagai basis.

Jenis rentang mendukung batas rentang inklusif dan eksklusif menggunakan karakter [] dan (), masing-masing. Misalnya '[4,9)' mewakili semua bilangan bulat mulai dari dan termasuk 4 hingga tetapi tidak termasuk 9.

Jenis Pengenal Objek

Pengidentifikasi objek (OID) digunakan secara internal oleh PostgreSQL sebagai kunci utama untuk berbagai tabel sistem. Jika WITH OIDS ditentukan atau variabel konfigurasi default_with_oids diaktifkan, hanya kemudian, dalam kasus seperti itu OID ditambahkan ke tabel yang dibuat pengguna. Tabel berikut mencantumkan beberapa tipe alias. Tipe alias OID tidak memiliki operasinya sendiri kecuali untuk rutinitas input dan output khusus.

Nama	Referensi	Deskripsi	Contoh Nilai
oid	apa saja	pengenal objek numerik	564182
regproc	pg_proc	nama fungsi	jumlah
regprocedure	pg_proc	berfungsi dengan tipe argumen	jumlah (int4)
regoper	pg_operator	nama operator	+
regoperator	pg_operator	operator dengan tipe argumen	* (integer, integer) atau - (NONE, integer)
regclass	pg_class	nama relasi	pg_type
regtype	pg_type	nama tipe data	bilangan bulat
regconfig	pg_ts_config	konfigurasi pencarian teks	Inggris
regdictionary	pg_ts_dict	kamus pencarian teks	sederhana

Jenis Pseudo

Sistem tipe PostgreSQL berisi sejumlah entri tujuan khusus yang secara kolektif disebut tipe semu. Pseudo-type tidak bisa digunakan sebagai tipe data kolom, tapi bisa digunakan untuk mendeklarasikan argumen fungsi atau tipe hasil.

Tabel yang diberikan di bawah ini mencantumkan tipe pseudo yang ada.

No. S.	Nama & Deskripsi
1	any Menunjukkan bahwa suatu fungsi menerima tipe data masukan apa pun.
2	anyelement Menunjukkan bahwa suatu fungsi menerima tipe data apa pun.
3	anyarray Menunjukkan bahwa suatu fungsi menerima tipe data larik apa pun.
4	anynonarray Menunjukkan bahwa suatu fungsi menerima tipe data non-larik apa pun.
5	anyenum Menunjukkan bahwa suatu fungsi menerima tipe data enum apa pun.
6	anyrange Menunjukkan bahwa suatu fungsi menerima tipe data rentang apa pun.
7	cstring Menunjukkan bahwa suatu fungsi menerima atau mengembalikan string C yang diakhiri dengan null.
8	internal Menunjukkan bahwa suatu fungsi menerima atau mengembalikan tipe data server-internal.
9	language_handler Penangan panggilan bahasa prosedural dideklarasikan untuk mengembalikan language_handler.
10	fdw_handler Penangan pembungkus data asing dideklarasikan untuk mengembalikan fdw_handler.
11	record Mengidentifikasi fungsi yang mengembalikan jenis baris yang tidak ditentukan.
12	trigger Fungsi pemicu dideklarasikan untuk mengembalikan pemicu.
13	void Menunjukkan bahwa suatu fungsi tidak mengembalikan nilai.

Bab ini membahas tentang cara membuat database baru di PostgreSQL Anda. PostgreSQL menyediakan dua cara untuk membuat database baru -

Menggunakan CREATE DATABASE, sebuah perintah SQL.
Menggunakan createb, baris perintah dapat dieksekusi.

Menggunakan CREATE DATABASE

Perintah ini akan membuat database dari prompt shell PostgreSQL, tetapi Anda harus memiliki hak istimewa yang sesuai untuk membuat database. Secara default, database baru akan dibuat dengan mengkloning template database sistem standar1 .

Sintaksis

Sintaks dasar pernyataan CREATE DATABASE adalah sebagai berikut -

CREATE DATABASE dbname;

dimana dbname adalah nama database yang akan dibuat.

Contoh

Berikut ini adalah contoh sederhana, yang akan dibuat testdb di skema PostgreSQL Anda

postgres=# CREATE DATABASE testdb;
postgres-#

Menggunakan Perintah Createdb

Baris perintah PostgreSQL yang dapat dieksekusi createb adalah pembungkus di sekitar perintah SQL BUAT DATABASE . Satu-satunya perbedaan antara perintah ini dan perintah SQL CREATE DATABASE adalah bahwa perintah sebelumnya dapat langsung dijalankan dari baris perintah dan memungkinkan komentar ditambahkan ke dalam database, semuanya dalam satu perintah.

Sintaksis

Sintaks untuk createb adalah seperti yang ditunjukkan di bawah ini -

createdb [option...] [dbname [description]]

Parameter

Tabel yang diberikan di bawah ini mencantumkan parameter dengan deskripsinya.

No. S.	Parameter & Deskripsi
1	dbname Nama database yang akan dibuat.
2	description Menentukan komentar untuk dikaitkan dengan database yang baru dibuat.
3	options argumen baris perintah, yang diterima createb.

Pilihan

Tabel berikut mencantumkan argumen baris perintah yang diterima createb -

No. S.	Opsi & Deskripsi
1	-D tablespace Menentukan tablespace default untuk database.
2	-e Gema perintah yang dibuat createb dan mengirim ke server.
3	-E encoding Menentukan skema pengkodean karakter yang akan digunakan dalam database ini.
4	-l locale Menentukan lokal yang akan digunakan dalam database ini.
5	-T template Menentukan database template untuk membangun database ini.
6	--help Tampilkan bantuan tentang argumen baris perintah createb, dan keluar.
7	-h host Menentukan nama host dari mesin yang menjalankan server.
8	-p port Menentukan port TCP atau ekstensi file soket domain Unix lokal tempat server mendengarkan sambungan.
9	-U username Nama pengguna untuk disambungkan sebagai.
10	-w Jangan pernah mengeluarkan permintaan kata sandi.
11	-W Paksa createb untuk meminta kata sandi sebelum menghubungkan ke database.

Buka command prompt dan masuk ke direktori tempat PostgreSQL diinstal. Buka direktori bin dan jalankan perintah berikut untuk membuat database.

createdb -h localhost -p 5432 -U postgres testdb
password ******

Perintah yang diberikan di atas akan meminta Anda untuk memasukkan kata sandi pengguna admin PostgreSQL, yaitu postgres, secara default. Karenanya, berikan kata sandi dan lanjutkan untuk membuat database baru Anda

Setelah database dibuat menggunakan salah satu metode yang disebutkan di atas, Anda dapat memeriksanya di daftar database menggunakan \l, yaitu, perintah backslash el sebagai berikut -

postgres-# \l
                             List of databases
   Name    |  Owner   | Encoding | Collate | Ctype |   Access privileges   
-----------+----------+----------+---------+-------+-----------------------
 postgres  | postgres | UTF8     | C       | C     | 
 template0 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 template1 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 testdb    | postgres | UTF8     | C       | C     | 
(4 rows)

postgres-#

Bab ini menjelaskan berbagai metode mengakses database. Asumsikan bahwa kita telah membuat database di bab sebelumnya. Anda dapat memilih database menggunakan salah satu metode berikut -

Perintah SQL Database
Prompt Perintah OS

Perintah SQL Database

Asumsikan Anda telah meluncurkan klien PostgreSQL dan Anda telah mendarat di prompt SQL berikut -

postgres=#

Anda dapat memeriksa daftar database yang tersedia menggunakan \l, yaitu, perintah backslash el sebagai berikut -

postgres-# \l
                             List of databases
   Name    |  Owner   | Encoding | Collate | Ctype |   Access privileges   
-----------+----------+----------+---------+-------+-----------------------
 postgres  | postgres | UTF8     | C       | C     | 
 template0 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 template1 | postgres | UTF8     | C       | C     | =c/postgres          +
           |          |          |         |       | postgres=CTc/postgres
 testdb    | postgres | UTF8     | C       | C     | 
(4 rows)

postgres-#

Sekarang, ketik perintah berikut untuk menghubungkan / memilih database yang diinginkan; di sini, kami akan terhubung ke database testdb .

postgres=# \c testdb;
psql (9.2.4)
Type "help" for help.
You are now connected to database "testdb" as user "postgres".
testdb=#

Prompt Perintah OS

Anda dapat memilih database Anda dari command prompt itu sendiri pada saat Anda login ke database Anda. Berikut adalah contoh sederhana -

psql -h localhost -p 5432 -U postgress testdb
Password for user postgress: ****
psql (9.2.4)
Type "help" for help.
You are now connected to database "testdb" as user "postgres".
testdb=#

Anda sekarang masuk ke testdb PostgreSQL dan siap untuk menjalankan perintah Anda di dalam testdb. Untuk keluar dari database, Anda dapat menggunakan perintah \ q.

Pada bab ini, kita akan membahas cara menghapus database di PostgreSQL. Ada dua opsi untuk menghapus database -

Menggunakan DROP DATABASE, perintah SQL.
Menggunakan dropdb baris perintah yang dapat dieksekusi.

Berhati-hatilah sebelum menggunakan operasi ini karena menghapus database yang ada akan mengakibatkan hilangnya informasi lengkap yang tersimpan di database.

Menggunakan DROP DATABASE

Perintah ini menjatuhkan database. Ini menghapus entri katalog untuk database dan menghapus direktori yang berisi data. Itu hanya bisa dijalankan oleh pemilik database. Perintah ini tidak dapat dijalankan saat Anda atau orang lain terhubung ke database target (sambungkan ke postgres atau database lain untuk mengeluarkan perintah ini).

Sintaksis

Sintaks untuk DROP DATABASE diberikan di bawah ini -

DROP DATABASE [ IF EXISTS ] name

Parameter

Tabel mencantumkan parameter dengan deskripsinya.

No. S.	Parameter & Deskripsi
1	IF EXISTS Jangan melempar error jika database tidak ada. Pemberitahuan dikeluarkan dalam kasus ini.
2	name Nama database yang akan dihapus.

Kami tidak dapat melepaskan database yang memiliki koneksi terbuka, termasuk koneksi kami sendiri dari psql atau pgAdmin III . Kita harus beralih ke database atau template1 lain jika ingin menghapus database yang saat ini kita hubungkan. Jadi, mungkin akan lebih mudah untuk menggunakan program dropdb sebagai gantinya, yang merupakan pembungkus di sekitar perintah ini.

Contoh

Berikut ini adalah contoh sederhana, yang akan dihapus testdb dari skema PostgreSQL Anda -

postgres=# DROP DATABASE testdb;
postgres-#

Menggunakan Perintah dropdb

Baris perintah PostgresSQL dapat dieksekusi dropdbadalah pembungkus baris perintah di sekitar perintah SQL DROP DATABASE . Tidak ada perbedaan yang efektif antara menjatuhkan database melalui utilitas ini dan melalui metode lain untuk mengakses server. dropdb menghancurkan database PostgreSQL yang ada. Pengguna yang menjalankan perintah ini haruslah super user database atau pemilik database.

Sintaksis

Sintaks untuk dropdb adalah seperti di bawah ini -

dropdb  [option...] dbname

Parameter

Tabel berikut mencantumkan parameter dengan deskripsinya

No. S.	Parameter & Deskripsi
1	dbname Nama database yang akan dihapus.
2	option argumen baris perintah, yang diterima dropdb.

Pilihan

Tabel berikut mencantumkan argumen baris perintah yang diterima dropdb -

No. S.	Opsi & Deskripsi
1	-e Menunjukkan perintah yang dikirim ke server.
2	-i Mengeluarkan perintah verifikasi sebelum melakukan sesuatu yang merusak.
3	-V Cetak versi dropdb dan keluar.
4	--if-exists Jangan melempar error jika database tidak ada. Pemberitahuan dikeluarkan dalam kasus ini.
5	--help Perlihatkan bantuan tentang argumen baris perintah dropdb, dan keluar.
6	-h host Menentukan nama host dari mesin yang menjalankan server.
7	-p port Menentukan port TCP atau ekstensi file soket domain UNIX lokal tempat server mendengarkan sambungan.
8	-U username Nama pengguna untuk disambungkan sebagai.
9	-w Jangan pernah mengeluarkan permintaan kata sandi.
10	-W Paksa dropdb untuk meminta kata sandi sebelum menghubungkan ke database.
11	--maintenance-db=dbname Menentukan nama database yang akan disambungkan untuk menghapus database target.

Contoh

Contoh berikut menunjukkan menghapus database dari prompt perintah OS -

dropdb -h localhost -p 5432 -U postgress testdb
Password for user postgress: ****

Perintah di atas menjatuhkan database testdb. Di sini, saya telah menggunakanpostgres (Ditemukan di bawah pg_roles dari template1) nama pengguna untuk menghapus database.

Pernyataan PostgreSQL CREATE TABLE digunakan untuk membuat tabel baru di salah satu database yang diberikan.

Sintaksis

Sintaks dasar pernyataan CREATE TABLE adalah sebagai berikut -

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

CREATE TABLE adalah kata kunci, yang memerintahkan sistem database untuk membuat tabel baru. Nama unik atau pengenal untuk tabel mengikuti pernyataan CREATE TABLE. Awalnya, tabel kosong di database saat ini dimiliki oleh pengguna yang mengeluarkan perintah.

Kemudian, dalam tanda kurung, muncul daftar, yang mendefinisikan setiap kolom dalam tabel dan jenis tipe datanya. Sintaksnya akan menjadi jelas dengan contoh yang diberikan di bawah ini.

Contoh

Berikut ini 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 di tabel ini -

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 -

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 \d perintah, yang akan digunakan untuk membuat daftar semua tabel dalam database terlampir.

testdb-# \d

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

List of relations
 Schema |    Name    | Type  |  Owner
--------+------------+-------+----------
 public | company    | table | postgres
 public | department | table | postgres
(2 rows)

Menggunakan \d tablename untuk mendeskripsikan setiap tabel seperti yang ditunjukkan di bawah ini -

testdb-# \d company

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

Table "public.company"
  Column   |     Type      | Modifiers
-----------+---------------+-----------
 id        | integer       | not null
 name      | text          | not null
 age       | integer       | not null
 address   | character(50) |
 salary    | real          |
 join_date | date          |
Indexes:
    "company_pkey" PRIMARY KEY, btree (id)

Pernyataan TABEL DROP PostgreSQL digunakan untuk menghapus definisi tabel dan semua data terkait, indeks, aturan, pemicu, dan batasan 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

Sintaks dasar dari pernyataan DROP TABLE adalah sebagai berikut -

DROP TABLE table_name;

Contoh

Kami telah membuat tabel DEPARTMENT and COMPANY di bab sebelumnya. Pertama, verifikasi tabel ini (gunakan\d untuk membuat daftar tabel) -

testdb-# \d

Ini akan menghasilkan hasil sebagai berikut -

List of relations
 Schema |    Name    | Type  |  Owner
--------+------------+-------+----------
 public | company    | table | postgres
 public | department | table | postgres
(2 rows)

Ini berarti tabel DEPARTMENT dan COMPANY ada. Jadi mari kita jatuhkan sebagai berikut -

testdb=# drop table department, company;

Ini akan menghasilkan hasil sebagai berikut -

DROP TABLE
testdb=# \d
relations found.
testdb=#

Pesan yang dikembalikan DROP TABLE menunjukkan bahwa perintah drop berhasil dijalankan.

SEBUAH schemaadalah kumpulan tabel bernama. Skema juga dapat berisi tampilan, indeks, urutan, tipe data, operator, dan fungsi. Skema serupa dengan direktori di tingkat sistem operasi, kecuali bahwa skema tidak dapat disarangkan. Pernyataan PostgreSQL CREATE SCHEMA membuat skema.

Sintaksis

Sintaks dasar CREATE SCHEMA adalah sebagai berikut -

CREATE SCHEMA name;

Dimana nama adalah nama skema.

Sintaks untuk Membuat Tabel di Skema

Sintaks dasar untuk membuat tabel dalam skema adalah sebagai berikut -

CREATE TABLE myschema.mytable (
...
);

Contoh

Mari kita lihat contoh untuk membuat skema. Hubungkan ke database testdb dan buat skema myschema sebagai berikut -

testdb=# create schema myschema;
CREATE SCHEMA

Pesan "CREATE SCHEMA" menandakan bahwa skema berhasil dibuat.

Sekarang, mari kita buat tabel pada skema di atas sebagai berikut -

testdb=# create table myschema.company(
   ID   INT              NOT NULL,
   NAME VARCHAR (20)     NOT NULL,
   AGE  INT              NOT NULL,
   ADDRESS  CHAR (25),
   SALARY   DECIMAL (18, 2),
   PRIMARY KEY (ID)
);

Ini akan membuat tabel kosong. Anda dapat memverifikasi tabel yang dibuat dengan perintah yang diberikan di bawah ini -

testdb=# select * from myschema.company;

Ini akan menghasilkan hasil sebagai berikut -

id | name | age | address | salary
----+------+-----+---------+--------
(0 rows)

Sintaks untuk Menghapus Skema

Untuk melepaskan skema jika kosong (semua objek di dalamnya telah dihapus), gunakan perintah -

DROP SCHEMA myschema;

Untuk melepaskan skema termasuk semua objek yang ada, gunakan perintah -

DROP SCHEMA myschema CASCADE;

Keuntungan menggunakan Skema

Ini memungkinkan banyak pengguna untuk menggunakan satu database tanpa mengganggu satu sama lain.
Ini mengatur objek database ke dalam kelompok logis untuk membuatnya lebih mudah dikelola.
Aplikasi pihak ketiga dapat dimasukkan ke dalam skema terpisah sehingga tidak bertabrakan dengan nama objek lain.

PostgreSQL INSERT INTOpernyataan memungkinkan seseorang untuk memasukkan baris baru ke dalam tabel. Seseorang dapat menyisipkan satu baris dalam satu waktu atau beberapa baris sebagai hasil dari sebuah kueri.

Sintaksis

Sintaks dasar dari pernyataan INSERT INTO adalah sebagai berikut -

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.
Nama kolom target dapat dicantumkan dalam urutan apa pun. Nilai yang diberikan oleh klausa VALUES atau kueri dikaitkan dengan daftar kolom eksplisit atau implisit dari kiri ke kanan.

Anda mungkin tidak perlu menentukan nama kolom dalam kueri SQL jika Anda menambahkan nilai untuk semua kolom pada tabel. Namun, pastikan urutan nilainya dalam urutan yang sama dengan kolom di tabel. Sintaks SQL INSERT INTO adalah sebagai berikut -

INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);

Keluaran

Tabel berikut merangkum pesan keluaran dan artinya -

No. S.	Pesan & Deskripsi Output
1	INSERT oid 1 Pesan dikembalikan jika hanya satu baris yang disisipkan. oid adalah OID numerik dari baris yang disisipkan.
2	INSERT 0 # Pesan dikembalikan jika lebih dari satu baris disisipkan. # adalah jumlah baris yang disisipkan.

Contoh

Mari kita buat tabel PERUSAHAAN di testdb sebagai berikut -

CREATE TABLE COMPANY(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   JOIN_DATE	  DATE
);

Contoh berikut menyisipkan baris ke dalam tabel PERUSAHAAN -

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (1, 'Paul', 32, 'California', 20000.00,'2001-07-13');

Contoh berikut adalah menyisipkan baris; di sini kolom gaji dihilangkan dan oleh karena itu akan memiliki nilai default -

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,JOIN_DATE) VALUES (2, 'Allen', 25, 'Texas', '2007-12-13');

Contoh berikut menggunakan klausa DEFAULT untuk kolom JOIN_DATE daripada menentukan nilai -

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (3, 'Teddy', 23, 'Norway', 20000.00, DEFAULT );

Contoh berikut menyisipkan beberapa baris menggunakan sintaks multirow VALUES -

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00, '2007-12-13' ), (5, 'David', 27, 'Texas', 85000.00, '2007-12-13');

Semua pernyataan di atas akan membuat catatan berikut di tabel PERUSAHAAN. Bab berikutnya akan mengajari Anda cara menampilkan semua catatan ini dari tabel.

ID        NAME        AGE        ADDRESS     SALARY	  JOIN_DATE
----      ----------  -----      ----------  -------      --------
1         Paul        32         California  20000.0      2001-07-13
2         Allen       25         Texas                    2007-12-13
3         Teddy       23         Norway      20000.0
4         Mark        25         Rich-Mond   65000.0      2007-12-13
5         David       27         Texas       85000.0      2007-12-13

PostgreSQL SELECTpernyataan digunakan untuk mengambil data dari tabel database, yang mengembalikan data dalam bentuk tabel hasil. Tabel hasil ini disebut kumpulan hasil.

Sintaksis

Sintaks dasar pernyataan SELECT adalah sebagai berikut -

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 memiliki catatan sebagai berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut ini adalah contoh, yang akan mengambil bidang ID, Nama dan Gaji pelanggan yang tersedia di tabel PELANGGAN -

testdb=# SELECT ID, NAME, SALARY FROM COMPANY ;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | salary
 ----+-------+--------
   1 | Paul  |  20000
   2 | Allen |  15000
   3 | Teddy |  20000
   4 | Mark  |  65000
   5 | David |  85000
   6 | Kim   |  45000
   7 | James |  10000
(7 rows)

Jika Anda ingin mengambil semua bidang tabel PELANGGAN, gunakan kueri berikut -

testdb=# SELECT * FROM COMPANY;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Apa itu Operator di PostgreSQL?

Operator adalah kata khusus atau karakter yang digunakan terutama dalam klausa WHERE pernyataan PostgreSQL untuk melakukan operasi, seperti perbandingan dan operasi aritmatika.

Operator digunakan untuk menentukan kondisi dalam pernyataan PostgreSQL dan berfungsi sebagai penghubung untuk beberapa kondisi dalam pernyataan.

Operator aritmatika
Operator perbandingan
Operator logika
Operator bitwise

Operator Aritmatika PostgreSQL

Asumsikan variabel a memegang 2 dan variabel b memegang 3, lalu -

Contoh

Operator	Deskripsi	Contoh
+	Penambahan - Menambahkan nilai di kedua sisi operator	a + b akan memberi 5
-	Pengurangan - Mengurangi operan tangan kanan dari operan tangan kiri	a - b akan memberi -1
*	Perkalian - Mengalikan nilai di kedua sisi operator	a * b akan memberi 6
/	Divisi - Membagi operan tangan kiri dengan operan tangan kanan	b / a akan memberi 1
%	Modulus - Membagi operan tangan kiri dengan operan tangan kanan dan mengembalikan sisanya	b% a akan memberi 1
^	Eksponen - Ini memberikan nilai eksponen operan tangan kanan	a ^ b akan memberi 8
\| /	akar pangkat dua	\| / 25.0 akan menghasilkan 5
\|\| /	akar pangkat tiga	\|\| / 27.0 akan menghasilkan 3
!	faktorial	5! akan memberi 120
!!	faktorial (operator awalan)	!! 5 akan memberi 120

Operator Perbandingan PostgreSQL

Asumsikan variabel a menampung 10 dan variabel b menampung 20, maka -

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 nilai tidak sama maka kondisi menjadi benar.	(a! = b) benar.
<>	Memeriksa apakah nilai dari dua operan sama atau tidak, jika nilai tidak sama maka kondisi menjadi benar.	(a <> b) benar.
>	Memeriksa apakah nilai operan kiri lebih besar dari nilai operan kanan, jika ya maka kondisi 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 kondisi menjadi benar.	(a> = b) tidak benar.
<=	Memeriksa apakah nilai operan kiri kurang dari atau sama dengan nilai operan kanan, jika ya maka kondisi menjadi benar.	(a <= b) benar.

Operator Logika PostgreSQL

Berikut adalah daftar semua operator logika yang tersedia di PostgresSQL.

Tunjukkan Contoh

No. S.	Operator & Deskripsi
1	AND Operator AND memungkinkan adanya beberapa kondisi dalam klausa WHERE pernyataan PostgresSQL.
2	NOT Operator NOT membalikkan arti dari operator logika yang digunakannya. Misalnya. TIDAK ADA, TIDAK ANTARA, TIDAK DI dll.This is negate operator.
3	OR Operator OR digunakan untuk menggabungkan beberapa kondisi dalam klausa WHERE pernyataan PostgresSQL.

Operator String Bit PostgreSQL

Operator bitwise bekerja pada bit dan melakukan operasi bit demi bit. Tabel kebenaran untuk & dan | adalah sebagai berikut -

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; dan B = 13; sekarang dalam format biner mereka akan menjadi sebagai berikut -

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A | B = 0011 1101

~ A = 1100 0011

Tunjukkan Contoh

Operator Bitwise yang didukung oleh PostgreSQL tercantum dalam tabel berikut -

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
#	bitwise XOR.	A # B akan memberikan 49 yaitu 0100 1001

Ekspresi adalah kombinasi dari satu atau beberapa nilai, operator, dan fungsi PostgresSQL yang dievaluasi menjadi nilai.

EKSPRESI PostgreSQL seperti rumus dan ditulis dalam bahasa kueri. Anda juga bisa menggunakan untuk membuat kueri database untuk kumpulan data tertentu.

Sintaksis

Pertimbangkan sintaks dasar dari pernyataan SELECT sebagai berikut -

SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION | EXPRESSION];

Ada berbagai jenis ekspresi PostgreSQL, yang disebutkan di bawah ini -

PostgreSQL - Ekspresi Boolean

Ekspresi Boolean PostgreSQL mengambil data atas dasar pencocokan nilai tunggal. Berikut adalah sintaksnya -

SELECT column1, column2, columnN
FROM table_name
WHERE SINGLE VALUE MATCHTING EXPRESSION;

Pertimbangkan tabel PERUSAHAAN memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut adalah contoh sederhana yang menunjukkan penggunaan Ekspresi Boolean PostgreSQL -

testdb=# SELECT * FROM COMPANY WHERE SALARY = 10000;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address  | salary
----+-------+-----+----------+--------
  7 | James |  24 | Houston  |  10000
(1 row)

PostgreSQL - 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 SQL Numeric Expressions -

testdb=# SELECT (15 + 6) AS ADDITION ;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

addition
----------
       21
(1 row)

Ada beberapa fungsi bawaan seperti avg (), sum (), count () untuk melakukan apa yang dikenal sebagai penghitungan data agregat terhadap tabel atau kolom tabel tertentu.

testdb=# SELECT COUNT(*) AS "RECORDS" FROM COMPANY;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

RECORDS
---------
       7
(1 row)

PostgreSQL - Ekspresi Tanggal

Ekspresi Tanggal mengembalikan nilai tanggal dan waktu sistem saat ini dan ekspresi ini digunakan dalam berbagai manipulasi data.

testdb=#  SELECT CURRENT_TIMESTAMP;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

now
-------------------------------
 2013-05-06 14:38:28.078+05:30
(1 row)

Klausa WHERE PostgreSQL digunakan untuk menentukan kondisi saat mengambil data dari tabel tunggal atau bergabung dengan beberapa tabel.

Jika kondisi yang diberikan terpenuhi, baru kemudian ia mengembalikan nilai tertentu dari tabel. Anda dapat memfilter baris yang tidak ingin Anda sertakan dalam kumpulan hasil dengan menggunakan klausa WHERE.

Klausa WHERE tidak hanya digunakan dalam pernyataan SELECT, tetapi juga digunakan dalam pernyataan UPDATE, DELETE, dll., Yang akan kita periksa di bab-bab selanjutnya.

Sintaksis

Sintaks dasar pernyataan SELECT dengan klausa WHERE adalah sebagai berikut -

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

Anda dapat menentukan kondisi_penelusuran menggunakan perbandingan atau operator logika. like>, <, =, LIKE, NOT, dll. Contoh berikut akan membuat konsep ini menjadi jelas.

Contoh

Pertimbangkan tabel PERUSAHAAN memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut adalah contoh sederhana yang menunjukkan penggunaan Operator Logika PostgreSQL. Pernyataan SELECT akan mencantumkan semua record yang AGE-nya lebih besar dari atau sama dengan 25AND gaji lebih besar dari atau sama dengan 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age |  address   | salary
----+-------+-----+------------+--------
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(2 rows)

Pernyataan SELECT berikut mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25 OR gaji lebih besar dari atau sama dengan 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
(4 rows)

Pernyataan SELECT berikut mencantumkan semua catatan di mana AGE bukan NULL yang berarti semua catatan, karena tidak ada catatan yang memiliki AGE sama dengan NULL -

testdb=#  SELECT * FROM COMPANY WHERE AGE IS NOT NULL;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
 ----+-------+-----+------------+--------
   1 | Paul  |  32 | California |  20000
   2 | Allen |  25 | Texas      |  15000
   3 | Teddy |  23 | Norway     |  20000
   4 | Mark  |  25 | Rich-Mond  |  65000
   5 | David |  27 | Texas      |  85000
   6 | Kim   |  22 | South-Hall |  45000
   7 | James |  24 | Houston    |  10000
(7 rows)

Pernyataan SELECT berikut mencantumkan semua record di mana NAME dimulai dengan 'Pa', tidak peduli apa yang muncul setelah 'Pa'.

testdb=# SELECT * FROM COMPANY WHERE NAME LIKE 'Pa%';

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name | age |address    | salary
----+------+-----+-----------+--------
  1 | Paul |  32 | California|  20000

Pernyataan SELECT berikut mencantumkan semua catatan di mana nilai AGE adalah 25 atau 27 -

testdb=# SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(3 rows)

Pernyataan SELECT berikut mencantumkan semua catatan di mana nilai AGE bukan 25 atau 27 -

testdb=# SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  3 | Teddy |  23 | Norway     |  20000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(4 rows)

Pernyataan SELECT berikut mencantumkan semua catatan di mana nilai USIA berada di ANTARA 25 DAN 27 -

testdb=# SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(3 rows)

Pernyataan SELECT berikut menggunakan subkueri SQL di mana subkueri menemukan semua rekaman dengan bidang AGE yang memiliki GAJI> 65000 dan kemudian klausa WHERE digunakan bersama dengan operator EXISTS untuk mencantumkan semua rekaman di mana AGE dari kueri luar ada di hasil yang dikembalikan menurut sub-kueri -

testdb=# SELECT AGE FROM COMPANY
        WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

age
-----
  32
  25
  23
  25
  27
  22
  24
(7 rows)

Pernyataan SELECT berikut menggunakan subkueri SQL di mana subkueri menemukan semua rekaman dengan bidang AGE yang memiliki GAJI> 65000 dan kemudian klausa WHERE digunakan bersama dengan operator> untuk mencantumkan semua rekaman di mana AGE dari kueri luar lebih besar dari usia di hasil yang dikembalikan oleh sub-kueri -

testdb=# SELECT * FROM COMPANY
        WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name | age | address    | salary
----+------+-----+------------+--------
  1 | Paul |  32 | California |  20000

PostgreSQL AND dan ORoperator digunakan untuk menggabungkan beberapa kondisi untuk mempersempit data yang dipilih dalam pernyataan PostgreSQL. Kedua operator ini disebut operator konjungtif.

Operator ini menyediakan cara untuk membuat beberapa perbandingan dengan operator yang berbeda dalam pernyataan PostgreSQL yang sama.

Operator AND

Itu ANDOperator memungkinkan adanya beberapa kondisi dalam klausa WHERE pernyataan PostgreSQL. Saat menggunakan operator AND, kondisi lengkap akan dianggap benar jika semua kondisi benar. Misalnya [kondisi1] DAN [kondisi2] hanya akan benar jika kondisi1 dan kondisi2 adalah benar.

Sintaksis

Sintaks dasar operator AND dengan klausa WHERE adalah sebagai berikut -

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];

Anda dapat menggabungkan jumlah N kondisi menggunakan operator AND. Untuk tindakan yang akan diambil oleh pernyataan PostgreSQL, apakah itu transaksi atau kueri, semua kondisi yang dipisahkan oleh DAN harus BENAR.

Contoh

Pertimbangkan tabel PERUSAHAAN memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Pernyataan SELECT berikut mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25 AND gaji lebih besar dari atau sama dengan 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(2 rows)

Operator OR

Operator OR juga digunakan untuk menggabungkan beberapa kondisi dalam klausa WHERE pernyataan PostgreSQL. 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

Sintaks dasar operator OR dengan klausa WHERE adalah sebagai berikut -

SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]

Anda dapat menggabungkan jumlah N kondisi menggunakan operator OR. Untuk tindakan yang akan diambil oleh pernyataan PostgreSQL, apakah itu transaksi atau kueri, hanya SALAH SATU kondisi yang dipisahkan oleh ATAU harus BENAR.

Contoh

Pertimbangkan tabel PERUSAHAAN , memiliki catatan berikut -

# select * from COMPANY;
  id | name  | age | address   | salary
 ----+-------+-----+-----------+--------
   1 | Paul  |  32 | California|  20000
   2 | Allen |  25 | Texas     |  15000
   3 | Teddy |  23 | Norway    |  20000
   4 | Mark  |  25 | Rich-Mond |  65000
   5 | David |  27 | Texas     |  85000
   6 | Kim   |  22 | South-Hall|  45000
   7 | James |  24 | Houston   |  10000
(7 rows)

Pernyataan SELECT berikut mencantumkan semua catatan di mana AGE lebih besar dari atau sama dengan 25 OR gaji lebih besar dari atau sama dengan 65000.00 -

testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(4 rows)

PostgreSQL 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

Sintaks dasar dari kueri UPDATE dengan klausa WHERE adalah sebagai berikut -

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

Anda dapat menggabungkan jumlah N kondisi menggunakan operator DAN atau ATAU.

Contoh

Pertimbangkan tabel PERUSAHAAN , memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut ini adalah contoh, yang akan memperbarui ADDRESS untuk pelanggan yang ID-nya adalah 6 -

testdb=# UPDATE COMPANY SET SALARY = 15000 WHERE ID = 3;

Sekarang, tabel COMPANY akan memiliki record berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
  3 | Teddy |  23 | Norway     |  15000
(7 rows)

Jika Anda ingin mengubah semua nilai kolom ALAMAT dan GAJI di tabel PERUSAHAAN, Anda tidak perlu menggunakan klausa WHERE dan kueri UPDATE adalah sebagai berikut -

testdb=# UPDATE COMPANY SET ADDRESS = 'Texas', SALARY=20000;

Sekarang, tabel COMPANY akan memiliki record berikut -

id | name  | age | address | salary
----+-------+-----+---------+--------
  1 | Paul  |  32 | Texas   |  20000
  2 | Allen |  25 | Texas   |  20000
  4 | Mark  |  25 | Texas   |  20000
  5 | David |  27 | Texas   |  20000
  6 | Kim   |  22 | Texas   |  20000
  7 | James |  24 | Texas   |  20000
  3 | Teddy |  23 | Texas   |  20000
(7 rows)

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

Sintaksis

Sintaks dasar kueri DELETE dengan klausa WHERE adalah sebagai berikut -

DELETE FROM table_name
WHERE [condition];

Anda dapat menggabungkan jumlah N kondisi menggunakan operator DAN atau ATAU.

Contoh

Pertimbangkan tabel PERUSAHAAN , memiliki catatan sebagai berikut -

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut ini adalah contoh, yang akan MENGHAPUS pelanggan yang ID-nya 7 -

testdb=# DELETE FROM COMPANY WHERE ID = 2;

Sekarang, tabel COMPANY akan memiliki record berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
(6 rows)

Jika Anda ingin MENGHAPUS semua catatan dari tabel PERUSAHAAN, Anda tidak perlu menggunakan klausa WHERE dengan kueri DELETE, yang akan menjadi sebagai berikut -

testdb=# DELETE FROM COMPANY;

Sekarang, tabel COMPANY tidak memiliki record karena semua record telah dihapus oleh pernyataan DELETE.

PostgreSQL LIKEoperator digunakan untuk mencocokkan nilai teks dengan pola menggunakan wildcard. Jika ekspresi pencarian bisa dicocokkan dengan ekspresi pola, operator LIKE akan mengembalikan true, yaitu1.

Ada dua karakter pengganti yang digunakan sehubungan 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.

Jika salah satu dari dua tanda ini tidak digunakan dalam hubungannya dengan klausa LIKE, maka LIKE bertindak seperti operator sama dengan.

Sintaksis

Sintaks dasar% dan _ adalah sebagai berikut -

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 dapat menggabungkan jumlah N kondisi menggunakan operator DAN atau ATAU. Di sini XXXX bisa berupa nilai numerik atau string apa pun.

Contoh

Berikut adalah beberapa contoh yang menunjukkan WHERE bagian memiliki klausa LIKE yang berbeda dengan operator '%' dan '_' -

No. S.	Pernyataan & Deskripsi
1	WHERE SALARY::text LIKE '200%' Menemukan nilai apa pun yang dimulai dengan 200
2	WHERE SALARY::text LIKE '%200%' Menemukan nilai apa pun yang memiliki 200 di posisi mana pun
3	WHERE SALARY::text LIKE '_00%' Menemukan nilai apa pun yang memiliki 00 di posisi kedua dan ketiga
4	WHERE SALARY::text LIKE '2_%_%' Menemukan nilai apa pun yang dimulai dengan 2 dan setidaknya memiliki panjang 3 karakter
5	WHERE SALARY::text LIKE '%2' Menemukan nilai apa pun yang diakhiri dengan 2
6	WHERE SALARY::text LIKE '_2%3' Menemukan nilai apa pun yang memiliki 2 di posisi kedua dan diakhiri dengan 3
7	WHERE SALARY::text LIKE '2___3' Menemukan nilai apa pun dalam angka lima digit yang dimulai dengan 2 dan diakhiri dengan 3

Postgres LIKE hanya untuk membandingkan String. Oleh karena itu, kita perlu secara eksplisit mentransmisikan kolom integer ke string seperti pada contoh di atas.

Mari kita ambil contoh nyata, perhatikan tabel PERUSAHAAN , memiliki catatan sebagai berikut -

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut ini adalah contoh, yang akan menampilkan semua record dari tabel COMPANY dimana AGE dimulai dengan 2 -

testdb=# SELECT * FROM COMPANY WHERE AGE::text LIKE '2%';

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  8 | Paul  |  24 | Houston     |  20000
(7 rows)

Berikut ini adalah contoh, yang akan menampilkan semua record dari tabel COMPANY di mana ADDRESS akan memiliki tanda hubung (-) di dalam teks -

testdb=# SELECT * FROM COMPANY WHERE ADDRESS  LIKE '%-%';

Ini akan menghasilkan hasil sebagai berikut -

id | name | age |                      address              | salary
----+------+-----+-------------------------------------------+--------
  4 | Mark |  25 | Rich-Mond                                 |  65000
  6 | Kim  |  22 | South-Hall                                |  45000
(2 rows)

PostgreSQL LIMIT klausa digunakan untuk membatasi jumlah data yang dikembalikan oleh pernyataan SELECT.

Sintaksis

Sintaks dasar pernyataan SELECT dengan klausa LIMIT adalah sebagai berikut -

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

Berikut ini adalah sintaks klausa LIMIT ketika digunakan bersama dengan klausa OFFSET -

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

LIMIT dan OFFSET memungkinkan Anda untuk mengambil hanya sebagian dari baris yang dihasilkan oleh sisa kueri.

Contoh

Pertimbangkan tabel PERUSAHAAN memiliki catatan sebagai berikut -

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut ini adalah contoh, yang membatasi baris dalam tabel sesuai dengan jumlah baris yang ingin Anda ambil dari tabel -

testdb=# SELECT * FROM COMPANY LIMIT 4;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
(4 rows)

Namun, dalam situasi tertentu, Anda mungkin perlu mengambil sekumpulan record dari offset tertentu. Berikut adalah contoh, yang mengambil tiga rekaman mulai dari posisi ketiga -

testdb=# SELECT * FROM COMPANY LIMIT 3 OFFSET 2;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
(3 rows)

PostgreSQL ORDER BY klausa digunakan untuk mengurutkan data dalam urutan naik atau turun, berdasarkan satu atau beberapa kolom.

Sintaksis

Sintaks dasar klausa ORDER BY adalah sebagai berikut -

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 memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Berikut ini adalah contoh yang akan mengurutkan hasil dalam urutan menaik menurut GAJI -

testdb=# SELECT * FROM COMPANY ORDER BY AGE ASC;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
 ----+-------+-----+------------+--------
   6 | Kim   |  22 | South-Hall |  45000
   3 | Teddy |  23 | Norway     |  20000
   7 | James |  24 | Houston    |  10000
   8 | Paul  |  24 | Houston    |  20000
   4 | Mark  |  25 | Rich-Mond  |  65000
   2 | Allen |  25 | Texas      |  15000
   5 | David |  27 | Texas      |  85000
   1 | Paul  |  32 | California |  20000
   9 | James |  44 | Norway     |   5000
  10 | James |  45 | Texas      |   5000
(10 rows)

Berikut ini adalah contoh yang akan mengurutkan hasil dalam urutan menaik berdasarkan NAMA dan GAJI -

testdb=# SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address      | salary
----+-------+-----+--------------+--------
  2 | Allen |  25 | Texas        |  15000
  5 | David |  27 | Texas        |  85000
 10 | James |  45 | Texas        |   5000
  9 | James |  44 | Norway       |   5000
  7 | James |  24 | Houston      |  10000
  6 | Kim   |  22 | South-Hall   |  45000
  4 | Mark  |  25 | Rich-Mond    |  65000
  1 | Paul  |  32 | California   |  20000
  8 | Paul  |  24 | Houston      |  20000
  3 | Teddy |  23 | Norway       |  20000
(10 rows)

Berikut ini adalah contoh, yang akan mengurutkan hasil dalam urutan menurun menurut NAME -

testdb=# SELECT * FROM COMPANY ORDER BY NAME DESC;

Ini akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  3 | Teddy |  23 | Norway     |  20000
  1 | Paul  |  32 | California |  20000
  8 | Paul  |  24 | Houston    |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
  9 | James |  44 | Norway     |   5000
 10 | James |  45 | Texas      |   5000
  5 | David |  27 | Texas      |  85000
  2 | Allen |  25 | Texas      |  15000
(10 rows)

PostgreSQL GROUP BYklausa digunakan dalam kolaborasi dengan pernyataan SELECT untuk mengelompokkan baris tersebut dalam tabel yang memiliki data identik. Ini dilakukan untuk menghilangkan redundansi dalam output dan / atau menghitung agregat yang berlaku untuk grup ini.

Klausa GROUP BY mengikuti klausa WHERE dalam pernyataan SELECT dan mendahului klausa ORDER BY.

Sintaksis

Sintaks dasar klausa GROUP BY diberikan di bawah ini. 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....columnN

Anda 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

Consider the table COMPANY having records as follows −

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

If you want to know the total amount of salary of each customer, then GROUP BY query would be as follows −

testdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;

This would produce the following result −

name  |  sum
 -------+-------
  Teddy | 20000
  Paul  | 20000
  Mark  | 65000
  David | 85000
  Allen | 15000
  Kim   | 45000
  James | 10000
(7 rows)

Now, let us create three more records in COMPANY table using the following INSERT statements −

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

Now, our table has the following records with duplicate names −

id | name  | age | address      | salary
 ----+-------+-----+--------------+--------
   1 | Paul  |  32 | California   |  20000
   2 | Allen |  25 | Texas        |  15000
   3 | Teddy |  23 | Norway       |  20000
   4 | Mark  |  25 | Rich-Mond    |  65000
   5 | David |  27 | Texas        |  85000
   6 | Kim   |  22 | South-Hall   |  45000
   7 | James |  24 | Houston      |  10000
   8 | Paul  |  24 | Houston      |  20000
   9 | James |  44 | Norway       |   5000
  10 | James |  45 | Texas        |   5000
(10 rows)

Again, let us use the same statement to group-by all the records using NAME column as follows −

testdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;

This would produce the following result −

name  |  sum
-------+-------
 Allen | 15000
 David | 85000
 James | 20000
 Kim   | 45000
 Mark  | 65000
 Paul  | 40000
 Teddy | 20000
(7 rows)

Let us use ORDER BY clause along with GROUP BY clause as follows −

testdb=#  SELECT NAME, SUM(SALARY)
         FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;

This would produce the following result −

name  |  sum
-------+-------
 Teddy | 20000
 Paul  | 40000
 Mark  | 65000
 Kim   | 45000
 James | 20000
 David | 85000
 Allen | 15000
(7 rows)

In PostgreSQL, the WITH query provides a way to write auxiliary statements for use in a larger query. It helps in breaking down complicated and large queries into simpler forms, which are easily readable. These statements often referred to as Common Table Expressions or CTEs, can be thought of as defining temporary tables that exist just for one query.

The WITH query being CTE query, is particularly useful when subquery is executed multiple times. It is equally helpful in place of temporary tables. It computes the aggregation once and allows us to reference it by its name (may be multiple times) in the queries.

The WITH clause must be defined before it is used in the query.

Syntax

The basic syntax of WITH query is as follows −

WITH
   name_for_summary_data AS (
      SELECT Statement)
   SELECT columns
   FROM name_for_summary_data
   WHERE conditions <=> (
      SELECT column
      FROM name_for_summary_data)
   [ORDER BY columns]

Where name_for_summary_data is the name given to the WITH clause. The name_for_summary_data can be the same as an existing table name and will take precedence.

You can use data-modifying statements (INSERT, UPDATE or DELETE) in WITH. This allows you to perform several different operations in the same query.

Recursive WITH

Example

Consider the table COMPANY having records as follows −

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Now, let us write a query using the WITH clause to select the records from the above table, as follows −

With CTE AS
(Select
 ID
, NAME
, AGE
, ADDRESS
, SALARY
FROM COMPANY )
Select * From CTE;

The above given PostgreSQL statement will produce the following result −

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Now, let us write a query using the RECURSIVE keyword along with the WITH clause, to find the sum of the salaries less than 20000, as follows −

WITH RECURSIVE t(n) AS (
   VALUES (0)
   UNION ALL
   SELECT SALARY FROM COMPANY WHERE SALARY < 20000
)
SELECT sum(n) FROM t;

The above given PostgreSQL statement will produce the following result −

sum
-------
 25000
(1 row)

Let us write a query using data modifying statements along with the WITH clause, as shown below.

First, create a table COMPANY1 similar to the table COMPANY. The query in the example effectively moves rows from COMPANY to COMPANY1. The DELETE in WITH deletes the specified rows from COMPANY, returning their contents by means of its RETURNING clause; and then the primary query reads that output and inserts it into COMPANY1 TABLE −

CREATE TABLE COMPANY1(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

WITH moved_rows AS (
   DELETE FROM COMPANY
   WHERE
      SALARY >= 30000
   RETURNING *
)
INSERT INTO COMPANY1 (SELECT * FROM moved_rows);

The above given PostgreSQL statement will produce the following result −

INSERT 0 3

Now, the records in the tables COMPANY and COMPANY1 are as follows −

testdb=# SELECT * FROM COMPANY;
 id | name  | age |  address   | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  7 | James |  24 | Houston    |  10000
(4 rows)


testdb=# SELECT * FROM COMPANY1;
 id | name  | age | address | salary
----+-------+-----+-------------+--------
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 | South-Hall  |  45000
(3 rows)

The HAVING clause allows us to pick out particular rows where the function's result meets some condition.

The WHERE clause places conditions on the selected columns, whereas the HAVING clause places conditions on groups created by the GROUP BY clause.

Syntax

The following is the position of the HAVING clause in a SELECT query −

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

The HAVING clause must follow the GROUP BY clause in a query and must also precede the ORDER BY clause if used. The following is the syntax of the SELECT statement, including the HAVING clause −

SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2

Example

Consider the table COMPANY having records as follows −

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

The following is an example, which would display record for which the name count is less than 2 −

testdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) < 2;

This would produce the following result −

name
 -------
  Teddy
  Paul
  Mark
  David
  Allen
  Kim
  James
(7 rows)

Now, let us create three more records in COMPANY table using the following INSERT statements −

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

Now, our table has the following records with duplicate names −

id | name  | age | address      | salary
 ----+-------+-----+--------------+--------
   1 | Paul  |  32 | California   |  20000
   2 | Allen |  25 | Texas        |  15000
   3 | Teddy |  23 | Norway       |  20000
   4 | Mark  |  25 | Rich-Mond    |  65000
   5 | David |  27 | Texas        |  85000
   6 | Kim   |  22 | South-Hall   |  45000
   7 | James |  24 | Houston      |  10000
   8 | Paul  |  24 | Houston      |  20000
   9 | James |  44 | Norway       |   5000
  10 | James |  45 | Texas        |   5000
(10 rows)

The following is the example, which would display record for which the name count is greater than 1 −

testdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) > 1;

This would produce the following result −

name
-------
 Paul
 James
(2 rows)

The PostgreSQL DISTINCT keyword is used in conjunction with SELECT statement to eliminate all the duplicate records and fetching only unique records.

There may be a situation when you have multiple duplicate records in a table. While fetching such records, it makes more sense to fetch only unique records instead of fetching duplicate records.

Syntax

The basic syntax of DISTINCT keyword to eliminate duplicate records is as follows −

SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]

Example

Consider the table COMPANY having records as follows −

# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Let us add two more records to this table as follows −

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (8, 'Paul', 32, 'California', 20000.00 );

INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (9, 'Allen', 25, 'Texas', 15000.00 );

Now, the records in the COMPANY table would be −

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
  8 | Paul  |  32 | California |  20000
  9 | Allen |  25 | Texas      |  15000
(9 rows)

First, let us see how the following SELECT query returns duplicate salary records −

testdb=# SELECT name FROM COMPANY;

This would produce the following result −

name
-------
 Paul
 Allen
 Teddy
 Mark
 David
 Kim
 James
 Paul
 Allen
(9 rows)

Now, let us use DISTINCT keyword with the above SELECT query and see the result −

testdb=# SELECT DISTINCT name FROM COMPANY;

This would produce the following result where we do not have any duplicate entry −

name
-------
 Teddy
 Paul
 Mark
 David
 Allen
 Kim
 James
(7 rows)

Constraints are the rules enforced on data columns on table. These are used to prevent invalid data from being entered into the database. This ensures the accuracy and reliability of the data in the database.

Constraints could be column level or table level. Column level constraints are applied only to one column whereas table level constraints are applied to the whole table. Defining a data type for a column is a constraint in itself. For example, a column of type DATE constrains the column to valid dates.

The following are commonly used constraints available in PostgreSQL.

NOT NULL Constraint − Ensures that a column cannot have NULL value.
UNIQUE Constraint − Ensures that all values in a column are different.
PRIMARY Key − Uniquely identifies each row/record in a database table.
FOREIGN Key − Constrains data based on columns in other tables.
CHECK Constraint − The CHECK constraint ensures that all values in a column satisfy certain conditions.
EXCLUSION Constraint − The EXCLUDE constraint ensures that if any two rows are compared on the specified column(s) or expression(s) using the specified operator(s), not all of these comparisons will return TRUE.

NOT NULL Constraint

By default, a column can hold NULL values. If you do not want a column to have a NULL value, then you need to define such constraint on this column specifying that NULL is now not allowed for that column. A NOT NULL constraint is always written as a column constraint.

A NULL is not the same as no data; rather, it represents unknown data.

Example

For example, the following PostgreSQL statement creates a new table called COMPANY1 and adds five columns, three of which, ID and NAME and AGE, specify not to accept NULL values −

CREATE TABLE COMPANY1(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

UNIQUE Constraint

The UNIQUE Constraint prevents two records from having identical values in a particular column. In the COMPANY table, for example, you might want to prevent two or more people from having identical age.

Example

For example, the following PostgreSQL statement creates a new table called COMPANY3 and adds five columns. Here, AGE column is set to UNIQUE, so that you cannot have two records with same age −

CREATE TABLE COMPANY3(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL UNIQUE,
   ADDRESS        CHAR(50),
   SALARY         REAL    DEFAULT 50000.00
);

PRIMARY KEY Constraint

The PRIMARY KEY constraint uniquely identifies each record in a database table. There can be more UNIQUE columns, but only one primary key in a table. Primary keys are important when designing the database tables. Primary keys are unique ids.

We use them to refer to table rows. Primary keys become foreign keys in other tables, when creating relations among tables. Due to a 'longstanding coding oversight', primary keys can be NULL in SQLite. This is not the case with other databases

A primary key is a field in a table, which uniquely identifies each row/record in a database table. Primary keys must contain unique values. A primary key column cannot have NULL values.

A table can have only one primary key, which may consist of single or multiple fields. When multiple fields are used as a primary key, they are called a composite key.

If a table has a primary key defined on any field(s), then you cannot have two records having the same value of that field(s).

Example

You already have seen various examples above where we have created COMAPNY4 table with ID as primary key −

CREATE TABLE COMPANY4(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

FOREIGN KEY Constraint

A foreign key constraint specifies that the values in a column (or a group of columns) must match the values appearing in some row of another table. We say this maintains the referential integrity between two related tables. They are called foreign keys because the constraints are foreign; that is, outside the table. Foreign keys are sometimes called a referencing key.

Example

For example, the following PostgreSQL statement creates a new table called COMPANY5 and adds five columns.

CREATE TABLE COMPANY6(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

For example, the following PostgreSQL statement creates a new table called DEPARTMENT1, which adds three columns. The column EMP_ID is the foreign key and references the ID field of the table COMPANY6.

CREATE TABLE DEPARTMENT1(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      references COMPANY6(ID)
);

CHECK Constraint

The CHECK Constraint enables a condition to check the value being entered into a record. If the condition evaluates to false, the record violates the constraint and is not entered into the table.

Example

For example, the following PostgreSQL statement creates a new table called COMPANY5 and adds five columns. Here, we add a CHECK with SALARY column, so that you cannot have any SALARY as Zero.

CREATE TABLE COMPANY5(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT    NOT NULL,
   AGE            INT     NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL    CHECK(SALARY > 0)
);

EXCLUSION Constraint

Exclusion constraints ensure that if any two rows are compared on the specified columns or expressions using the specified operators, at least one of these operator comparisons will return false or null.

Example

For example, the following PostgreSQL statement creates a new table called COMPANY7 and adds five columns. Here, we add an EXCLUDE constraint −

CREATE TABLE COMPANY7(
   ID INT PRIMARY KEY     NOT NULL,
   NAME           TEXT,
   AGE            INT  ,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   EXCLUDE USING gist
   (NAME WITH =,
   AGE WITH <>)
);

Here, USING gist is the type of index to build and use for enforcement.

You need to execute the command CREATE EXTENSION btree_gist, once per database. This will install the btree_gist extension, which defines the exclusion constraints on plain scalar data types.

As we have enforced the age has to be same, let us see this by inserting records to the table −

INSERT INTO COMPANY7 VALUES(1, 'Paul', 32, 'California', 20000.00 );
INSERT INTO COMPANY7 VALUES(2, 'Paul', 32, 'Texas', 20000.00 );
INSERT INTO COMPANY7 VALUES(3, 'Paul', 42, 'California', 20000.00 );

For the first two INSERT statements, the records are added to the COMPANY7 table. For the third INSERT statement, the following error is displayed −

ERROR:  conflicting key value violates exclusion constraint "company7_name_age_excl"
DETAIL:  Key (name, age)=(Paul, 42) conflicts with existing key (name, age)=(Paul, 32).

Dropping Constraints

To remove a constraint you need to know its name. If the name is known, it is easy to drop. Else, you need to find out the system-generated name. The psql command \d table name can be helpful here. The general syntax is −

ALTER TABLE table_name DROP CONSTRAINT some_name;

The PostgreSQL Joins clause is used to combine records from two or more tables in a database. A JOIN is a means for combining fields from two tables by using values common to each.

Join Types in PostgreSQL are −

The CROSS JOIN
The INNER JOIN
The LEFT OUTER JOIN
The RIGHT OUTER JOIN
The FULL OUTER JOIN

Before we proceed, let us consider two tables, COMPANY and DEPARTMENT. We already have seen INSERT statements to populate COMPANY table. So just let us assume the list of records available in COMPANY table −

id | name  | age | address   | salary | join_date
----+-------+-----+-----------+--------+-----------
  1 | Paul  |  32 | California|  20000 | 2001-07-13
  3 | Teddy |  23 | Norway    |  20000 |
  4 | Mark  |  25 | Rich-Mond |  65000 | 2007-12-13
  5 | David |  27 | Texas     |  85000 | 2007-12-13
  2 | Allen |  25 | Texas     |        | 2007-12-13
  8 | Paul  |  24 | Houston   |  20000 | 2005-07-13
  9 | James |  44 | Norway    |   5000 | 2005-07-13
 10 | James |  45 | Texas     |   5000 | 2005-07-13

Another table is DEPARTMENT, has the following definition −

CREATE TABLE DEPARTMENT(
   ID INT PRIMARY KEY      NOT NULL,
   DEPT           CHAR(50) NOT NULL,
   EMP_ID         INT      NOT NULL
);

Here is the list of INSERT statements to populate DEPARTMENT table −

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

Finally, we have the following list of records available in DEPARTMENT table −

id | dept        | emp_id
----+-------------+--------
  1 | IT Billing  |  1
  2 | Engineering |  2
  3 | Finance     |  7

The CROSS JOIN

A CROSS JOIN matches every row of the first table with every row of the second table. If the input tables have x and y columns, respectively, the resulting table will have x+y columns. Because CROSS JOINs have the potential to generate extremely large tables, care must be taken to use them only when appropriate.

The following is the syntax of CROSS JOIN −

SELECT ... FROM table1 CROSS JOIN table2 ...

Based on the above tables, we can write a CROSS JOIN as follows −

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;

The above given query will produce the following result −

emp_id| name  |  dept
------|-------|--------------
    1 | Paul  | IT Billing
    1 | Teddy | IT Billing
    1 | Mark  | IT Billing
    1 | David | IT Billing
    1 | Allen | IT Billing
    1 | Paul  | IT Billing
    1 | James | IT Billing
    1 | James | IT Billing
    2 | Paul  | Engineering
    2 | Teddy | Engineering
    2 | Mark  | Engineering
    2 | David | Engineering
    2 | Allen | Engineering
    2 | Paul  | Engineering
    2 | James | Engineering
    2 | James | Engineering
    7 | Paul  | Finance
    7 | Teddy | Finance
    7 | Mark  | Finance
    7 | David | Finance
    7 | Allen | Finance
    7 | Paul  | Finance
    7 | James | Finance
    7 | James | Finance

The INNER JOIN

A INNER JOIN creates a new result table by combining column values of two tables (table1 and table2) based upon the join-predicate. The query compares each row of table1 with each row of table2 to find all pairs of rows, which satisfy the join-predicate. When the join-predicate is satisfied, column values for each matched pair of rows of table1 and table2 are combined into a result row.

An INNER JOIN is the most common type of join and is the default type of join. You can use INNER keyword optionally.

The following is the syntax of INNER JOIN −

SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;

Based on the above tables, we can write an INNER JOIN as follows −

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
        ON COMPANY.ID = DEPARTMENT.EMP_ID;

The above given query will produce the following result −

emp_id | name  | dept
--------+-------+------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering

The LEFT OUTER JOIN

The OUTER JOIN is an extension of the INNER JOIN. SQL standard defines three types of OUTER JOINs: LEFT, RIGHT, and FULL and PostgreSQL supports all of these.

In case of LEFT OUTER JOIN, an inner join is performed first. Then, for each row in table T1 that does not satisfy the join condition with any row in table T2, a joined row is added with null values in columns of T2. Thus, the joined table always has at least one row for each row in T1.

The following is the syntax of LEFT OUTER JOIN −

SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...

Based on the above tables, we can write an inner join as follows −

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

The above given query will produce the following result −

emp_id | name  | dept
--------+-------+------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
        | James |
        | David |
        | Paul  |
        | Mark  |
        | Teddy |
        | James |

The RIGHT OUTER JOIN

First, an inner join is performed. Then, for each row in table T2 that does not satisfy the join condition with any row in table T1, a joined row is added with null values in columns of T1. This is the converse of a left join; the result table will always have a row for each row in T2.

The following is the syntax of RIGHT OUTER JOIN −

SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...

Based on the above tables, we can write an inner join as follows −

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY RIGHT OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

The above given query will produce the following result −

emp_id | name  | dept
--------+-------+--------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 |       | Finance

The FULL OUTER JOIN

First, an inner join is performed. Then, for each row in table T1 that does not satisfy the join condition with any row in table T2, a joined row is added with null values in columns of T2. In addition, for each row of T2 that does not satisfy the join condition with any row in T1, a joined row with null values in the columns of T1 is added.

The following is the syntax of FULL OUTER JOIN −

SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...

Based on the above tables, we can write an inner join as follows −

testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY FULL OUTER JOIN DEPARTMENT
   ON COMPANY.ID = DEPARTMENT.EMP_ID;

The above given query will produce the following result −

emp_id | name  | dept
--------+-------+---------------
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 |       | Finance
        | James |
        | David |
        | Paul  |
        | Mark  |
        | Teddy |
        | James |

The PostgreSQL UNION clause/operator is used to combine the results of two or more SELECT statements without returning any duplicate rows.

To use UNION, each SELECT must have the same number of columns selected, the same number of column expressions, the same data type, and have them in the same order but they do not have to be the same length.

Syntax

The basic syntax of UNION is as follows −

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

UNION

SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]

Here, given condition could be any given expression based on your requirement.

Example

Consider the following two tables, (a) COMPANY table is as follows −

testdb=# SELECT * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

(b) Another table is DEPARTMENT as follows −

testdb=# SELECT * from DEPARTMENT;
 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     |      6
(7 rows)

Now let us join these two tables using SELECT statement along with UNION clause as follows −

testdb=# 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;

This would produce the following result −

emp_id | name  |  dept
--------+-------+--------------
      5 | David | Engineering
      6 | Kim   | Finance
      2 | Allen | Engineering
      3 | Teddy | Engineering
      4 | Mark  | Finance
      1 | Paul  | IT Billing
      7 | James | Finance
(7 rows)

Klausul 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

Sintaks dasar UNION ALL adalah sebagai berikut -

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 -

testdb=# 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
      7 | James | Finance
      3 | Teddy | Engineering
      4 | Mark  | Finance
      5 | David | Engineering
      6 | Kim   | Finance
      1 | Paul  | IT Billing
      2 | Allen | Engineering
      7 | James | Finance
      3 | Teddy | Engineering
      4 | Mark  | Finance
      5 | David | Engineering
      6 | Kim   | Finance
(14 rows)

PostgreSQL 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

Sintaks dasar penggunaan NULL sementara membuat tabel adalah sebagai berikut -

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. Oleh karena itu, ini 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 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.0

Mari kita gunakan pernyataan UPDATE untuk menetapkan beberapa nilai nullable sebagai NULL sebagai berikut -

testdb=# UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);

Sekarang, tabel COMPANY harus memiliki record berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  1 | Paul  |  32 | California  |  20000
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  5 | David |  27 | Texas       |  85000
  6 | Kim   |  22 |             |
  7 | James |  24 |             |
(7 rows)

Selanjutnya, mari kita lihat penggunaan IS NOT NULL operator untuk membuat daftar semua catatan di mana GAJI bukan NULL -

testdb=#  SELECT  ID, NAME, AGE, ADDRESS, SALARY
   FROM COMPANY
   WHERE SALARY IS NOT NULL;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
(5 rows)

Berikut ini adalah penggunaan IS NULL operator yang akan mencantumkan semua catatan di mana SALARY adalah NULL -

testdb=#  SELECT  ID, NAME, AGE, ADDRESS, SALARY
        FROM COMPANY
        WHERE SALARY IS NULL;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age | address | salary
----+-------+-----+---------+--------
  6 | Kim   |  22 |         |
  7 | James |  24 |         |
(2 rows)

Anda 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 PostgreSQL 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 PostgreSQL tertentu.

Sintaksis

Sintaks dasar table alias adalah sebagai berikut -

SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];

Sintaks dasar column alias adalah sebagai berikut -

SELECT column_name AS alias_name
FROM table_name
WHERE [condition];

Contoh

Perhatikan dua tabel berikut, (a) tabel PERUSAHAAN adalah sebagai berikut -

testdb=# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

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

Sekarang, berikut adalah penggunaan TABLE ALIAS di mana kami menggunakan C dan D sebagai alias untuk tabel PERUSAHAAN dan DEPARTEMEN, masing-masing -

testdb=# SELECT C.ID, C.NAME, C.AGE, D.DEPT
   FROM COMPANY AS C, DEPARTMENT AS D
   WHERE  C.ID = D.EMP_ID;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

id | name  | age |  dept
----+-------+-----+------------
  1 | Paul  |  32 | IT Billing
  2 | Allen |  25 | Engineering
  7 | James |  24 | Finance
  3 | Teddy |  23 | Engineering
  4 | Mark  |  25 | Finance
  5 | David |  27 | Engineering
  6 | Kim   |  22 | Finance
(7 rows)

Mari kita lihat contoh penggunaan COLUMN ALIAS di mana COMPANY_ID adalah alias kolom ID dan COMPANY_NAME adalah alias kolom nama -

testdb=# 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 PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

company_id | company_name | age | dept
------------+--------------+-----+------------
      1     | Paul         |  32 | IT Billing
      2     | Allen        |  25 | Engineering
      7     | James        |  24 | Finance
      3     | Teddy        |  23 | Engineering
      4     | Mark         |  25 | Finance
      5     | David        |  27 | Engineering
      6     | Kim          |  22 | Finance
(7 rows)

PostgreSQL Triggers adalah fungsi callback database, yang secara otomatis dijalankan / dipanggil ketika peristiwa database tertentu terjadi.

Berikut ini adalah poin penting tentang pemicu PostgreSQL -

Pemicu PostgreSQL dapat ditentukan untuk diaktifkan
- Sebelum operasi dicoba pada satu baris (sebelum batasan diperiksa dan INSERT, UPDATE atau DELETE dicoba)
- Setelah operasi selesai (setelah kendala diperiksa dan INSERT, UPDATE, atau DELETE telah selesai)
- Alih-alih operasi (dalam kasus penyisipan, pembaruan atau penghapusan pada tampilan)
Pemicu yang ditandai UNTUK SETIAP BARIS dipanggil sekali untuk setiap baris yang dimodifikasi oleh operasi. Sebaliknya, pemicu yang ditandai UNTUK SETIAP PERNYATAAN hanya dijalankan sekali untuk operasi tertentu, terlepas dari berapa banyak baris yang dimodifikasi.
Keduanya, klausa WHEN dan tindakan pemicu, dapat mengakses elemen dari 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 PostgreSQL yang ditentukan hanya dieksekusi untuk baris yang klausa WHEN benar. Jika tidak ada klausa WHEN yang diberikan, pernyataan PostgreSQL dijalankan untuk semua baris.
Jika beberapa pemicu dari jenis yang sama ditentukan untuk peristiwa yang sama, pemicu tersebut akan diaktifkan dalam urutan abjad berdasarkan nama.
Kata kunci SEBELUM, SETELAH, atau BUKAN 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 tablenametidak database.tablename.
Opsi CONSTRAINT ketika ditentukan membuat pemicu batasan . Ini sama dengan pemicu biasa kecuali bahwa waktu pengaktifan pemicu dapat disesuaikan menggunakan SET CONSTRAINTS. Pemicu batasan diharapkan memunculkan pengecualian saat batasan yang mereka terapkan dilanggar.

Sintaksis

Sintaks dasar pembuatan file trigger adalah sebagai berikut -

CREATE  TRIGGER trigger_name [BEFORE|AFTER|INSTEAD OF] event_name
ON table_name
[
 -- Trigger logic goes here....
];

Sini, event_namebisa berupa operasi database INSERT, DELETE, UPDATE, dan TRUNCATE 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 tabel sebagai berikut -

CREATE  TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name
ON table_name
[
 -- Trigger logic goes here....
];

Contoh

Mari kita pertimbangkan sebuah kasus di mana kita ingin menyimpan uji coba audit untuk setiap catatan yang dimasukkan ke dalam tabel PERUSAHAAN, yang akan kita buat baru sebagai berikut (Hapus tabel PERUSAHAAN jika Anda sudah memilikinya).

testdb=# 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 -

testdb=# 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 saat record akan dibuat di tabel COMPANY. Jadi sekarang, mari kita buat pemicu pada tabel PERUSAHAAN sebagai berikut -

testdb=# CREATE TRIGGER example_trigger AFTER INSERT ON COMPANY
FOR EACH ROW EXECUTE PROCEDURE auditlogfunc();

Dimana auditlogfunc () adalah PostgreSQL procedure dan memiliki definisi berikut -

CREATE OR REPLACE FUNCTION auditlogfunc() RETURNS TRIGGER AS $example_table$
   BEGIN
      INSERT INTO AUDIT(EMP_ID, ENTRY_DATE) VALUES (new.ID, current_timestamp);
      RETURN NEW;
   END;
$example_table$ LANGUAGE plpgsql;

Sekarang, kita akan memulai pekerjaan sebenarnya. Mari kita mulai memasukkan catatan dalam tabel PERUSAHAAN yang seharusnya menghasilkan catatan log audit dalam tabel AUDIT. Jadi mari kita buat satu record di tabel COMPANY sebagai berikut -

testdb=# 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

Pada waktu yang sama, satu record akan dibuat dalam tabel AUDIT. Record ini adalah hasil dari sebuah trigger, yang kita buat pada operasi INSERT pada tabel COMPANY. Demikian pula, Anda dapat membuat pemicu pada operasi UPDATE dan DELETE berdasarkan kebutuhan Anda.

emp_id |          entry_date
--------+-------------------------------
      1 | 2013-05-05 15:49:59.968+05:30
(1 row)

Mendaftar TRIGGERS

Anda dapat membuat daftar semua pemicu dalam database saat ini dari pg_trigger tabel sebagai berikut -

testdb=# SELECT * FROM pg_trigger;

Pernyataan PostgreSQL yang diberikan di atas akan mencantumkan semua pemicu.

Jika Anda ingin membuat daftar pemicu pada tabel tertentu, gunakan klausa AND dengan nama tabel sebagai berikut -

testdb=# SELECT tgname FROM pg_trigger, pg_class WHERE tgrelid=pg_class.oid AND relname='company';

Pernyataan PostgreSQL yang diberikan di atas juga akan mencantumkan hanya satu entri sebagai berikut -

tgname
-----------------
 example_trigger
(1 row)

Menjatuhkan PEMICU

Berikut ini adalah perintah DROP, yang dapat digunakan untuk menjatuhkan pemicu yang ada -

testdb=# DROP TRIGGER trigger_name;

Indeks adalah tabel pencarian khusus yang dapat digunakan mesin pencari database untuk mempercepat pengambilan data. Sederhananya, indeks adalah penunjuk ke data dalam tabel. Indeks dalam database sangat mirip dengan indeks di bagian belakang buku.

Misalnya, jika Anda ingin mereferensikan semua halaman dalam sebuah buku yang membahas topik tertentu, Anda harus merujuk ke indeks terlebih dahulu, yang mencantumkan semua topik menurut abjad dan kemudian merujuk ke satu atau beberapa nomor halaman tertentu.

Sebuah indeks membantu untuk mempercepat query SELECT dan klausa WHERE; namun, ini 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

Sintaks dasar CREATE INDEX adalah sebagai berikut -

CREATE INDEX index_name ON table_name;

Jenis Indeks

PostgreSQL menyediakan beberapa jenis indeks: B-tree, Hash, GiST, SP-GiST dan GIN. Setiap jenis Indeks menggunakan algoritme berbeda yang paling sesuai untuk berbagai jenis kueri. Secara default, perintah BUAT INDEKS membuat indeks pohon-B, yang sesuai dengan situasi paling umum.

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 Multikolom

Indeks multikolom didefinisikan di lebih dari satu kolom tabel. Sintaks dasarnya adalah sebagai berikut -

CREATE INDEX index_name
ON table_name (column1_name, column2_name);

Apakah akan membuat indeks satu kolom atau indeks multikolom, 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 dalam klausa WHERE sebagai filter, indeks multikolom akan menjadi pilihan terbaik.

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 Parsial

Indeks parsial adalah indeks yang dibangun di atas subset tabel; subset didefinisikan oleh ekspresi kondisional (disebut predikat indeks parsial). Indeks berisi entri hanya untuk baris tabel yang memenuhi predikat. Sintaks dasarnya adalah sebagai berikut -

CREATE INDEX index_name
on table_name (conditional_expression);

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.

Contoh

Berikut adalah contoh di mana kita akan membuat indeks pada tabel PERUSAHAAN untuk kolom gaji -

# CREATE INDEX salary_index ON COMPANY (salary);

Sekarang, mari kita daftarkan semua indeks yang tersedia di tabel PERUSAHAAN menggunakan \d company perintah.

# \d company

Ini akan menghasilkan hasil berikut, di mana company_pkey adalah indeks implisit, yang dibuat saat tabel dibuat.

Table "public.company"
 Column  |     Type      | Modifiers
---------+---------------+-----------
 id      | integer       | not null
 name    | text          | not null
 age     | integer       | not null
 address | character(50) |
 salary  | real          |
Indexes:
    "company_pkey" PRIMARY KEY, btree (id)
    "salary_index" btree (salary)

Anda dapat membuat daftar seluruh database indeks menggunakan file \di perintah -

Perintah DROP INDEX

Indeks dapat dijatuhkan menggunakan PostgreSQL DROPperintah. Perhatian harus diberikan saat menurunkan indeks karena kinerja mungkin melambat atau ditingkatkan.

Sintaks dasarnya adalah sebagai berikut -

DROP INDEX index_name;

Anda dapat menggunakan pernyataan berikut untuk menghapus indeks yang dibuat sebelumnya -

# 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 pada tabel kecil.
Tabel yang memiliki operasi penyisipan atau pembaruan batch besar yang sering.
Indeks tidak boleh digunakan pada kolom yang berisi nilai NULL dalam jumlah tinggi.
Kolom yang sering dimanipulasi tidak boleh diindeks.

PostgreSQL ALTER TABLE perintah digunakan untuk menambah, menghapus atau mengubah kolom dalam tabel yang sudah ada.

Anda juga akan menggunakan perintah ALTER TABLE untuk menambah dan melepaskan berbagai batasan pada tabel yang ada.

Sintaksis

Sintaks dasar ALTER TABLE untuk menambahkan kolom baru pada tabel yang sudah ada adalah sebagai berikut -

ALTER TABLE table_name ADD column_name datatype;

Sintaks dasar ALTER TABLE to DROP COLUMN dalam tabel yang ada adalah sebagai berikut -

ALTER TABLE table_name DROP COLUMN column_name;

Sintaks dasar ALTER TABLE untuk mengubah file DATA TYPE dari kolom dalam tabel adalah sebagai berikut -

ALTER TABLE table_name ALTER COLUMN column_name TYPE datatype;

Sintaks dasar ALTER TABLE untuk menambahkan file NOT NULL batasan ke kolom dalam tabel adalah sebagai berikut -

ALTER TABLE table_name MODIFY column_name datatype NOT NULL;

Sintaks dasar ALTER TABLE to ADD UNIQUE CONSTRAINT ke tabel adalah sebagai berikut -

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);

Sintaks dasar ALTER TABLE to ADD CHECK CONSTRAINT ke tabel adalah sebagai berikut -

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

Sintaks dasar ALTER TABLE to ADD PRIMARY KEY batasan ke tabel adalah sebagai berikut -

ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);

Sintaks dasar ALTER TABLE to DROP CONSTRAINT dari tabel adalah sebagai berikut -

ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;

Jika Anda menggunakan MySQL, kodenya adalah sebagai berikut -

ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;

Sintaks dasar ALTER TABLE to DROP PRIMARY KEY kendala dari tabel adalah sebagai berikut -

ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;

Jika Anda menggunakan MySQL, kodenya adalah sebagai berikut -

ALTER TABLE table_name
DROP PRIMARY KEY;

Contoh

Pertimbangkan tabel PERUSAHAAN kami memiliki catatan berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Berikut ini adalah contoh untuk MENAMBAHKAN kolom baru di tabel yang sudah ada -

testdb=# ALTER TABLE COMPANY ADD GENDER char(1);

Sekarang, tabel COMPANY diubah dan berikut ini akan menjadi output dari pernyataan SELECT -

id | name  | age | address     | salary | gender
----+-------+-----+-------------+--------+--------
  1 | Paul  |  32 | California  |  20000 |
  2 | Allen |  25 | Texas       |  15000 |
  3 | Teddy |  23 | Norway      |  20000 |
  4 | Mark  |  25 | Rich-Mond   |  65000 |
  5 | David |  27 | Texas       |  85000 |
  6 | Kim   |  22 | South-Hall  |  45000 |
  7 | James |  24 | Houston     |  10000 |
(7 rows)

Berikut adalah contoh untuk DROP kolom gender dari tabel yang ada -

testdb=# ALTER TABLE COMPANY DROP GENDER;

Sekarang, tabel COMPANY diubah dan berikut ini akan menjadi output dari pernyataan SELECT -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

PostgreSQL TRUNCATE TABLEperintah digunakan untuk menghapus data lengkap dari tabel yang ada. Anda juga dapat menggunakan perintah DROP TABLE untuk menghapus tabel lengkap tetapi itu akan menghapus struktur tabel lengkap dari database dan Anda perlu membuat ulang tabel ini sekali lagi jika Anda ingin menyimpan beberapa data.

Ini memiliki efek yang sama seperti DELETE pada setiap tabel, tetapi karena tidak benar-benar memindai tabel, ini lebih cepat. Selain itu, ia mengambil kembali ruang disk dengan segera, daripada memerlukan operasi VACUUM berikutnya. Ini paling berguna pada tabel besar.

Sintaksis

Sintaks dasar TRUNCATE TABLE adalah sebagai berikut -

TRUNCATE TABLE  table_name;

Contoh

Pertimbangkan tabel PERUSAHAAN memiliki catatan berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(7 rows)

Berikut ini adalah contoh untuk memotong -

testdb=# TRUNCATE TABLE COMPANY;

Sekarang, tabel COMPANY dipotong dan berikut ini akan menjadi output dari pernyataan SELECT -

testdb=# SELECT * FROM CUSTOMERS;
 id | name | age | address | salary
----+------+-----+---------+--------
(0 rows)

Tampilan adalah tabel pseudo. Artinya, mereka bukanlah tabel nyata; namun tampil sebagai tabel biasa untuk SELECT. Tampilan dapat mewakili bagian dari tabel nyata, memilih kolom atau baris tertentu dari tabel biasa. Sebuah tampilan bahkan dapat mewakili tabel yang digabungkan. Karena tampilan diberi izin terpisah, Anda bisa menggunakannya untuk membatasi akses tabel sehingga pengguna hanya melihat baris atau kolom tertentu dari tabel.

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 PostgreSQL tertulis untuk membuat tampilan.

Tampilan, yang merupakan jenis tabel virtual, memungkinkan pengguna untuk melakukan hal berikut -

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.

Karena tampilan bukan tabel biasa, Anda mungkin tidak dapat menjalankan pernyataan DELETE, INSERT, atau UPDATE pada tampilan. Namun, Anda dapat membuat ATURAN untuk memperbaiki masalah ini menggunakan DELETE, INSERT atau UPDATE pada tampilan.

Membuat Tampilan

Tampilan PostgreSQL dibuat menggunakan CREATE VIEWpernyataan. Tampilan PostgreSQL dapat dibuat dari satu tabel, beberapa tabel, atau tampilan lain.

Sintaks dasar CREATE VIEW adalah sebagai berikut -

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 sangat mirip seperti Anda menggunakannya dalam kueri PILIH PostgreSQL normal. Jika TEMP opsional atau kata kunci TEMPORARY ada, tampilan akan dibuat di ruang sementara. Tampilan sementara secara otomatis dihapus di akhir sesi saat ini.

Contoh

Pertimbangkan, tabel PERUSAHAAN memiliki catatan berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000

Sekarang, berikut adalah contoh untuk membuat view dari tabel COMPANY. Tampilan ini hanya akan digunakan untuk memiliki beberapa kolom dari tabel COMPANY -

testdb=# CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM  COMPANY;

Sekarang, Anda dapat membuat kueri COMPANY_VIEW dengan cara yang sama seperti Anda membuat kueri tabel sebenarnya. Berikut contohnya -

testdb=# 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 |  24
(7 rows)

Menjatuhkan Tampilan

Untuk melepaskan tampilan, cukup gunakan pernyataan DROP VIEW dengan view_name. Sintaks dasar DROP VIEW adalah sebagai berikut -

testdb=# DROP VIEW view_name;

Perintah berikut akan menghapus tampilan COMPANY_VIEW, yang kita buat di bagian terakhir -

testdb=# 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 record, mengupdate record, 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 PostgreSQL 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

Perintah berikut 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 saja. Mereka tidak dapat digunakan saat membuat tabel atau menjatuhkannya karena operasi ini secara otomatis dilakukan dalam database.

Perintah BEGIN TRANSACTION

Transaksi dapat dimulai menggunakan BEGIN TRANSACTION atau cukup BEGIN perintah. Transaksi seperti itu biasanya bertahan sampai perintah COMMIT atau ROLLBACK berikutnya ditemukan. Tetapi transaksi juga akan ROLLBACK jika database ditutup atau jika terjadi kesalahan.

Berikut ini adalah sintaks sederhana untuk memulai transaksi -

BEGIN;

or

BEGIN TRANSACTION;

Perintah COMMIT

Perintah COMMIT adalah perintah transaksional yang digunakan untuk menyimpan perubahan yang dilakukan oleh transaksi ke database.

Perintah COMMIT menyimpan semua transaksi ke database sejak COMMIT atau perintah ROLLBACK terakhir.

Sintaks untuk perintah COMMIT adalah sebagai berikut -

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.

Sintaks untuk perintah ROLLBACK adalah sebagai berikut -

ROLLBACK;

Contoh

Pertimbangkan tabel PERUSAHAAN memiliki catatan berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Sekarang, mari kita mulai transaksi dan menghapus record dari tabel yang memiliki age = 25 dan terakhir kita menggunakan perintah ROLLBACK untuk membatalkan semua perubahan.

testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
ROLLBACK;

Jika Anda akan memeriksa tabel PERUSAHAAN masih memiliki catatan berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000

Sekarang, mari kita mulai transaksi lain dan menghapus record dari tabel yang memiliki age = 25 dan terakhir kita menggunakan perintah COMMIT untuk melakukan semua perubahan.

testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
COMMIT;

Jika Anda akan memeriksa tabel PERUSAHAAN, itu masih memiliki catatan berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  3 | Teddy |  23 | Norway     |  20000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000
(5 rows)

Locks atau Exclusive Locks atau Write Locks mencegah pengguna mengubah baris atau seluruh tabel. Baris yang diubah oleh UPDATE dan DELETE kemudian secara eksklusif dikunci secara otomatis selama transaksi. Ini mencegah pengguna lain mengubah baris hingga transaksi dilakukan atau dibatalkan.

Satu-satunya saat pengguna harus menunggu pengguna lain adalah saat mereka mencoba mengubah baris yang sama. Jika mereka mengubah baris yang berbeda, tidak perlu menunggu. Query SELECT tidak perlu menunggu.

Database melakukan penguncian secara otomatis. Namun, dalam kasus tertentu, penguncian harus dikontrol secara manual. Penguncian manual dapat dilakukan dengan menggunakan perintah LOCK. Ini memungkinkan spesifikasi jenis dan cakupan kunci transaksi.

Sintaks untuk perintah LOCK

Sintaks dasar untuk perintah LOCK adalah sebagai berikut -

LOCK [ TABLE ]
name
 IN
lock_mode

name- Nama (kualifikasi skema opsional) dari tabel yang ada untuk dikunci. Jika HANYA ditentukan sebelum nama tabel, hanya tabel itu yang dikunci. Jika HANYA tidak ditentukan, tabel dan semua tabel turunannya (jika ada) dikunci.
lock_mode- Mode kunci menentukan kunci mana yang bentrok dengan kunci ini. Jika tidak ada mode kunci yang ditentukan, maka ACCESS EXCLUSIVE, mode paling ketat, digunakan. Nilai yang memungkinkan adalah: ACCESS SHARE, ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE, SHARE, SHARE ROW EKSKLUSIF, EKSKLUSIF, AKSES EKSKLUSIF.

Setelah diperoleh, kunci akan ditahan untuk sisa transaksi saat ini. Tidak ada perintah UNLOCK TABLE; kunci selalu dilepaskan pada akhir transaksi.

DeadLocks

Kebuntuan bisa terjadi ketika dua transaksi menunggu satu sama lain untuk menyelesaikan operasinya. Meskipun PostgreSQL dapat mendeteksinya dan mengakhirinya dengan ROLLBACK, jalan buntu masih bisa merepotkan. Untuk mencegah aplikasi Anda mengalami masalah ini, pastikan untuk merancangnya sedemikian rupa sehingga akan mengunci objek dalam urutan yang sama.

Kunci Penasihat

PostgreSQL menyediakan sarana untuk membuat kunci yang memiliki arti yang ditentukan aplikasi. Ini disebut kunci penasehat . Karena sistem tidak memaksakan penggunaannya, aplikasi terserah pada aplikasi untuk menggunakannya dengan benar. Kunci Advisory dapat berguna untuk mengunci strategi yang tidak cocok untuk model MVCC.

Misalnya, penggunaan umum dari advisory lock adalah untuk meniru strategi penguncian pesimis yang biasa disebut sistem manajemen data "file datar". Sementara bendera yang disimpan dalam tabel dapat digunakan untuk tujuan yang sama, kunci penasehat lebih cepat, menghindari penggelembungan tabel, dan secara otomatis dibersihkan oleh server di akhir sesi.

Contoh

Pertimbangkan tabel PERUSAHAAN memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Contoh berikut mengunci tabel PERUSAHAAN dalam database testdb dalam mode AKSES EKSKLUSIF. Pernyataan LOCK hanya berfungsi dalam mode transaksi -

testdb=#BEGIN;
LOCK TABLE company1 IN ACCESS EXCLUSIVE MODE;

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

LOCK TABLE

Pesan di atas menunjukkan bahwa tabel dikunci hingga transaksi berakhir dan untuk menyelesaikan transaksi Anda harus melakukan rollback atau melakukan transaksi.

Sebuah subquery atau Inner query atau Nested query adalah query dalam query PostgreSQL lain dan disematkan 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, 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, EXISTS, NOT IN, ANY / SOME, ALL.
Operator BETWEEN tidak dapat digunakan dengan subkueri; Namun, ANTARA dapat digunakan dalam subkueri.

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 yang memiliki catatan berikut -

id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Sekarang, mari kita periksa sub-query berikut dengan pernyataan SELECT -

testdb=# 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
  5 | David |  27 | Texas       |  85000
(2 rows)

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

Sintaks dasarnya adalah 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. Sekarang, untuk menyalin tabel COMPANY lengkap ke dalam COMPANY_BKP, berikut adalah sintaksnya -

testdb=# 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.

Sintaks dasarnya adalah 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 -

testdb=# UPDATE COMPANY
   SET SALARY = SALARY * 0.50
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE >= 27 );

Ini akan mempengaruhi dua baris dan akhirnya tabel COMPANY akan memiliki record berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  1 | Paul  |  32 | California  |  10000
  5 | David |  27 | Texas       |  42500
(7 rows)

Subkueri dengan Pernyataan DELETE

Subkueri dapat digunakan bersama dengan pernyataan DELETE seperti pernyataan lain yang disebutkan di atas.

Sintaks dasarnya adalah 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 rekaman dari tabel PERUSAHAAN untuk semua pelanggan, yang AGE-nya lebih besar dari atau sama dengan 27 -

testdb=# DELETE FROM COMPANY
   WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
      WHERE AGE > 27 );

Ini akan mempengaruhi dua baris dan akhirnya tabel COMPANY akan memiliki record berikut -

id | name  | age | address     | salary
----+-------+-----+-------------+--------
  2 | Allen |  25 | Texas       |  15000
  3 | Teddy |  23 | Norway      |  20000
  4 | Mark  |  25 | Rich-Mond   |  65000
  6 | Kim   |  22 | South-Hall  |  45000
  7 | James |  24 | Houston     |  10000
  5 | David |  27 | Texas       |  42500
(6 rows)

PostgreSQL memiliki tipe data smallserial , serial dan bigserial ; ini bukan tipe sebenarnya, tetapi hanya kenyamanan notasi untuk membuat kolom pengenal unik. Ini mirip dengan properti AUTO_INCREMENT yang didukung oleh beberapa database lain.

Jika Anda ingin kolom serial memiliki batasan unik atau menjadi kunci utama, sekarang harus ditentukan, sama seperti tipe data lainnya.

Jenis nama seri menciptakan bilangan bulat kolom. Nama tipe bigserial membuat kolom bigint . Bigserial harus digunakan jika Anda mengantisipasi penggunaan lebih dari 2 ³¹ pengidentifikasi selama masa pakai tabel. Nama tipe smallserial membuat kolom smallint .

Sintaksis

Penggunaan dasar SERIAL dataype adalah sebagai berikut -

CREATE TABLE tablename (
   colname SERIAL
);

Contoh

Pertimbangkan tabel PERUSAHAAN yang akan dibuat sebagai berikut -

testdb=# CREATE TABLE COMPANY(
   ID  SERIAL PRIMARY KEY,
   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 tujuh tupel ke dalam tabel COMPANY dan COMPANY akan memiliki record berikut -

id | name  | age | address    | salary
----+-------+-----+------------+--------
  1 | Paul  |  32 | California |  20000
  2 | Allen |  25 | Texas      |  15000
  3 | Teddy |  23 | Norway     |  20000
  4 | Mark  |  25 | Rich-Mond  |  65000
  5 | David |  27 | Texas      |  85000
  6 | Kim   |  22 | South-Hall |  45000
  7 | James |  24 | Houston    |  10000

Setiap kali sebuah objek dibuat dalam database, pemilik ditugaskan untuk itu. Pemiliknya biasanya adalah orang yang mengeksekusi pernyataan pembuatan. Untuk sebagian besar jenis objek, status awalnya adalah hanya pemilik (atau pengguna super) yang dapat mengubah atau menghapus objek. Untuk mengizinkan peran atau pengguna lain untuk menggunakannya, hak istimewa atau izin harus diberikan.

Berbagai jenis hak istimewa di PostgreSQL adalah -

SELECT,
INSERT,
UPDATE,
DELETE,
TRUNCATE,
REFERENCES,
TRIGGER,
CREATE,
CONNECT,
TEMPORARY,
LAKUKAN, dan
USAGE

Bergantung pada jenis objek (tabel, fungsi, dll.,), Hak istimewa diterapkan ke objek. Untuk menetapkan hak istimewa kepada pengguna, perintah GRANT digunakan.

Sintaks untuk GRANT

Sintaks dasar untuk perintah GRANT adalah sebagai berikut -

GRANT privilege [, ...]
ON object [, ...]
TO { PUBLIC | GROUP group | username }

privilege - nilai bisa berupa: SELECT, INSERT, UPDATE, DELETE, ATURAN, ALL.
object- Nama objek yang akan diberikan akses. Objek yang mungkin adalah: tabel, tampilan, urutan
PUBLIC - Bentuk singkat yang mewakili semua pengguna.
KELOMPOK group - Grup yang diberi hak istimewa.
username- Nama pengguna yang diberi hak istimewa. PUBLIK adalah bentuk singkat yang mewakili semua pengguna.

Hak istimewa dapat dicabut dengan menggunakan perintah REVOKE.

Sintaks untuk REVOKE

Sintaks dasar untuk perintah REVOKE adalah sebagai berikut -

REVOKE privilege [, ...]
ON object [, ...]
FROM { PUBLIC | GROUP groupname | username }

privilege - nilai bisa berupa: SELECT, INSERT, UPDATE, DELETE, ATURAN, ALL.
object- Nama objek yang akan diberikan akses. Objek yang mungkin adalah: tabel, tampilan, urutan
PUBLIC - Bentuk singkat yang mewakili semua pengguna.
KELOMPOK group - Grup yang diberi hak istimewa.
username- Nama pengguna yang diberi hak istimewa. PUBLIK adalah bentuk singkat yang mewakili semua pengguna.

Contoh

Untuk memahami hak istimewa, pertama-tama mari kita buat USER sebagai berikut -

testdb=# CREATE USER manisha WITH PASSWORD 'password';
CREATE ROLE

Pesan CREATE ROLE menunjukkan bahwa PENGGUNA "manisha" telah dibuat.

Pertimbangkan tabel PERUSAHAAN memiliki catatan sebagai berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Selanjutnya, mari kita berikan semua hak istimewa pada tabel PERUSAHAAN kepada pengguna "manisha" sebagai berikut -

testdb=# GRANT ALL ON COMPANY TO manisha;
GRANT

Pesan GRANT menunjukkan bahwa semua hak diberikan kepada USER.

Selanjutnya, mari kita cabut hak istimewa dari PENGGUNA "manisha" sebagai berikut -

testdb=# REVOKE ALL ON COMPANY FROM manisha;
REVOKE

Pesan REVOKE menunjukkan bahwa semua hak istimewa dicabut dari PENGGUNA.

Anda bahkan dapat menghapus pengguna sebagai berikut -

testdb=# DROP USER manisha;
DROP ROLE

Pesan DROP ROLE menunjukkan PENGGUNA 'Manisha' dihapus dari database.

Kita telah membahas tentang tipe data Tanggal / Waktu di bab Tipe Data . Sekarang, mari kita lihat operator Tanggal / Waktu dan Fungsi.

Tabel berikut mencantumkan perilaku operator aritmatika dasar -

Operator	Contoh	Hasil
+	tanggal '2001-09-28' + integer '7'	tanggal '2001-10-05'
+	tanggal '2001-09-28' + interval '1 jam'	cap waktu '2001-09-28 01:00:00'
+	tanggal '2001-09-28' + waktu '03: 00 '	cap waktu '2001-09-28 03:00:00'
+	interval '1 hari' + interval '1 jam'	interval '1 hari 01:00:00'
+	timestamp '2001-09-28 01:00' + interval '23 jam '	cap waktu '2001-09-29 00:00:00'
+	waktu '01: 00 '+ interval' 3 jam '	waktu '04: 00: 00 '
-	- interval '23 jam '	interval '-23: 00: 00'
-	tanggal '2001-10-01' - tanggal '2001-09-28'	integer '3' (hari)
-	tanggal '2001-10-01' - integer '7'	tanggal '2001-09-24'
-	tanggal '2001-09-28' - interval '1 jam'	cap waktu '2001-09-27 23:00:00'
-	waktu '05: 00 '- waktu '03: 00'	interval '02: 00: 00 '
-	waktu '05: 00 '- interval' 2 jam '	waktu '03: 00: 00 '
-	cap waktu '2001-09-28 23:00' - interval '23 jam '	cap waktu '2001-09-28 00:00:00'
-	interval '1 hari' - interval '1 jam'	interval '1 hari -01: 00: 00'
-	timestamp '2001-09-29 03:00' - timestamp '2001-09-27 12:00'	interval '1 hari 15.00.00'
*	900 * interval '1 detik'	interval '00: 15: 00 '
*	21 * interval '1 hari'	interval '21 hari '
*	presisi ganda '3,5' * interval '1 jam'	interval '03: 30: 00 '
/	interval '1 jam' / presisi ganda '1,5'	interval '00: 40: 00 '

Berikut ini adalah daftar semua fungsi penting terkait Tanggal dan Waktu yang tersedia.

No. S.	Deskripsi fungsi
1	USIA() Kurangi argumen
2	TANGGAL / WAKTU SAAT INI () Tanggal dan waktu saat ini
3	DATE_PART () Dapatkan subbidang (setara dengan ekstrak)
4	EKSTRAK() Dapatkan subbidang
5	ISFINITE () Tes untuk tanggal, waktu dan interval terbatas (bukan +/- tak terhingga)
6	MEMBENARKAN Sesuaikan interval

AGE (cap waktu, cap waktu), AGE (cap waktu)

No. S.	Deskripsi fungsi
1	AGE(timestamp, timestamp) Saat dipanggil dengan bentuk TIMESTAMP dari argumen kedua, AGE () mengurangi argumen, menghasilkan hasil "simbolis" yang menggunakan tahun dan bulan dan berjenis INTERVAL.
2	AGE(timestamp) Ketika dipanggil dengan hanya TIMESTAMP sebagai argumen, AGE () mengurangi dari current_date (pada tengah malam).

Contoh fungsi AGE (timestamp, timestamp) adalah -

testdb=# SELECT AGE(timestamp '2001-04-10', timestamp '1957-06-13');

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

age
-------------------------
 43 years 9 mons 27 days

Contoh fungsi AGE (timestamp) adalah -

testdb=# select age(timestamp '1957-06-13');

Pernyataan PostgreSQL yang diberikan di atas akan menghasilkan hasil sebagai berikut -

age
--------------------------
 55 years 10 mons 22 days

TANGGAL / WAKTU SAAT INI ()

PostgreSQL menyediakan sejumlah fungsi yang mengembalikan nilai yang terkait dengan tanggal dan waktu saat ini. Berikut adalah beberapa fungsi -

No. S.	Deskripsi fungsi
1	CURRENT_DATE Memberikan tanggal sekarang.
2	CURRENT_TIME Memberikan nilai dengan zona waktu.
3	CURRENT_TIMESTAMP Memberikan nilai dengan zona waktu.
4	CURRENT_TIME(precision) Secara opsional, mengambil parameter presisi, yang menyebabkan hasil dibulatkan ke banyak digit pecahan di bidang detik.
5	CURRENT_TIMESTAMP(precision) Secara opsional, mengambil parameter presisi, yang menyebabkan hasil dibulatkan ke banyak digit pecahan di bidang detik.
6	LOCALTIME Memberikan nilai tanpa zona waktu.
7	LOCALTIMESTAMP Memberikan nilai tanpa zona waktu.
8	LOCALTIME(precision) Secara opsional, mengambil parameter presisi, yang menyebabkan hasil dibulatkan ke banyak digit pecahan di bidang detik.
9	LOCALTIMESTAMP(precision) Secara opsional, mengambil parameter presisi, yang menyebabkan hasil dibulatkan ke banyak digit pecahan di bidang detik.

Contoh menggunakan fungsi dari tabel di atas -

testdb=# SELECT CURRENT_TIME;
       timetz
--------------------
 08:01:34.656+05:30
(1 row)


testdb=# SELECT CURRENT_DATE;
    date
------------
 2013-05-05
(1 row)


testdb=# SELECT CURRENT_TIMESTAMP;
              now
-------------------------------
 2013-05-05 08:01:45.375+05:30
(1 row)


testdb=# SELECT CURRENT_TIMESTAMP(2);
         timestamptz
------------------------------
 2013-05-05 08:01:50.89+05:30
(1 row)


testdb=# SELECT LOCALTIMESTAMP;
       timestamp
------------------------
 2013-05-05 08:01:55.75
(1 row)

PostgreSQL juga menyediakan fungsi yang mengembalikan waktu mulai dari pernyataan saat ini, serta waktu aktual saat ini pada saat fungsi tersebut dipanggil. Fungsi-fungsi ini adalah -

No. S.	Deskripsi fungsi
1	transaction_timestamp() Ini setara dengan CURRENT_TIMESTAMP, tetapi dinamai untuk secara jelas mencerminkan apa yang dikembalikannya.
2	statement_timestamp() Ini mengembalikan waktu mulai dari pernyataan saat ini.
3	clock_timestamp() Ini mengembalikan waktu aktual saat ini, dan oleh karena itu nilainya berubah bahkan dalam satu perintah SQL.
4	timeofday() Ini mengembalikan waktu aktual saat ini, tetapi sebagai string teks yang diformat daripada stempel waktu dengan nilai zona waktu.
5	now() Ini adalah PostgreSQL tradisional yang setara dengan transaction_timestamp ().

DATE_PART (teks, stempel waktu), DATE_PART (teks, interval), DATE_TRUNC (teks, stempel waktu)

No. S.	Deskripsi fungsi
1	DATE_PART('field', source) Fungsi-fungsi ini mendapatkan subbidang. The lapangan parameter perlu menjadi nilai string, bukan nama. Nama bidang yang valid adalah: abad, hari, dekade, dow, doy, epoch, jam, isodow, isoyear, mikrodetik, milenium, milidetik, menit, bulan, kuartal, detik, zona waktu, zona_jam waktu, zona_minute, minggu, tahun.
2	DATE_TRUNC('field', source) Fungsi ini secara konseptual mirip dengan fungsi pemotongan angka. source adalah ekspresi nilai dari tipe timestamp atau interval. bidang memilih presisi mana untuk memotong nilai input. Nilai yang dikembalikan adalah tipe timestamp atau interval . Nilai yang valid untuk bidang adalah: mikrodetik, milidetik, detik, menit, jam, hari, minggu, bulan, kuartal, tahun, dekade, abad, milenium

Berikut ini adalah contoh untuk fungsi DATE_PART ( 'field' , source) -

testdb=# SELECT date_part('day', TIMESTAMP '2001-02-16 20:38:40');
 date_part
-----------
        16
(1 row)


testdb=# SELECT date_part('hour', INTERVAL '4 hours 3 minutes');
 date_part
-----------
         4
(1 row)

Berikut ini adalah contoh untuk fungsi DATE_TRUNC ( 'field' , source) -

testdb=# SELECT date_trunc('hour', TIMESTAMP '2001-02-16 20:38:40');
     date_trunc
---------------------
 2001-02-16 20:00:00
(1 row)


testdb=# SELECT date_trunc('year', TIMESTAMP '2001-02-16 20:38:40');
     date_trunc
---------------------
 2001-01-01 00:00:00
(1 row)

EKSTRAK (bidang dari cap waktu), EKSTRAK (bidang dari interval)

Itu EXTRACT(field FROM source)fungsi mengambil subbidang seperti tahun atau jam dari nilai tanggal / waktu. The Sumber harus ekspresi nilai tipe timestamp, waktu, atau selang . The lapangan adalah identifier atau string yang menyeleksi apa lapangan untuk ekstrak dari nilai sumber. Fungsi EXTRACT mengembalikan nilai tipe presisi ganda .

Berikut ini adalah nama bidang yang valid (mirip dengan nama bidang fungsi DATE_PART): abad, hari, dekade, dow, doy, epoch, jam, isodow, isoyear, mikrodetik, milenium, milidetik, menit, bulan, kuartal, detik, zona waktu, zona waktu_jam , timezone_minute, minggu, tahun.

Berikut ini adalah contoh fungsi EXTRACT ( 'field' , source) -

testdb=# SELECT EXTRACT(CENTURY FROM TIMESTAMP '2000-12-16 12:21:13');
 date_part
-----------
        20
(1 row)


testdb=# SELECT EXTRACT(DAY FROM TIMESTAMP '2001-02-16 20:38:40');
 date_part
-----------
        16
(1 row)

ISFINITE (tanggal), ISFINITE (stempel waktu), ISFINITE (interval)

No. S.	Deskripsi fungsi
1	ISFINITE(date) Tes untuk tanggal terbatas.
2	ISFINITE(timestamp) Tes untuk cap waktu terbatas.
3	ISFINITE(interval) Tes untuk interval terbatas.

Berikut ini adalah contoh dari fungsi ISFINITE () -

testdb=# SELECT isfinite(date '2001-02-16');
 isfinite
----------
 t
(1 row)


testdb=# SELECT isfinite(timestamp '2001-02-16 21:28:30');
 isfinite
----------
 t
(1 row)


testdb=# SELECT isfinite(interval '4 hours');
 isfinite
----------
 t
(1 row)

JUSTIFY_DAYS (interval), JUSTIFY_HOURS (interval), JUSTIFY_INTERVAL (interval)

No. S.	Deskripsi fungsi
1	JUSTIFY_DAYS(interval) Menyesuaikan interval sehingga jangka waktu 30 hari direpresentasikan sebagai bulan. Kembalikaninterval Tipe
2	JUSTIFY_HOURS(interval) Menyesuaikan interval sehingga jangka waktu 24 jam direpresentasikan sebagai hari. Kembalikaninterval Tipe
3	JUSTIFY_INTERVAL(interval) Sesuaikan interval menggunakan JUSTIFY_DAYS dan JUSTIFY_HOURS, dengan penyesuaian tanda tambahan. Kembalikaninterval Tipe

Berikut ini adalah contoh untuk fungsi ISFINITE () -

testdb=# SELECT justify_days(interval '35 days');
 justify_days
--------------
 1 mon 5 days
(1 row)


testdb=# SELECT justify_hours(interval '27 hours');
 justify_hours
----------------
 1 day 03:00:00
(1 row)


testdb=# SELECT justify_interval(interval '1 mon -1 hour');
 justify_interval
------------------
 29 days 23:00:00
(1 row)

PostgreSQL functions, juga dikenal sebagai Prosedur Tersimpan, memungkinkan Anda menjalankan operasi yang biasanya mengambil beberapa kueri dan perjalanan bolak-balik dalam satu fungsi dalam database. Fungsi memungkinkan penggunaan kembali database karena aplikasi lain dapat berinteraksi langsung dengan prosedur tersimpan Anda, bukan kode tingkat menengah atau duplikat.

Fungsi dapat dibuat dalam bahasa pilihan Anda seperti SQL, PL / pgSQL, C, Python, dll.

Sintaksis

Sintaks dasar untuk membuat fungsi adalah sebagai berikut -

CREATE [OR REPLACE] FUNCTION function_name (arguments) 
RETURNS return_datatype AS $variable_name$
   DECLARE
      declaration;
      [...]
   BEGIN
      < function_body >
      [...]
      RETURN { variable_name | value }
   END; LANGUAGE plpgsql;

Dimana,

function-name menentukan nama fungsi.
Opsi [ATAU GANTI] memungkinkan modifikasi fungsi yang ada.
Fungsi tersebut harus mengandung a return pernyataan.
RETURNklausa menentukan bahwa tipe data yang akan Anda kembalikan dari fungsi. Itureturn_datatype dapat berupa basis, komposit, atau tipe domain, atau dapat merujuk pada tipe kolom tabel.
function-body berisi bagian yang dapat dieksekusi.
Kata kunci AS digunakan untuk membuat fungsi mandiri.
plpgsqladalah nama bahasa di mana fungsi diimplementasikan. Di sini, kami menggunakan opsi ini untuk PostgreSQL, Bisa SQL, C, internal, atau nama bahasa prosedural yang ditentukan pengguna. Untuk kompatibilitas mundur, nama dapat diapit oleh tanda kutip tunggal.

Contoh

Contoh berikut mengilustrasikan pembuatan dan pemanggilan fungsi mandiri. Fungsi ini mengembalikan jumlah total rekaman dalam tabel PERUSAHAAN. Kami akan menggunakan tabel PERUSAHAAN , yang memiliki catatan berikut -

testdb# select * from COMPANY;
 id | name  | age | address   | salary
----+-------+-----+-----------+--------
  1 | Paul  |  32 | California|  20000
  2 | Allen |  25 | Texas     |  15000
  3 | Teddy |  23 | Norway    |  20000
  4 | Mark  |  25 | Rich-Mond |  65000
  5 | David |  27 | Texas     |  85000
  6 | Kim   |  22 | South-Hall|  45000
  7 | James |  24 | Houston   |  10000
(7 rows)

Fungsi totalRecords () adalah sebagai berikut -

CREATE OR REPLACE FUNCTION totalRecords ()
RETURNS integer AS $total$
declare
	total integer;
BEGIN
   SELECT count(*) into total FROM COMPANY;
   RETURN total;
END;
$total$ LANGUAGE plpgsql;

Ketika query di atas dijalankan, hasilnya adalah -

testdb# CREATE FUNCTION

Sekarang, mari kita jalankan panggilan ke fungsi ini dan periksa record di tabel COMPANY

testdb=# select totalRecords();

Ketika query di atas dijalankan, hasilnya adalah -

totalrecords
--------------
      7
(1 row)

Fungsi bawaan PostgreSQL, juga disebut sebagai fungsi Agregat, digunakan untuk melakukan pemrosesan pada data string atau numerik.

Berikut ini adalah daftar semua fungsi bawaan PostgreSQL tujuan umum -

Fungsi PostgreSQL COUNT - Fungsi agregat PostgreSQL COUNT digunakan untuk menghitung jumlah baris dalam tabel database.
Fungsi PostgreSQL MAX - Fungsi agregat PostgreSQL MAX memungkinkan kita untuk memilih nilai tertinggi (maksimum) untuk kolom tertentu.
Fungsi PostgreSQL MIN - Fungsi agregat PostgreSQL MIN memungkinkan kita untuk memilih nilai terendah (minimum) untuk kolom tertentu.
Fungsi AVG PostgreSQL - Fungsi agregat AVG PostgreSQL memilih nilai rata-rata untuk kolom tabel tertentu.
Fungsi SUM PostgreSQL - Fungsi agregat SUM PostgreSQL memungkinkan memilih total untuk kolom numerik.
Fungsi ARRAY PostgreSQL - Fungsi agregat ARRAY PostgreSQL menempatkan nilai input, termasuk null, digabungkan ke dalam array.
Fungsi Numerik PostgreSQL - Daftar lengkap fungsi PostgreSQL yang diperlukan untuk memanipulasi angka dalam SQL.
Fungsi String PostgreSQL - Daftar lengkap fungsi PostgreSQL yang diperlukan untuk memanipulasi string di PostgreSQL.

Tutorial ini akan digunakan libpqxxlibrary, yang merupakan API klien C ++ resmi untuk PostgreSQL. Kode sumber libpqxx tersedia di bawah lisensi BSD, jadi Anda bebas mengunduhnya, menyebarkannya kepada orang lain, mengubahnya, menjualnya, memasukkannya ke dalam kode Anda sendiri, dan membagikan perubahan Anda dengan siapa pun yang Anda pilih.

Instalasi

Versi terbaru libpqxx tersedia untuk diunduh dari tautan Unduh Libpqxx . Jadi unduh versi terbaru dan ikuti langkah-langkah berikut -

wget http://pqxx.org/download/software/libpqxx/libpqxx-4.0.tar.gz
tar xvfz libpqxx-4.0.tar.gz
cd libpqxx-4.0
./configure
make
make install

Sebelum Anda mulai menggunakan antarmuka C / C ++ PostgreSQL, temukan file pg_hba.conf file di direktori instalasi PostgreSQL Anda dan tambahkan baris berikut -

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Anda dapat memulai / memulai ulang server postgres jika tidak berjalan menggunakan perintah berikut -

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

C / C ++ Interface API

Berikut ini adalah rutinitas antarmuka penting yang dapat mencukupi kebutuhan Anda untuk bekerja dengan database PostgreSQL dari program C / C ++ Anda. Jika Anda mencari aplikasi yang lebih canggih maka Anda dapat melihat dokumentasi resmi libpqxx, atau Anda dapat menggunakan API yang tersedia secara komersial.

No. S.	API & Deskripsi
1	pqxx::connection C( const std::string & dbstring ) Ini adalah typedef yang akan digunakan untuk terhubung ke database. Di sini, dbstring menyediakan parameter yang diperlukan untuk terhubung ke database, misalnyadbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432. Jika koneksi berhasil diatur maka itu membuat C dengan objek koneksi yang menyediakan berbagai fungsi fungsi publik yang berguna.
2	C.is_open() Metode is_open () adalah metode publik dari objek koneksi dan mengembalikan nilai boolean. Jika koneksi aktif, maka metode ini mengembalikan nilai true jika tidak mengembalikan salah.
3	C.disconnect() Metode ini digunakan untuk memutuskan koneksi database yang dibuka.
4	pqxx::work W( C ) Ini adalah typedef yang akan digunakan untuk membuat objek transaksional menggunakan koneksi C, yang pada akhirnya akan digunakan untuk mengeksekusi pernyataan SQL dalam mode transaksional. Jika objek transaksi berhasil dibuat, maka itu ditugaskan ke variabel W yang akan digunakan untuk mengakses metode publik yang terkait dengan objek transaksional.
5	W.exec(const std::string & sql) Metode publik dari objek transaksional ini akan digunakan untuk menjalankan pernyataan SQL.
6	W.commit() Metode publik dari objek transaksional ini akan digunakan untuk melakukan transaksi.
7	W.abort() Metode publik dari objek transaksional ini akan digunakan untuk mengembalikan transaksi.
8	pqxx::nontransaction N( C ) Ini adalah typedef yang akan digunakan untuk membuat objek non-transaksional menggunakan koneksi C, yang pada akhirnya akan digunakan untuk mengeksekusi pernyataan SQL dalam mode non-transaksional. Jika objek transaksi berhasil dibuat, maka itu ditetapkan ke variabel N yang akan digunakan untuk mengakses metode publik yang terkait dengan objek non-transaksional.
9	N.exec(const std::string & sql) Metode publik dari objek non-transaksional ini akan digunakan untuk mengeksekusi pernyataan SQL dan mengembalikan objek hasil yang sebenarnya merupakan interator yang memegang semua catatan yang dikembalikan.

Menghubungkan ke Database

Segmen kode C berikut menunjukkan cara menyambung ke database yang ada yang berjalan pada mesin lokal di port 5432. Di sini, saya menggunakan garis miring terbalik \ untuk kelanjutan baris.

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }
}

Sekarang, mari kita kompilasi dan jalankan program di atas untuk terhubung ke database kita testdb, yang sudah tersedia di skema Anda dan dapat diakses menggunakan user postgres dan password pass123 .

Anda dapat menggunakan ID pengguna dan kata sandi berdasarkan pengaturan database Anda. Ingatlah untuk menyimpan -lpqxx dan -lpq dalam urutan yang ditentukan! Jika tidak, penaut akan mengeluh dengan getir tentang fungsi yang hilang dengan nama yang dimulai dengan "PQ".

$g++ test.cpp -lpqxx -lpq $./a.out
Opened database successfully: testdb

Buat Tabel

Segmen kode C berikut akan digunakan untuk membuat tabel di database yang dibuat sebelumnya -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* 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 );";

      /* Create a transactional object. */
      work W(C);
      
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Table created successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Ketika program yang diberikan di atas dikompilasi dan dijalankan, itu akan membuat tabel PERUSAHAAN di database testdb Anda dan akan menampilkan pernyataan berikut -

Opened database successfully: testdb
Table created successfully

Operasi INSERT

Segmen kode C berikut menunjukkan bagaimana kita dapat membuat catatan dalam tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* 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 );";

      /* Create a transactional object. */
      work W(C);
      
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records created successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Ketika program yang diberikan di atas dikompilasi dan dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut -

Opened database successfully: testdb
Records created successfully

PILIH Operasi

Segmen kode C berikut menunjukkan bagaimana kita dapat mengambil dan menampilkan catatan dari tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }

      /* Create SQL statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Ketika program yang diberikan di atas dikompilasi dan dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully: testdb
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 20000
ID = 2
Name = Allen
Age = 25
Address = Texas
Salary = 15000
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
Operation done successfully

UPDATE 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 kami -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      
      /* Create a transactional object. */
      work W(C);
      /* Create  SQL UPDATE statement */
      sql = "UPDATE COMPANY set SALARY = 25000.00 where ID=1";
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records updated successfully" << endl;
      
      /* Create SQL SELECT statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Ketika program yang diberikan di atas dikompilasi dan dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully: testdb
Records updated successfully
ID = 2
Name = Allen
Age = 25
Address = Texas
Salary = 15000
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 25000
Operation done successfully

HAPUS Operasi

Segmen kode C berikut menunjukkan bagaimana kita dapat menggunakan pernyataan DELETE untuk menghapus catatan apa pun dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN kita -

#include <iostream>
#include <pqxx/pqxx> 

using namespace std;
using namespace pqxx;

int main(int argc, char* argv[]) {
   char * sql;
   
   try {
      connection C("dbname = testdb user = postgres password = cohondob \
      hostaddr = 127.0.0.1 port = 5432");
      if (C.is_open()) {
         cout << "Opened database successfully: " << C.dbname() << endl;
      } else {
         cout << "Can't open database" << endl;
         return 1;
      }
      
      /* Create a transactional object. */
      work W(C);
      /* Create  SQL DELETE statement */
      sql = "DELETE from COMPANY where ID = 2";
      /* Execute SQL query */
      W.exec( sql );
      W.commit();
      cout << "Records deleted successfully" << endl;
      
      /* Create SQL SELECT statement */
      sql = "SELECT * from COMPANY";

      /* Create a non-transactional object. */
      nontransaction N(C);
      
      /* Execute SQL query */
      result R( N.exec( sql ));
      
      /* List down all the records */
      for (result::const_iterator c = R.begin(); c != R.end(); ++c) {
         cout << "ID = " << c[0].as<int>() << endl;
         cout << "Name = " << c[1].as<string>() << endl;
         cout << "Age = " << c[2].as<int>() << endl;
         cout << "Address = " << c[3].as<string>() << endl;
         cout << "Salary = " << c[4].as<float>() << endl;
      }
      cout << "Operation done successfully" << endl;
      C.disconnect ();
   } catch (const std::exception &e) {
      cerr << e.what() << std::endl;
      return 1;
   }

   return 0;
}

Ketika program yang diberikan di atas dikompilasi dan dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully: testdb
Records deleted successfully
ID = 3
Name = Teddy
Age = 23
Address = Norway
Salary = 20000
ID = 4
Name = Mark
Age = 25
Address = Rich-Mond
Salary = 65000
ID = 1
Name = Paul
Age = 32
Address = California
Salary = 25000
Operation done successfully

Instalasi

Sebelum kita mulai menggunakan PostgreSQL di program Java kita, kita perlu memastikan bahwa kita memiliki PostgreSQL JDBC dan Java yang disiapkan di mesin. Anda dapat memeriksa tutorial Java untuk instalasi Java di komputer Anda. Sekarang mari kita periksa cara mengatur driver JDBC PostgreSQL.

Unduh versi terbaru postgresql- (VERSION) .jdbc.jar dari repositori postgresql-jdbc .
Tambahkan file jar yang diunduh postgresql- (VERSION) .jdbc.jar di jalur kelas Anda, atau Anda dapat menggunakannya bersama dengan opsi -classpath seperti yang dijelaskan di bawah dalam contoh.

Bagian berikut mengasumsikan Anda memiliki sedikit pengetahuan tentang konsep Java JDBC. Jika Anda tidak punya, maka disarankan untuk menghabiskan setengah jam dengan Tutorial JDBC agar terbiasa dengan konsep yang dijelaskan di bawah ini.

Menghubungkan ke Database

Kode 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.Connection;
import java.sql.DriverManager;

public class PostgreSQLJDBC {
   public static void main(String args[]) {
      Connection c = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "postgres", "123");
      } catch (Exception e) {
         e.printStackTrace();
         System.err.println(e.getClass().getName()+": "+e.getMessage());
         System.exit(0);
      }
      System.out.println("Opened database successfully");
   }
}

Sebelum Anda mengkompilasi dan menjalankan program di atas, temukan pg_hba.conf file di direktori instalasi PostgreSQL Anda dan tambahkan baris berikut -

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Anda dapat memulai / memulai ulang server postgres jika tidak berjalan menggunakan perintah berikut -

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Sekarang, mari kita kompilasi dan jalankan program di atas untuk terhubung dengan testdb. Di sini, kami menggunakanpostgres sebagai ID pengguna dan 123sebagai kata sandi untuk mengakses database. Anda dapat mengubahnya sesuai konfigurasi dan pengaturan database Anda. Kami juga mengasumsikan versi driver JDBC saat inipostgresql-9.2-1002.jdbc3.jar tersedia di jalur saat ini.

C:\JavaPostgresIntegration>javac PostgreSQLJDBC.java
C:\JavaPostgresIntegration>java -cp c:\tools\postgresql-9.2-1002.jdbc3.jar;C:\JavaPostgresIntegration PostgreSQLJDBC
Open database successfully

Buat Tabel

Program Java berikut akan digunakan untuk membuat tabel pada database yang dibuka sebelumnya. Pastikan Anda belum memiliki tabel ini di database target Anda.

import java.sql.*;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;


public class PostgreSQLJDBC {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         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 sebuah program dikompilasi dan dijalankan, itu akan membuat tabel PERUSAHAAN di testdb database dan akan menampilkan dua baris berikut -

Opened database successfully
Table created successfully

Operasi INSERT

Program Java berikut menunjukkan bagaimana kita dapat membuat catatan dalam tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class PostgreSQLJDBC {
   public static void main(String args[]) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         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 successfully

PILIH Operasi

Program Java berikut menunjukkan bagaimana kita dapat mengambil dan menampilkan catatan dari tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;


public class PostgreSQLJDBC {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         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 dikompilasi dan dijalankan, itu 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 successfully

UPDATE Operasi

Kode Java berikut menunjukkan bagaimana kita dapat menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN kita -

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;


public class PostgreSQLJDBC {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         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 dikompilasi dan dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully
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

ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0

Operation done successfully

HAPUS Operasi

Kode Java berikut menunjukkan bagaimana kita dapat menggunakan pernyataan DELETE untuk menghapus catatan apa pun dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN kita -

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.Statement;


public class PostgreSQLJDBC6 {
   public static void main( String args[] ) {
      Connection c = null;
      Statement stmt = null;
      try {
         Class.forName("org.postgresql.Driver");
         c = DriverManager
            .getConnection("jdbc:postgresql://localhost:5432/testdb",
            "manisha", "123");
         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 dikompilasi dan dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully
ID = 3
NAME = Teddy
AGE = 23
ADDRESS = Norway
SALARY = 20000.0

ID = 4
NAME = Mark
AGE = 25
ADDRESS = Rich-Mond
SALARY = 65000.0

ID = 1
NAME = Paul
AGE = 32
ADDRESS = California
SALARY = 25000.0
Operation done successfully

Instalasi

Ekstensi PostgreSQL diaktifkan secara default di rilis terbaru PHP 5.3.x. Dimungkinkan untuk menonaktifkannya dengan menggunakan--without-pgsqlpada waktu kompilasi. Anda masih dapat menggunakan perintah yum untuk menginstal antarmuka PHP-PostgreSQL -

yum install php-pgsql

Sebelum Anda mulai menggunakan antarmuka PHP PostgreSQL, cari file pg_hba.conf file di direktori instalasi PostgreSQL Anda dan tambahkan baris berikut -

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Anda dapat memulai / memulai ulang server postgres, jika tidak berjalan, gunakan perintah berikut -

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

Pengguna Windows harus mengaktifkan php_pgsql.dll untuk menggunakan ekstensi ini. DLL ini disertakan dengan distribusi Windows dalam rilis terbaru PHP 5.3.x

Untuk instruksi instalasi terperinci, silakan periksa tutorial PHP kami dan situs resminya.

API Antarmuka PHP

Berikut ini adalah rutinitas PHP yang penting, yang dapat mencukupi kebutuhan Anda untuk bekerja dengan database PostgreSQL dari program PHP Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi PHP.

No. S.	API & Deskripsi
1	resource pg_connect ( string $connection_string [, int $connect_type ] ) Ini membuka koneksi ke database PostgreSQL yang ditentukan oleh connection_string. Jika PGSQL_CONNECT_FORCE_NEW diteruskan sebagai connect_type, maka koneksi baru dibuat jika panggilan kedua ke pg_connect (), meskipun connection_string identik dengan koneksi yang ada.
2	bool pg_connection_reset ( resource $connection ) Rutinitas ini mengatur ulang koneksi. Ini berguna untuk pemulihan kesalahan. Mengembalikan TRUE pada kesuksesan atau FALSE pada kegagalan.
3	int pg_connection_status ( resource $connection ) Rutinitas ini mengembalikan status koneksi yang ditentukan. Menampilkan PGSQL_CONNECTION_OK atau PGSQL_CONNECTION_BAD.
4	string pg_dbname ([ resource $connection ] ) Rutinitas ini mengembalikan nama database yang diberikan sumber koneksi PostgreSQL.
5	resource pg_prepare ([ resource $connection ], string $stmtname, string $query ) Ini mengajukan permintaan untuk membuat pernyataan yang disiapkan dengan parameter yang diberikan dan menunggu sampai selesai.
6	resource pg_execute ([ resource $connection ], string $stmtname, array $params ) Rutin ini mengirimkan permintaan untuk mengeksekusi pernyataan yang telah disiapkan dengan parameter yang diberikan dan menunggu hasilnya.
7	resource pg_query ([ resource $connection ], string $query ) Rutinitas ini mengeksekusi query pada koneksi database yang ditentukan.
8	array pg_fetch_row ( resource $result [, int $row ] ) Rutinitas ini mengambil satu baris data dari hasil yang terkait dengan sumber daya hasil yang ditentukan.
9	array pg_fetch_all ( resource $result ) Rutinitas ini mengembalikan larik yang berisi semua baris (catatan) dalam sumber daya hasil.
10	int pg_affected_rows ( resource $result ) Rutinitas ini mengembalikan jumlah baris yang dipengaruhi oleh kueri INSERT, UPDATE, dan DELETE.
11	int pg_num_rows ( resource $result ) Rutinitas ini mengembalikan jumlah baris dalam sumber hasil PostgreSQL misalnya jumlah baris yang dikembalikan oleh pernyataan SELECT.
12	bool pg_close ([ resource $connection ] ) Rutinitas ini menutup koneksi non-persisten ke database PostgreSQL yang terkait dengan sumber koneksi yang diberikan.
13	string pg_last_error ([ resource $connection ] ) Rutinitas ini mengembalikan pesan kesalahan terakhir untuk koneksi yang diberikan.
14	string pg_escape_literal ([ resource $connection ], string $data ) Rutinitas ini mengesampingkan literal untuk dimasukkan ke dalam bidang teks.
15	string pg_escape_string ([ resource $connection ], string $data ) Rutinitas ini lolos dari string untuk melakukan kueri database.

Menghubungkan ke Database

Kode PHP berikut menunjukkan cara menyambungkan ke database yang ada di mesin lokal dan akhirnya objek koneksi database akan dikembalikan.

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }
?>

Sekarang, mari kita jalankan program yang diberikan di atas untuk membuka database kita testdb: jika database berhasil dibuka, maka akan muncul pesan berikut -

Opened database successfully

Buat Tabel

Program PHP berikut akan digunakan untuk membuat tabel dalam database yang dibuat sebelumnya -

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } 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 = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
   } else {
      echo "Table created successfully\n";
   }
   pg_close($db);
?>

Ketika program yang diberikan di atas dijalankan, itu akan membuat tabel PERUSAHAAN di Anda testdb dan itu akan menampilkan pesan berikut -

Opened database successfully
Table created successfully

Operasi INSERT

Program PHP berikut menunjukkan bagaimana kita dapat membuat catatan dalam tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

<?php
   $host        = "host=127.0.0.1";
   $port = "port=5432"; $dbname      = "dbname = testdb";
   $credentials = "user = postgres password=pass123"; $db = pg_connect( "$host $port $dbname $credentials"  );
   if(!$db) { echo "Error : Unable to open database\n"; } 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 = pg_query($db, $sql); if(!$ret) {
      echo pg_last_error($db); } else { echo "Records created successfully\n"; } pg_close($db);
?>

Ketika program yang diberikan di atas dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut -

Opened database successfully
Records created successfully

PILIH Operasi

Program PHP berikut menunjukkan bagaimana kita dapat mengambil dan menampilkan catatan dari tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }

   $sql =<<<EOF SELECT * from COMPANY; EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
      exit;
   } 
   while($row = pg_fetch_row($ret)) {
      echo "ID = ". $row[0] . "\n"; echo "NAME = ". $row[1] ."\n";
      echo "ADDRESS = ". $row[2] ."\n"; echo "SALARY = ".$row[4] ."\n\n";
   }
   echo "Operation done successfully\n";
   pg_close($db);
?>

Ketika program yang diberikan di atas dijalankan, itu akan menghasilkan hasil sebagai berikut. Ingatlah bahwa bidang dikembalikan dalam urutan yang mereka gunakan saat membuat tabel.

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 successfully

UPDATE Operasi

Kode PHP berikut menunjukkan bagaimana kita dapat menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN kita -

<?php
   $host        = "host=127.0.0.1";
   $port = "port=5432"; $dbname      = "dbname = testdb";
   $credentials = "user = postgres password=pass123"; $db = pg_connect( "$host $port $dbname $credentials"  );
   if(!$db) { echo "Error : Unable to open database\n"; } else { echo "Opened database successfully\n"; } $sql =<<<EOF
      UPDATE COMPANY set SALARY = 25000.00 where ID=1;
EOF;
   $ret = pg_query($db, $sql); if(!$ret) {
      echo pg_last_error($db); exit; } else { echo "Record updated successfully\n"; } $sql =<<<EOF
      SELECT * from COMPANY;
EOF;

   $ret = pg_query($db, $sql); if(!$ret) {
      echo pg_last_error($db); exit; } while($row = pg_fetch_row($ret)) { echo "ID = ". $row[0] . "\n";
      echo "NAME = ". $row[1] ."\n"; echo "ADDRESS = ". $row[2] ."\n";
      echo "SALARY =  ".$row[4] ."\n\n"; } echo "Operation done successfully\n"; pg_close($db);
?>

Ketika program yang diberikan di atas dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully
Record updated successfully
ID = 2
NAME = Allen
ADDRESS = 25
SALARY =  15000

ID = 3
NAME = Teddy
ADDRESS = 23
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = 25
SALARY =  65000

ID = 1
NAME = Paul
ADDRESS = 32
SALARY =  25000

Operation done successfully

HAPUS Operasi

Kode PHP berikut menunjukkan bagaimana kita dapat menggunakan pernyataan DELETE untuk menghapus catatan apa pun dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN kita -

<?php
   $host = "host = 127.0.0.1"; $port        = "port = 5432";
   $dbname = "dbname = testdb"; $credentials = "user = postgres password=pass123";

   $db = pg_connect( "$host $port $dbname $credentials" ); if(!$db) {
      echo "Error : Unable to open database\n";
   } else {
      echo "Opened database successfully\n";
   }
   $sql =<<<EOF DELETE from COMPANY where ID=2; EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
      exit;
   } else {
      echo "Record deleted successfully\n";
   }
   
   $sql =<<<EOF SELECT * from COMPANY; EOF; $ret = pg_query($db, $sql);
   if(!$ret) { echo pg_last_error($db);
      exit;
   } 
   while($row = pg_fetch_row($ret)) {
      echo "ID = ". $row[0] . "\n"; echo "NAME = ". $row[1] ."\n";
      echo "ADDRESS = ". $row[2] ."\n"; echo "SALARY = ".$row[4] ."\n\n";
   }
   echo "Operation done successfully\n";
   pg_close($db);
?>

Ketika program yang diberikan di atas dijalankan, itu akan menghasilkan hasil sebagai berikut -

Opened database successfully
Record deleted successfully
ID = 3
NAME = Teddy
ADDRESS = 23
SALARY =  20000

ID = 4
NAME = Mark
ADDRESS = 25
SALARY =  65000

ID = 1
NAME = Paul
ADDRESS = 32
SALARY =  25000

Operation done successfully

Instalasi

PostgreSQL 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 install

Jika Anda perlu menginstal driver SQLite untuk DBI, maka dapat diinstal sebagai berikut -

$ wget http://search.cpan.org/CPAN/authors/id/T/TU/TURNSTEP/DBD-Pg-2.19.3.tar.gz
$ tar xvfz DBD-Pg-2.19.3.tar.gz $ cd DBD-Pg-2.19.3
$ perl Makefile.PL $ make
$ make install

Sebelum Anda mulai menggunakan antarmuka Perl PostgreSQL, temukan file pg_hba.conf file di direktori instalasi PostgreSQL Anda dan tambahkan baris berikut -

# IPv4 local connections:
host    all         all         127.0.0.1/32          md5

Anda dapat memulai / memulai ulang server postgres, jika tidak berjalan, gunakan perintah berikut -

[root@host]# service postgresql restart
Stopping postgresql service:                               [  OK  ]
Starting postgresql service:                               [  OK  ]

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

No. S.	API & Deskripsi
1	DBI→connect($data_source, "userid", "password", \%attr) Membuat koneksi database, atau sesi, ke $ data_source yang diminta. Mengembalikan objek pegangan database jika koneksi berhasil. Sumber data memiliki bentuk seperti: DBI:Pg:dbname=$database;host=127.0.0.1;port=5432 Pg adalah nama driver PostgreSQL dan testdb adalah nama database.
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 sebuah 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 ().

Menghubungkan 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  = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432";
my $userid = "postgres"; my $password = "pass123";
my $dbh = DBI->connect($dsn, $userid, $password, { RaiseError => 1 }) 
   or die $DBI::errstr;

print "Opened database successfully\n";

Sekarang, mari kita jalankan program yang diberikan di atas untuk membuka database kita testdb; Jika database berhasil dibuka maka akan muncul pesan berikut -

Open database successfully

Buat Tabel

Program Perl berikut akan digunakan untuk membuat tabel di database yang dibuat sebelumnya -

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname=$database;host=127.0.0.1;port=5432";
my $userid = "postgres"; my $password = "pass123";
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 yang diberikan di atas dijalankan, itu akan membuat tabel PERUSAHAAN di Anda testdb dan itu akan menampilkan pesan berikut -

Opened database successfully
Table created successfully

Operasi INSERT

Program Perl berikut menunjukkan bagaimana kita dapat membuat catatan dalam tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "Pg"; my $database = "testdb";
my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432"; my $userid = "postgres";
my $password = "pass123"; 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 yang diberikan di atas dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut -

Opened database successfully
Records created successfully

PILIH Operasi

Program Perl berikut menunjukkan bagaimana kita dapat mengambil dan menampilkan catatan dari tabel PERUSAHAAN kita yang dibuat pada contoh di atas -

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432";
my $userid = "postgres"; my $password = "pass123";
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();

Ketika program yang diberikan di atas dijalankan, itu 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 successfully

UPDATE Operasi

Kode Perl berikut menunjukkan bagaimana kita dapat menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN kita -

#!/usr/bin/perl

use DBI;
use strict;

my $driver = "Pg"; my $database = "testdb";
my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432"; my $userid = "postgres";
my $password = "pass123"; 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();

Ketika program yang diberikan di atas dijalankan, itu 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 successfully

HAPUS Operasi

Kode Perl berikut menunjukkan bagaimana kita dapat menggunakan pernyataan DELETE untuk menghapus semua catatan dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN kita -

#!/usr/bin/perl

use DBI;
use strict;

my $driver   = "Pg"; 
my $database = "testdb"; my $dsn = "DBI:$driver:dbname = $database;host = 127.0.0.1;port = 5432";
my $userid = "postgres"; my $password = "pass123";
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();

Ketika program yang diberikan di atas dijalankan, itu 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 successfully

Instalasi

PostgreSQL dapat diintegrasikan dengan Python menggunakan modul psycopg2. sycopg2 adalah adaptor database PostgreSQL untuk bahasa pemrograman Python. psycopg2 ditulis dengan tujuan menjadi sangat kecil dan cepat, serta stabil seperti batu. Anda tidak perlu menginstal modul ini secara terpisah karena sudah dikirimkan, secara default, bersama dengan Python versi 2.5.x dan seterusnya.

Jika Anda belum menginstalnya di mesin Anda, maka Anda dapat menggunakan perintah yum untuk menginstalnya sebagai berikut -

$yum install python-psycopg2

Untuk menggunakan modul psycopg2, Anda harus terlebih dahulu membuat objek Connection yang mewakili database dan kemudian secara opsional Anda dapat membuat objek kursor yang akan membantu Anda dalam menjalankan semua pernyataan SQL.

API modul psycopg2 Python

Berikut ini adalah rutinitas modul psycopg2 yang penting, yang dapat mencukupi kebutuhan Anda untuk bekerja dengan database PostgreSQL dari program Python Anda. Jika Anda mencari aplikasi yang lebih canggih, Anda dapat melihat dokumentasi resmi modul psycopg2 Python.

No. S.	API & Deskripsi
1	psycopg2.connect(database="testdb", user="postgres", password="cohondob", host="127.0.0.1", port="5432") API ini membuka koneksi ke database PostgreSQL. Jika database berhasil dibuka, itu mengembalikan objek koneksi.
2	connection.cursor() Rutinitas ini menciptakan file cursor yang akan digunakan di seluruh pemrograman database Anda dengan Python.
3	cursor.execute(sql [, optional parameters]) Rutinitas ini menjalankan pernyataan SQL. Pernyataan SQL dapat diparameterisasi (yaitu, placeholder, bukan literal SQL). Modul psycopg2 mendukung placeholder menggunakan tanda% s Misalnya: cursor.execute ("masukkan ke dalam nilai orang (% s,% s)", (siapa, umur))
4	cursor.executemany(sql, seq_of_parameters) Rutin ini mengeksekusi perintah SQL terhadap semua urutan parameter atau pemetaan yang ditemukan di urutan sql.
5	cursor.callproc(procname[, parameters]) Rutinitas ini menjalankan prosedur database yang disimpan dengan nama yang diberikan. Urutan parameter harus berisi satu entri untuk setiap argumen yang diharapkan oleh prosedur.
6	cursor.rowcount Atribut hanya-baca ini yang mengembalikan jumlah total baris database yang telah dimodifikasi, disisipkan, atau dihapus oleh eksekusi terakhir * ().
7	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.
8	connection.rollback() Metode ini mengembalikan setiap perubahan ke database sejak panggilan terakhir ke commit ().
9	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!
10	cursor.fetchone() Metode ini mengambil baris berikutnya dari kumpulan hasil kueri, mengembalikan satu urutan, atau Tidak ada saat tidak ada lagi data yang tersedia.
11	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.
12	cursor.fetchall() Rutinitas ini mengambil semua baris (tersisa) dari hasil kueri, mengembalikan daftar. Daftar kosong dikembalikan jika tidak ada baris yang tersedia.

Menghubungkan 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 psycopg2

conn = psycopg2.connect(database="testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")

print "Opened database successfully"

Di sini, Anda juga dapat menyediakan database testdb sebagai nama dan jika database berhasil dibuka, maka akan muncul pesan berikut -

Open database successfully

Buat Tabel

Program Python berikut akan digunakan untuk membuat tabel di database yang dibuat sebelumnya -

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()
cur.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.commit()
conn.close()

Ketika program yang diberikan di atas dijalankan, itu akan membuat tabel PERUSAHAAN di Anda test.db dan itu akan menampilkan pesan berikut -

Opened database successfully
Table created successfully

Operasi INSERT

Program Python berikut menunjukkan bagaimana kita dapat membuat record di tabel COMPANY kita yang dibuat pada contoh di atas -

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (1, 'Paul', 32, 'California', 20000.00 )");

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (2, 'Allen', 25, 'Texas', 15000.00 )");

cur.execute("INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) \
      VALUES (3, 'Teddy', 23, 'Norway', 20000.00 )");

cur.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 yang diberikan di atas dijalankan, itu akan membuat catatan yang diberikan dalam tabel PERUSAHAAN dan akan menampilkan dua baris berikut -

Opened database successfully
Records created successfully

PILIH Operasi

Program Python berikut menunjukkan bagaimana kita dapat mengambil dan menampilkan record dari tabel COMPANY kita yang dibuat pada contoh di atas -

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("SELECT id, name, address, salary  from COMPANY")
rows = cur.fetchall()
for row in rows:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Ketika program yang diberikan di atas dijalankan, itu 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 successfully

UPDATE Operasi

Kode Python berikut menunjukkan bagaimana kita dapat menggunakan pernyataan UPDATE untuk memperbarui catatan apa pun dan kemudian mengambil dan menampilkan catatan yang diperbarui dari tabel PERUSAHAAN kita -

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("UPDATE COMPANY set SALARY = 25000.00 where ID = 1")
conn.commit()
print "Total number of rows updated :", cur.rowcount

cur.execute("SELECT id, name, address, salary  from COMPANY")
rows = cur.fetchall()
for row in rows:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Ketika program yang diberikan di atas dijalankan, itu 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 successfully

HAPUS Operasi

Kode Python berikut menunjukkan bagaimana kita dapat menggunakan pernyataan DELETE untuk menghapus catatan apa pun dan kemudian mengambil dan menampilkan catatan yang tersisa dari tabel PERUSAHAAN kita -

#!/usr/bin/python

import psycopg2

conn = psycopg2.connect(database = "testdb", user = "postgres", password = "pass123", host = "127.0.0.1", port = "5432")
print "Opened database successfully"

cur = conn.cursor()

cur.execute("DELETE from COMPANY where ID=2;")
conn.commit()
print "Total number of rows deleted :", cur.rowcount

cur.execute("SELECT id, name, address, salary  from COMPANY")
rows = cur.fetchall()
for row in rows:
   print "ID = ", row[0]
   print "NAME = ", row[1]
   print "ADDRESS = ", row[2]
   print "SALARY = ", row[3], "\n"

print "Operation done successfully";
conn.close()

Ketika program yang diberikan di atas dijalankan, itu 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