PostgreSQL - คู่มือฉบับย่อ
PostgreSQL เป็นระบบฐานข้อมูลเชิงวัตถุสัมพันธ์แบบโอเพ่นซอร์สที่มีประสิทธิภาพ มีระยะการพัฒนาที่ใช้งานมากว่า 15 ปีและสถาปัตยกรรมที่ได้รับการพิสูจน์แล้วซึ่งได้รับชื่อเสียงอย่างมากในด้านความน่าเชื่อถือความสมบูรณ์ของข้อมูลและความถูกต้อง
บทช่วยสอนนี้จะช่วยให้คุณเริ่มต้นใช้งาน PostgreSQL ได้อย่างรวดเร็วและทำให้คุณสบายใจกับการเขียนโปรแกรม PostgreSQL
PostgreSQL คืออะไร?
PostgreSQL (ออกเสียงว่า post-gress-Q-L) เป็นระบบจัดการฐานข้อมูลเชิงสัมพันธ์แบบโอเพ่นซอร์ส (DBMS) ที่พัฒนาโดยทีมอาสาสมัครทั่วโลก PostgreSQL ไม่ได้รับการควบคุมโดย บริษัท ใด ๆ หรือหน่วยงานเอกชนอื่น ๆ และมีซอร์สโค้ดให้บริการฟรี
ประวัติโดยย่อของ PostgreSQL
PostgreSQL เดิมเรียกว่า Postgres ถูกสร้างขึ้นที่ UCB โดยศาสตราจารย์ด้านวิทยาการคอมพิวเตอร์ชื่อ Michael Stonebraker Stonebraker เริ่ม Postgres ในปี 1986 โดยเป็นโครงการติดตามผลของ Ingres รุ่นก่อนซึ่งปัจจุบันเป็นเจ้าของโดย Computer Associates
1977-1985 - มีการพัฒนาโครงการที่เรียกว่า INGRES
การพิสูจน์แนวคิดสำหรับฐานข้อมูลเชิงสัมพันธ์
ก่อตั้ง บริษัท Ingres ในปีพ. ศ. 2523
ซื้อโดย Computer Associates ในปี 1994
1986-1994 - โพสต์เกรซ
การพัฒนาแนวคิดใน INGRES โดยเน้นที่การวางแนววัตถุและภาษาแบบสอบถาม - Quel
ฐานรหัสของ INGRES ไม่ได้ใช้เป็นพื้นฐานสำหรับ POSTGRES
เชิงพาณิชย์เป็น Illustra (ซื้อโดย Informix ซื้อโดย IBM)
1994-1995 - Postgres95
เพิ่มการรองรับ SQL ในปี 1994
วางจำหน่ายในชื่อ Postgres95 ในปี 1995
ออกใหม่เป็น PostgreSQL 6.0 ในปี 2539
การจัดตั้งทีมพัฒนาระดับโลกของ PostgreSQL
คุณสมบัติที่สำคัญของ PostgreSQL
PostgreSQL ทำงานบนระบบปฏิบัติการหลักทั้งหมดรวมถึง Linux, UNIX (AIX, BSD, HP-UX, SGI IRIX, MacOS X, Solaris, Tru64) และ Windows รองรับข้อความรูปภาพเสียงและวิดีโอและรวมถึงอินเตอร์เฟสการเขียนโปรแกรมสำหรับ C / C ++, Java, Perl, Python, Ruby, Tcl และ Open Database Connectivity (ODBC)
PostgreSQL รองรับส่วนใหญ่ของมาตรฐาน SQL และมีคุณสมบัติที่ทันสมัยมากมายรวมถึงสิ่งต่อไปนี้ -
- แบบสอบถาม SQL ที่ซับซ้อน
- SQL Sub- เลือก
- คีย์ต่างประเทศ
- Trigger
- Views
- Transactions
- การควบคุมภาวะพร้อมกันหลายทาง (MVCC)
- การจำลองแบบสตรีมมิง (ณ 9.0)
- Hot Standby (ณ 9.0)
คุณสามารถตรวจสอบเอกสารอย่างเป็นทางการของ PostgreSQL เพื่อทำความเข้าใจคุณสมบัติดังกล่าวข้างต้น ผู้ใช้สามารถขยาย PostgreSQL ได้หลายวิธี ตัวอย่างเช่นโดยการเพิ่มใหม่ -
- ประเภทข้อมูล
- Functions
- Operators
- ฟังก์ชันรวม
- วิธีการทำดัชนี
รองรับภาษาขั้นตอน
PostgreSQL รองรับภาษาขั้นตอนมาตรฐานสี่ภาษาซึ่งช่วยให้ผู้ใช้สามารถเขียนรหัสของตนเองในภาษาใดก็ได้และสามารถดำเนินการได้โดยเซิร์ฟเวอร์ฐานข้อมูล PostgreSQL ภาษาขั้นตอนเหล่านี้ ได้แก่ - PL / pgSQL, PL / Tcl, PL / Perl และ PL / Python นอกจากนี้ยังรองรับภาษาขั้นตอนอื่น ๆ ที่ไม่ได้มาตรฐานเช่น PL / PHP, PL / V8, PL / Ruby, PL / Java เป็นต้น
ในการเริ่มทำความเข้าใจพื้นฐานของ PostgreSQL ก่อนอื่นให้เราติดตั้ง PostgreSQL บทนี้จะอธิบายเกี่ยวกับการติดตั้ง PostgreSQL บนแพลตฟอร์ม Linux, Windows และ Mac OS
การติดตั้ง PostgreSQL บน Linux / Unix
ทำตามขั้นตอนที่กำหนดเพื่อติดตั้ง PostgreSQL บนเครื่อง Linux ของคุณ ตรวจสอบให้แน่ใจว่าคุณเข้าสู่ระบบด้วยroot ก่อนดำเนินการติดตั้ง
เลือกหมายเลขเวอร์ชันของ PostgreSQL ที่คุณต้องการและแพลตฟอร์มที่คุณต้องการจากEnterpriseDB ให้มากที่สุด
ฉันดาวน์โหลด postgresql-9.2.4-1-linux-x64.runสำหรับเครื่อง CentOS-6 64 บิตของฉัน ตอนนี้ให้เราดำเนินการดังต่อไปนี้ -
[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]:เมื่อคุณเปิดโปรแกรมติดตั้งระบบจะถามคำถามพื้นฐานสองสามข้อเช่นตำแหน่งของการติดตั้งรหัสผ่านของผู้ใช้ที่จะใช้ฐานข้อมูลหมายเลขพอร์ต ฯลฯ ดังนั้นให้ทุกคนเป็นค่าเริ่มต้นยกเว้นรหัสผ่านซึ่งคุณสามารถระบุรหัสผ่านได้ ตามที่คุณเลือก จะติดตั้ง PostgreSQL ที่เครื่อง Linux ของคุณและจะแสดงข้อความต่อไปนี้ -
Please wait while Setup installs PostgreSQL on your computer.
Installing
0% ______________ 50% ______________ 100%
#########################################
-----------------------------------------------------------------------
Setup has finished installing PostgreSQL on your computer.ทำตามขั้นตอนหลังการติดตั้งต่อไปนี้เพื่อสร้างฐานข้อมูลของคุณ -
[root@host]# su - postgres
Password:
bash-4.1$ createdb testdb bash-4.1$ psql testdb
psql (8.4.13, server 9.2.4)
test=#คุณสามารถเริ่ม / รีสตาร์ทเซิร์ฟเวอร์ postgres ในกรณีที่ไม่ได้ทำงานโดยใช้คำสั่งต่อไปนี้ -
[root@host]# service postgresql restart
Stopping postgresql service: [ OK ]
Starting postgresql service: [ OK ]หากการติดตั้งของคุณถูกต้องคุณจะมีพรอมต์ PotsgreSQL test=# ดังที่แสดงไว้ด้านบน
การติดตั้ง PostgreSQL บน Windows
ทำตามขั้นตอนที่กำหนดเพื่อติดตั้ง PostgreSQL บนเครื่อง Windows ของคุณ ตรวจสอบให้แน่ใจว่าคุณได้ปิด Third Party Antivirus ขณะติดตั้ง
เลือกหมายเลขเวอร์ชันของ PostgreSQL ที่คุณต้องการและแพลตฟอร์มที่คุณต้องการจากEnterpriseDB ให้มากที่สุด
ฉันดาวน์โหลด postgresql-9.2.4-1-windows.exe สำหรับพีซี Windows ของฉันที่ทำงานในโหมด 32 บิตดังนั้นให้เราเรียกใช้ postgresql-9.2.4-1-windows.exeในฐานะผู้ดูแลระบบเพื่อติดตั้ง PostgreSQL เลือกตำแหน่งที่คุณต้องการติดตั้ง โดยค่าเริ่มต้นจะติดตั้งไว้ในโฟลเดอร์ Program Files
ขั้นตอนต่อไปของกระบวนการติดตั้งคือการเลือกไดเร็กทอรีที่จะจัดเก็บข้อมูลของคุณ โดยค่าเริ่มต้นจะถูกเก็บไว้ในไดเร็กทอรี "data"
จากนั้นการตั้งค่าจะถามรหัสผ่านเพื่อให้คุณสามารถใช้รหัสผ่านที่คุณชื่นชอบได้
ขั้นตอนต่อไป; ให้พอร์ตเป็นค่าเริ่มต้น
ในขั้นตอนต่อไปเมื่อถูกถามถึง "Locale" ฉันเลือก "English, United States"
ใช้เวลาสักครู่ในการติดตั้ง PostgreSQL บนระบบของคุณ เมื่อเสร็จสิ้นขั้นตอนการติดตั้งคุณจะได้รับหน้าจอต่อไปนี้ ยกเลิกการเลือกช่องทำเครื่องหมายแล้วคลิกปุ่มเสร็จสิ้น
หลังจากขั้นตอนการติดตั้งเสร็จสิ้นคุณสามารถเข้าถึง pgAdmin III, StackBuilder และ PostgreSQL shell ได้จาก Program Menu ของคุณใน PostgreSQL 9.2
การติดตั้ง PostgreSQL บน Mac
ทำตามขั้นตอนที่กำหนดเพื่อติดตั้ง PostgreSQL บนเครื่อง Mac ของคุณ ตรวจสอบให้แน่ใจว่าคุณเข้าสู่ระบบด้วยadministrator ก่อนดำเนินการติดตั้ง
เลือกหมายเลขเวอร์ชันล่าสุดของ PostgreSQL สำหรับ Mac OS ที่EnterpriseDB
ฉันดาวน์โหลด postgresql-9.2.4-1-osx.dmgสำหรับ Mac OS ของฉันที่ทำงานกับ OS X เวอร์ชัน 10.8.3 ตอนนี้ให้เราเปิดภาพ dmg ใน finder แล้วดับเบิลคลิกซึ่งจะทำให้คุณติดตั้ง PostgreSQL ในหน้าต่างต่อไปนี้ -
จากนั้นคลิกไฟล์ postgres-9.2.4-1-osxไอคอนซึ่งจะแสดงข้อความเตือน ยอมรับคำเตือนและดำเนินการติดตั้งต่อไป มันจะถามรหัสผ่านผู้ดูแลระบบดังที่เห็นในหน้าต่างต่อไปนี้ -
ป้อนรหัสผ่านดำเนินการติดตั้งและหลังจากขั้นตอนนี้รีสตาร์ทเครื่อง Mac ของคุณ หากคุณไม่เห็นหน้าต่างต่อไปนี้ให้เริ่มการติดตั้งอีกครั้ง
เมื่อคุณเปิดโปรแกรมติดตั้งระบบจะถามคำถามพื้นฐานสองสามข้อเช่นตำแหน่งของการติดตั้งรหัสผ่านของผู้ใช้ที่จะใช้ฐานข้อมูลหมายเลขพอร์ตเป็นต้นดังนั้นให้เก็บทั้งหมดไว้ที่ค่าเริ่มต้นยกเว้นรหัสผ่านซึ่งคุณสามารถระบุ ตามที่คุณเลือก จะติดตั้ง PostgreSQL ในเครื่อง Mac ของคุณในโฟลเดอร์ Application ซึ่งคุณสามารถตรวจสอบได้ -
ตอนนี้คุณสามารถเปิดโปรแกรมใดก็ได้เพื่อเริ่มต้นด้วย เริ่มต้นด้วย SQL Shell เมื่อคุณเปิดใช้งาน SQL Shell เพียงใช้ค่าเริ่มต้นทั้งหมดที่แสดงยกเว้นป้อนรหัสผ่านของคุณซึ่งคุณได้เลือกไว้ในขณะติดตั้ง หากทุกอย่างเรียบร้อยคุณจะอยู่ในฐานข้อมูล postgres และไฟล์postgress# จะปรากฏขึ้นตามที่แสดงด้านล่าง -
ยินดีด้วย !!! ตอนนี้คุณมีสภาพแวดล้อมของคุณพร้อมที่จะเริ่มต้นด้วยการเขียนโปรแกรมฐานข้อมูล PostgreSQL
บทนี้แสดงรายการของคำสั่ง PostgreSQL SQL ตามด้วยกฎไวยากรณ์ที่แม่นยำสำหรับแต่ละคำสั่งเหล่านี้ ชุดคำสั่งนี้นำมาจากเครื่องมือบรรทัดคำสั่ง psql เมื่อคุณติดตั้ง Postgres แล้วให้เปิด psql เป็น -
Program Files → PostgreSQL 9.2 → SQL Shell(psql).
เมื่อใช้ psql คุณสามารถสร้างรายการคำสั่งทั้งหมดโดยใช้คำสั่ง \ help สำหรับไวยากรณ์ของคำสั่งเฉพาะให้ใช้คำสั่งต่อไปนี้ -
postgres-# \help <command_name>คำสั่ง SQL
คำสั่ง SQL ประกอบด้วยโทเค็นโดยแต่ละโทเค็นสามารถแสดงถึงคำสำคัญตัวระบุตัวระบุที่ยกมาค่าคงที่หรือสัญลักษณ์อักขระพิเศษ ตารางด้านล่างนี้ใช้คำสั่ง SELECT อย่างง่ายเพื่อแสดงคำสั่ง SQL พื้นฐาน แต่สมบูรณ์และส่วนประกอบ
| เลือก | id, ชื่อ | จาก | รัฐ | |
|---|---|---|---|---|
| ประเภทโทเค็น | คำสำคัญ | ตัวระบุ | คำสำคัญ | ตัวระบุ |
| คำอธิบาย | คำสั่ง | คอลัมน์รหัสและชื่อ | ข้อ | ชื่อตาราง |
คำสั่ง PostgreSQL SQL
แท้ง
ยกเลิกธุรกรรมปัจจุบัน
ABORT [ WORK | TRANSACTION ]แก้ไขรวม
เปลี่ยนนิยามของฟังก์ชันการรวม
ALTER AGGREGATE name ( type ) RENAME TO new_name
ALTER AGGREGATE name ( type ) OWNER TO new_ownerแก้ไขการแปลง
เปลี่ยนคำจำกัดความของการแปลง
ALTER CONVERSION name RENAME TO new_name
ALTER CONVERSION name OWNER TO new_ownerแก้ไขฐานข้อมูล
เปลี่ยนพารามิเตอร์เฉพาะฐานข้อมูล
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 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 FUNCTION name ( [ type [, ...] ] ) RENAME TO new_name
ALTER FUNCTION name ( [ type [, ...] ] ) OWNER TO new_ownerแก้ไขกลุ่ม
เปลี่ยนกลุ่มผู้ใช้
ALTER GROUP groupname ADD USER username [, ... ]
ALTER GROUP groupname DROP USER username [, ... ]
ALTER GROUP groupname RENAME TO new_nameแก้ไขดัชนี
เปลี่ยนนิยามของดัชนี
ALTER INDEX name OWNER TO new_owner
ALTER INDEX name SET TABLESPACE indexspace_name
ALTER INDEX name RENAME TO new_nameเปลี่ยนภาษา
เปลี่ยนคำจำกัดความของภาษาขั้นตอน
ALTER LANGUAGE name RENAME TO new_nameแก้ไข OPERATOR
เปลี่ยนคำจำกัดความของตัวดำเนินการ
ALTER OPERATOR name ( { lefttype | NONE }, { righttype | NONE } )
OWNER TO new_ownerแก้ไขคลาส OPERATOR
เปลี่ยนนิยามของคลาสตัวดำเนินการ
ALTER OPERATOR CLASS name USING index_method RENAME TO new_name
ALTER OPERATOR CLASS name USING index_method OWNER TO new_ownerแก้ไขโครงร่าง
เปลี่ยนนิยามของสคีมา
ALTER SCHEMA name RENAME TO new_name
ALTER SCHEMA name OWNER TO new_ownerเปลี่ยนแปลงลำดับ
เปลี่ยนนิยามของตัวสร้างลำดับ
ALTER SEQUENCE name [ INCREMENT [ BY ] increment ]
[ MINVALUE minvalue | NO MINVALUE ]
[ MAXVALUE maxvalue | NO MAXVALUE ]
[ RESTART [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]แก้ไขตาราง
เปลี่ยนนิยามของตาราง
ALTER TABLE [ ONLY ] name [ * ]
action [, ... ]
ALTER TABLE [ ONLY ] name [ * ]
RENAME [ COLUMN ] column TO new_column
ALTER TABLE name
RENAME TO new_nameโดยที่การกระทำคือหนึ่งในบรรทัดต่อไปนี้ -
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 name RENAME TO new_name
ALTER TABLESPACE name OWNER TO new_ownerแก้ไขทริกเกอร์
เปลี่ยนความหมายของทริกเกอร์
ALTER TRIGGER name ON table RENAME TO new_nameเปลี่ยนประเภท
เปลี่ยนนิยามของประเภท
ALTER TYPE name OWNER TO new_ownerแก้ไขผู้ใช้
เปลี่ยนบัญชีผู้ใช้ฐานข้อมูล
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ตัวเลือกได้ที่ไหน-
[ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
| CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| VALID UNTIL 'abstime'วิเคราะห์
รวบรวมสถิติเกี่ยวกับฐานข้อมูล
ANALYZE [ VERBOSE ] [ table [ (column [, ...] ) ] ]เริ่ม
เริ่มบล็อกธุรกรรม
BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]โดยที่transaction_modeเป็นหนึ่งใน -
ISOLATION LEVEL {
SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED
}
READ WRITE | READ ONLYด่าน
บังคับใช้จุดตรวจบันทึกธุรกรรม
CHECKPOINTปิด
ปิดเคอร์เซอร์
CLOSE nameคลัสเตอร์
จัดกลุ่มตารางตามดัชนี
CLUSTER index_name ON table_name
CLUSTER table_name
CLUSTERแสดงความคิดเห็น
กำหนดหรือเปลี่ยนข้อคิดเห็นของวัตถุ
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'คอมมิต
ทำธุรกรรมปัจจุบัน
COMMIT [ WORK | TRANSACTION ]สำเนา
คัดลอกข้อมูลระหว่างไฟล์และตาราง
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 [, ...] ]สร้างโดยรวม
กำหนดฟังก์ชันการรวมใหม่
CREATE AGGREGATE name (
BASETYPE = input_data_type,
SFUNC = sfunc,
STYPE = state_data_type
[, FINALFUNC = ffunc ]
[, INITCOND = initial_condition ]
)สร้างนักแสดง
กำหนดนักแสดงใหม่
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 ]สร้างทริกเกอร์ข้อ จำกัด
กำหนดทริกเกอร์ข้อ จำกัด ใหม่
CREATE CONSTRAINT TRIGGER name
AFTER events ON
table_name constraint attributes
FOR EACH ROW EXECUTE PROCEDURE func_name ( args )สร้างการแปลง
กำหนด Conversion ใหม่
CREATE [DEFAULT] CONVERSION name
FOR source_encoding TO dest_encoding FROM func_nameสร้างฐานข้อมูล
สร้างฐานข้อมูลใหม่
CREATE DATABASE name
[ [ WITH ] [ OWNER [=] db_owner ]
[ TEMPLATE [=] template ]
[ ENCODING [=] encoding ]
[ TABLESPACE [=] tablespace ]
]สร้างโดเมน
กำหนดโดเมนใหม่
CREATE DOMAIN name [AS] data_type
[ DEFAULT expression ]
[ constraint [ ... ] ]ข้อ จำกัดอยู่ที่ไหน-
[ CONSTRAINT constraint_name ]
{ NOT NULL | NULL | CHECK (expression) }สร้างฟังก์ชั่น
กำหนดฟังก์ชันใหม่
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 [, ...] ) ]สร้างกลุ่ม
กำหนดกลุ่มผู้ใช้ใหม่
CREATE GROUP name [ [ WITH ] option [ ... ] ]
Where option can be:
SYSID gid
| USER username [, ...]สร้างดัชนี
กำหนดดัชนีใหม่
CREATE [ UNIQUE ] INDEX name ON table [ USING method ]
( { column | ( expression ) } [ opclass ] [, ...] )
[ TABLESPACE tablespace ]
[ WHERE predicate ]สร้างภาษา
กำหนดภาษาขั้นตอนใหม่
CREATE [ TRUSTED ] [ PROCEDURAL ] LANGUAGE name
HANDLER call_handler [ VALIDATOR val_function ]สร้างตัวดำเนินการ
กำหนดตัวดำเนินการใหม่
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 ]
)สร้างคลาส OPERATOR
กำหนดคลาสตัวดำเนินการใหม่
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
} [, ... ]สร้างกฎ
กำหนดกฎการเขียนซ้ำใหม่
CREATE [ OR REPLACE ] RULE name AS ON event
TO table [ WHERE condition ]
DO [ ALSO | INSTEAD ] { NOTHING | command | ( command ; command ... ) }สร้างโครงการ
กำหนดสคีมาใหม่
CREATE SCHEMA schema_name
[ AUTHORIZATION username ] [ schema_element [ ... ] ]
CREATE SCHEMA AUTHORIZATION username
[ schema_element [ ... ] ]สร้างลำดับ
กำหนดตัวสร้างลำดับใหม่
CREATE [ TEMPORARY | TEMP ] SEQUENCE name
[ INCREMENT [ BY ] increment ]
[ MINVALUE minvalue | NO MINVALUE ]
[ MAXVALUE maxvalue | NO MAXVALUE ]
[ START [ WITH ] start ] [ CACHE cache ] [ [ NO ] CYCLE ]สร้างตาราง
กำหนดตารางใหม่
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 ]column_constraintอยู่ที่ไหน-
[ 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 ]และtable_constraintคือ -
[ 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 ]สร้างตารางเป็น
กำหนดตารางใหม่จากผลลัพธ์ของแบบสอบถาม
CREATE [ [ GLOBAL | LOCAL ] { TEMPORARY | TEMP } ] TABLE table_name
[ (column_name [, ...] ) ] [ [ WITH | WITHOUT ] OIDS ]
AS queryสร้างตารางพื้นที่
กำหนดพื้นที่ตารางใหม่
CREATE TABLESPACE tablespace_name [ OWNER username ] LOCATION 'directory'สร้างทริกเกอร์
กำหนดทริกเกอร์ใหม่
CREATE TRIGGER name { BEFORE | AFTER } { event [ OR ... ] }
ON table [ FOR [ EACH ] { ROW | STATEMENT } ]
EXECUTE PROCEDURE func_name ( arguments )สร้าง TYPE
กำหนดชนิดข้อมูลใหม่
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 ]
)สร้างผู้ใช้
กำหนดบัญชีผู้ใช้ฐานข้อมูลใหม่
CREATE USER name [ [ WITH ] option [ ... ] ]ตัวเลือกได้ที่ไหน-
SYSID uid
| [ ENCRYPTED | UNENCRYPTED ] PASSWORD 'password'
| CREATEDB | NOCREATEDB
| CREATEUSER | NOCREATEUSER
| IN GROUP group_name [, ...]
| VALID UNTIL 'abs_time'สร้างมุมมอง
กำหนดมุมมองใหม่
CREATE [ OR REPLACE ] VIEW name [ ( column_name [, ...] ) ] AS queryยกเลิกการใช้งาน
จัดสรรงบที่เตรียมไว้
DEALLOCATE [ PREPARE ] plan_nameประกาศ
กำหนดเคอร์เซอร์
DECLARE name [ BINARY ] [ INSENSITIVE ] [ [ NO ] SCROLL ]
CURSOR [ { WITH | WITHOUT } HOLD ] FOR query
[ FOR { READ ONLY | UPDATE [ OF column [, ...] ] } ]ลบ
ลบแถวของตาราง
DELETE FROM [ ONLY ] table [ WHERE condition ]ลดลงรวม
ลบฟังก์ชันการรวม
DROP AGGREGATE name ( type ) [ CASCADE | RESTRICT ]ดรอปแคสต์
ลบนักแสดง
DROP CAST (source_type AS target_type) [ CASCADE | RESTRICT ]DROP CONVERSION
ลบการแปลง
DROP CONVERSION name [ CASCADE | RESTRICT ]วางฐานข้อมูล
ลบฐานข้อมูล
DROP DATABASE nameDROP DOMAIN
ลบโดเมน
DROP DOMAIN name [, ...] [ CASCADE | RESTRICT ]ฟังก์ชั่น DROP
ลบฟังก์ชัน
DROP FUNCTION name ( [ type [, ...] ] ) [ CASCADE | RESTRICT ]DROP GROUP
ลบกลุ่มผู้ใช้
DROP GROUP nameDROP INDEX
ลบดัชนี
DROP INDEX name [, ...] [ CASCADE | RESTRICT ]วางภาษา
ลบภาษาขั้นตอน
DROP [ PROCEDURAL ] LANGUAGE name [ CASCADE | RESTRICT ]DROP OPERATOR
ลบตัวดำเนินการ
DROP OPERATOR name ( { left_type | NONE }, { right_type | NONE } )
[ CASCADE | RESTRICT ]DROP OPERATOR CLASS
ลบคลาสตัวดำเนินการ
DROP OPERATOR CLASS name USING index_method [ CASCADE | RESTRICT ]กฎ DROP
ลบกฎการเขียนซ้ำ
DROP RULE name ON relation [ CASCADE | RESTRICT ]วางโครงการ
ลบสคีมา
DROP SCHEMA name [, ...] [ CASCADE | RESTRICT ]วางลำดับ
ลบลำดับ
DROP SEQUENCE name [, ...] [ CASCADE | RESTRICT ]วางตาราง
ลบตาราง
DROP TABLE name [, ...] [ CASCADE | RESTRICT ]วางตารางพื้นที่
นำช้อนโต๊ะออก
DROP TABLESPACE tablespace_nameDROP TRIGGER
ลบทริกเกอร์
DROP TRIGGER name ON table [ CASCADE | RESTRICT ]DROP TYPE
ลบประเภทข้อมูล
DROP TYPE name [, ...] [ CASCADE | RESTRICT ]วางผู้ใช้
ลบบัญชีผู้ใช้ฐานข้อมูล
DROP USER nameดูดรอป
ลบมุมมอง
DROP VIEW name [, ...] [ CASCADE | RESTRICT ]สิ้นสุด
ทำธุรกรรมปัจจุบัน
END [ WORK | TRANSACTION ]ดำเนินการ
ดำเนินการตามคำสั่งที่เตรียมไว้
EXECUTE plan_name [ (parameter [, ...] ) ]อธิบาย
แสดงแผนการดำเนินการของคำสั่ง
EXPLAIN [ ANALYZE ] [ VERBOSE ] statementค้นหา
ดึงข้อมูลแถวจากแบบสอบถามโดยใช้เคอร์เซอร์
FETCH [ direction { FROM | IN } ] cursor_nameไหนทิศทางสามารถเว้นว่างหรือหนึ่ง -
NEXT
PRIOR
FIRST
LAST
ABSOLUTE count
RELATIVE count
count
ALL
FORWARD
FORWARD count
FORWARD ALL
BACKWARD
BACKWARD count
BACKWARD ALLGRANT
กำหนดสิทธิ์การเข้าถึง
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 ]แทรก
สร้างแถวใหม่ในตาราง
INSERT INTO table [ ( column [, ...] ) ]
{ DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) | query }ฟัง
ฟังการแจ้งเตือน
LISTEN nameโหลด
โหลดหรือโหลดไฟล์ไลบรารีที่แชร์ซ้ำ
LOAD 'filename'ล็อค
ล็อคโต๊ะ
LOCK [ TABLE ] name [, ...] [ IN lock_mode MODE ] [ NOWAIT ]โดยlock_modeเป็นหนึ่งใน -
ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE
| SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVEย้าย
วางเคอร์เซอร์
MOVE [ direction { FROM | IN } ] cursor_nameแจ้ง
สร้างการแจ้งเตือน
NOTIFY nameเตรียมความพร้อม
เตรียมคำสั่งสำหรับการดำเนินการ
PREPARE plan_name [ (data_type [, ...] ) ] AS statementREINDEX
สร้างดัชนีใหม่
REINDEX { DATABASE | TABLE | INDEX } name [ FORCE ]ปล่อยประหยัด
ทำลายจุดบันทึกที่กำหนดไว้ก่อนหน้านี้
RELEASE [ SAVEPOINT ] savepoint_nameรีเซ็ต
เรียกคืนค่าของพารามิเตอร์รันไทม์เป็นค่าดีฟอลต์
RESET name
RESET ALLถอน
ลบสิทธิ์การเข้าถึง
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 [ WORK | TRANSACTION ]ROLLBACK TO SAVEPOINT
ย้อนกลับไปที่จุดบันทึก
ROLLBACK [ WORK | TRANSACTION ] TO [ SAVEPOINT ] savepoint_nameประหยัด
กำหนดจุดบันทึกใหม่ภายในธุรกรรมปัจจุบัน
SAVEPOINT savepoint_nameเลือก
ดึงแถวจากตารางหรือมุมมอง
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 [, ...] ] ][ 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 [, ...] ) ]เลือกเข้า
กำหนดตารางใหม่จากผลลัพธ์ของแบบสอบถาม
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
เปลี่ยนพารามิเตอร์รันไทม์
SET [ SESSION | LOCAL ] name { TO | = } { value | 'value' | DEFAULT }
SET [ SESSION | LOCAL ] TIME ZONE { time_zone | LOCAL | DEFAULT }กำหนดข้อ จำกัด
ตั้งค่าโหมดการตรวจสอบข้อ จำกัด สำหรับธุรกรรมปัจจุบัน
SET CONSTRAINTS { ALL | name [, ...] } { DEFERRED | IMMEDIATE }ตั้งค่าการอนุญาตเซสชั่น
ตั้งค่าตัวระบุผู้ใช้เซสชันและตัวระบุผู้ใช้ปัจจุบันของเซสชันปัจจุบัน
SET [ SESSION | LOCAL ] SESSION AUTHORIZATION username
SET [ SESSION | LOCAL ] SESSION AUTHORIZATION DEFAULT
RESET SESSION AUTHORIZATIONตั้งค่าธุรกรรม
กำหนดลักษณะของธุรกรรมปัจจุบัน
SET TRANSACTION transaction_mode [, ...]
SET SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]โดยที่transaction_modeเป็นหนึ่งใน -
ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED }
READ WRITE | READ ONLYแสดง
แสดงค่าของพารามิเตอร์รันไทม์
SHOW name
SHOW ALLเริ่มการทำธุรกรรม
เริ่มบล็อกธุรกรรม
START TRANSACTION [ transaction_mode [, ...] ]โดยที่transaction_modeเป็นหนึ่งใน -
ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED
| READ UNCOMMITTED }
READ WRITE | READ ONLYตัด
ล้างตาราง
TRUNCATE [ TABLE ] nameไม่ฟัง
หยุดฟังการแจ้งเตือน
UNLISTEN { name | * }อัปเดต
อัปเดตแถวของตาราง
UPDATE [ ONLY ] table SET column = { expression | DEFAULT } [, ...]
[ FROM from_list ]
[ WHERE condition ]เครื่องดูดฝุ่น
รวบรวมขยะและเลือกวิเคราะห์ฐานข้อมูล
VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] [ table ]
VACUUM [ FULL ] [ FREEZE ] [ VERBOSE ] ANALYZE [ table [ (column [, ...] ) ] ]ในบทนี้เราจะพูดถึงประเภทข้อมูลที่ใช้ใน PostgreSQL ในขณะที่สร้างตารางคุณต้องระบุชนิดข้อมูลสำหรับแต่ละคอลัมน์เช่นชนิดของข้อมูลที่คุณต้องการจัดเก็บในช่องตาราง
สิ่งนี้ทำให้เกิดประโยชน์หลายประการ -
Consistency - การดำเนินการกับคอลัมน์ที่มีข้อมูลประเภทเดียวกันให้ผลลัพธ์ที่สอดคล้องกันและโดยปกติจะเร็วที่สุด
Validation - การใช้ประเภทข้อมูลอย่างเหมาะสมหมายถึงการตรวจสอบความถูกต้องของข้อมูลและการปฏิเสธข้อมูลนอกขอบเขตของประเภทข้อมูล
Compactness - เนื่องจากคอลัมน์สามารถจัดเก็บค่าประเภทเดียวได้จึงถูกจัดเก็บอย่างกะทัดรัด
Performance- การใช้ประเภทข้อมูลอย่างเหมาะสมทำให้การจัดเก็บข้อมูลมีประสิทธิภาพสูงสุด ค่าที่จัดเก็บสามารถประมวลผลได้อย่างรวดเร็วซึ่งช่วยเพิ่มประสิทธิภาพ
PostgreSQL รองรับประเภทข้อมูลที่หลากหลาย นอกจากนี้ผู้ใช้สามารถสร้างประเภทข้อมูลที่กำหนดเองได้โดยใช้คำสั่งCREATE TYPE SQL ประเภทข้อมูลใน PostgreSQL มีหลายประเภท พวกเขาจะกล่าวถึงด้านล่าง
ประเภทตัวเลข
ประเภทตัวเลขประกอบด้วยจำนวนเต็มสองไบต์สี่ไบต์และแปดไบต์ตัวเลขทศนิยมสี่ไบต์และแปดไบต์และทศนิยมที่มีความแม่นยำที่เลือกได้ ตารางต่อไปนี้แสดงประเภทที่ใช้ได้
| ชื่อ | ขนาดการจัดเก็บ | คำอธิบาย | พิสัย |
|---|---|---|---|
| Smallint | 2 ไบต์ | จำนวนเต็มช่วงเล็ก | -32768 ถึง +32767 |
| จำนวนเต็ม | 4 ไบต์ | ทางเลือกทั่วไปสำหรับจำนวนเต็ม | -2147483648 ถึง +2147483647 |
| bigint | 8 ไบต์ | จำนวนเต็มช่วงใหญ่ | -9223372036854775808 ถึง 9223372036854775807 |
| ทศนิยม | ตัวแปร | ความแม่นยำที่ผู้ใช้ระบุแน่นอน | มากถึง 131072 หลักก่อนจุดทศนิยม มากถึง 16383 หลักหลังจุดทศนิยม |
| ตัวเลข | ตัวแปร | ความแม่นยำที่ผู้ใช้ระบุแน่นอน | มากถึง 131072 หลักก่อนจุดทศนิยม มากถึง 16383 หลักหลังจุดทศนิยม |
| จริง | 4 ไบต์ | ความแม่นยำตัวแปรไม่แน่นอน | ความแม่นยำของทศนิยม 6 หลัก |
| ความแม่นยำสองเท่า | 8 ไบต์ | ความแม่นยำตัวแปรไม่แน่นอน | ความแม่นยำของทศนิยม 15 หลัก |
| smallserial | 2 ไบต์ | จำนวนเต็มอัตโนมัติขนาดเล็ก | 1 ถึง 32767 |
| อนุกรม | 4 ไบต์ | การสร้างจำนวนเต็มอัตโนมัติ | 1 ถึง 2147483647 |
| bigserial | 8 ไบต์ | จำนวนเต็มอัตโนมัติขนาดใหญ่ | 1 ถึง 9223372036854775807 |
ประเภทการเงิน
เงินประเภทเก็บสกุลเงินที่มีความแม่นยำเศษส่วนคงที่ ค่าของประเภทข้อมูลตัวเลข int และ bigintสามารถโยนเป็นเงินได้ ไม่แนะนำให้ใช้ตัวเลขทศนิยมเพื่อจัดการกับเงินเนื่องจากอาจเกิดข้อผิดพลาดในการปัดเศษ
| ชื่อ | ขนาดการจัดเก็บ | คำอธิบาย | พิสัย |
|---|---|---|---|
| เงิน | 8 ไบต์ | จำนวนเงิน | -92233720368547758.08 ถึง +92233720368547758.07 |
ประเภทตัวละคร
ตารางด้านล่างแสดงประเภทอักขระที่ใช้งานทั่วไปใน PostgreSQL
| ส. เลขที่ | ชื่อและคำอธิบาย |
|---|---|
| 1 | character varying(n), varchar(n) ความยาวผันแปรพร้อมขีด จำกัด |
| 2 | character(n), char(n) ความยาวคงที่เบาะว่าง |
| 3 | text ความยาวไม่ จำกัด ตัวแปร |
ประเภทข้อมูลไบนารี
byteaชนิดข้อมูลช่วยให้การจัดเก็บข้อมูลของสตริงไบนารีดังแสดงในตารางด้านล่าง
| ชื่อ | ขนาดการจัดเก็บ | คำอธิบาย |
|---|---|---|
| bytea | 1 หรือ 4 ไบต์บวกสตริงไบนารีจริง | สตริงไบนารีความยาวผันแปร |
ประเภทวันที่ / เวลา
PostgreSQL รองรับประเภทวันที่และเวลาของ SQL เต็มรูปแบบดังแสดงในตารางด้านล่าง วันที่จะนับตามปฏิทินเกรกอเรียน ที่นี่ทุกประเภทมีความละเอียดของ1 microsecond / 14 digits ยกเว้น date ชนิดซึ่งมีความละเอียดคือ day.
| ชื่อ | ขนาดการจัดเก็บ | คำอธิบาย | มูลค่าต่ำ | มูลค่าสูง |
|---|---|---|---|---|
| การประทับเวลา [(p)] [ไม่มีเขตเวลา] | 8 ไบต์ | ทั้งวันที่และเวลา (ไม่มีเขตเวลา) | 4713 ปีก่อนคริสตกาล | ค.ศ. 294276 |
| TIMESTAMPTZ | 8 ไบต์ | ทั้งวันที่และเวลาพร้อมเขตเวลา | 4713 ปีก่อนคริสตกาล | ค.ศ. 294276 |
| วันที่ | 4 ไบต์ | วันที่ (ไม่มีช่วงเวลาของวัน) | 4713 ปีก่อนคริสตกาล | ค.ศ. 5874897 |
| เวลา [(p)] [ไม่มีเขตเวลา] | 8 ไบต์ | ช่วงเวลาของวัน (ไม่มีวันที่) | 00:00:00 น | 24:00:00 น |
| เวลา [(p)] พร้อมเขตเวลา | 12 ไบต์ | ช่วงเวลาของวันเท่านั้นพร้อมเขตเวลา | 00: 00: 00 + 1459 | 24: 00: 00-1459 |
| ช่วงเวลา [ฟิลด์] [(p)] | 12 ไบต์ | ช่วงเวลา | -178000000 ปี | 178000000 ปี |
ประเภทบูลีน
PostgreSQL จัดเตรียม Boolean ประเภท SQL มาตรฐาน บูลีนชนิดข้อมูลสามารถมีรัฐจริง , เท็จและเป็นรัฐที่สามที่ไม่รู้จักซึ่งเป็นตัวแทนโดยค่า null SQL
| ชื่อ | ขนาดการจัดเก็บ | คำอธิบาย |
|---|---|---|
| บูลีน | 1 ไบต์ | สถานะเป็นจริงหรือเท็จ |
ประเภทแจกแจง
ประเภท Enumerated (enum) คือชนิดข้อมูลที่ประกอบด้วยชุดค่าคงที่ตามลำดับ เทียบเท่ากับประเภท enum ที่รองรับในภาษาโปรแกรมหลายภาษา
ไม่เหมือนกับประเภทอื่น ๆ ประเภท Enumerated ต้องสร้างโดยใช้คำสั่ง CREATE TYPE ประเภทนี้ใช้เพื่อจัดเก็บชุดค่าคงที่ตามลำดับ ตัวอย่างเช่นทิศทางของเข็มทิศเช่นทิศตะวันตกเฉียงใต้ทิศตะวันออกและทิศตะวันตกหรือวันในสัปดาห์ดังที่แสดงด้านล่าง -
CREATE TYPE week AS ENUM ('Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun');แจกแจงสร้างครั้งเดียวใช้ได้เหมือนชนิดอื่น ๆ
ประเภทเรขาคณิต
ชนิดข้อมูลทางเรขาคณิตแสดงถึงวัตถุเชิงพื้นที่สองมิติ ประเภทพื้นฐานที่สุดประเด็นเป็นพื้นฐานสำหรับประเภทอื่น ๆ ทั้งหมด
| ชื่อ | ขนาดการจัดเก็บ | การเป็นตัวแทน | คำอธิบาย |
|---|---|---|---|
| จุด | 16 ไบต์ | ชี้ไปที่เครื่องบิน | (x, y) |
| ไลน์ | 32 ไบต์ | เส้นไม่มีที่สิ้นสุด (ไม่ได้ใช้งานอย่างสมบูรณ์) | ((x1, y1), (x2, y2)) |
| lseg | 32 ไบต์ | ส่วนของเส้นตรง จำกัด | ((x1, y1), (x2, y2)) |
| กล่อง | 32 ไบต์ | กล่องสี่เหลี่ยม | ((x1, y1), (x2, y2)) |
| เส้นทาง | 16 + 16n ไบต์ | เส้นทางปิด (คล้ายกับรูปหลายเหลี่ยม) | ((x1, y1), ... ) |
| เส้นทาง | 16 + 16n ไบต์ | เปิดเส้นทาง | [(x1, y1), ... ] |
| รูปหลายเหลี่ยม | 40 + 16 น | รูปหลายเหลี่ยม (คล้ายกับเส้นทางปิด) | ((x1, y1), ... ) |
| วงกลม | 24 ไบต์ | วงกลม | <(x, y), r> (จุดศูนย์กลางและรัศมี) |
ประเภทที่อยู่เครือข่าย
PostgreSQL เสนอประเภทข้อมูลเพื่อจัดเก็บที่อยู่ IPv4, IPv6 และ MAC ควรใช้ประเภทเหล่านี้แทนประเภทข้อความธรรมดาในการจัดเก็บที่อยู่เครือข่ายเนื่องจากประเภทเหล่านี้มีการตรวจสอบข้อผิดพลาดในการป้อนข้อมูลและตัวดำเนินการและฟังก์ชันเฉพาะ
| ชื่อ | ขนาดการจัดเก็บ | คำอธิบาย |
|---|---|---|
| cidr | 7 หรือ 19 ไบต์ | เครือข่าย IPv4 และ IPv6 |
| inet | 7 หรือ 19 ไบต์ | โฮสต์และเครือข่าย IPv4 และ IPv6 |
| macaddr | 6 ไบต์ | ที่อยู่ MAC |
ประเภทสตริงบิต
ประเภทสตริงบิตใช้เพื่อจัดเก็บมาสก์บิต พวกเขาเป็น 0 หรือ 1 มีสองประเภทบิต SQL:bit(n) และ bit varying(n)โดยที่ n คือจำนวนเต็มบวก
ประเภทการค้นหาข้อความ
ประเภทนี้รองรับการค้นหาข้อความแบบเต็มซึ่งเป็นกิจกรรมของการค้นหาผ่านชุดเอกสารภาษาธรรมชาติเพื่อค้นหาเอกสารที่ตรงกับข้อความค้นหามากที่สุด มีข้อมูลสองประเภทสำหรับสิ่งนี้ -
| ส. เลขที่ | ชื่อและคำอธิบาย |
|---|---|
| 1 | tsvector นี่คือรายการเรียงลำดับของคำที่แตกต่างกันซึ่งได้รับการทำให้เป็นมาตรฐานเพื่อรวมรูปแบบต่างๆของคำเดียวกันซึ่งเรียกว่า "lexemes" |
| 2 | tsquery นี้จัดเก็บคำศัพท์ที่ต้องการค้นหาและรวมคำศัพท์เหล่านี้ไว้เพื่อเคารพตัวดำเนินการบูลีน & (AND) (หรือ) และ! (ไม่). วงเล็บสามารถใช้เพื่อบังคับใช้การจัดกลุ่มของตัวดำเนินการ |
ประเภท UUID
UUID (Universally Unique Identifiers) เขียนเป็นลำดับของเลขฐานสิบหกตัวพิมพ์เล็กในหลาย ๆ กลุ่มคั่นด้วยยัติภังค์โดยเฉพาะกลุ่มของตัวเลขแปดหลักตามด้วยสามกลุ่มสี่หลักตามด้วยกลุ่ม 12 หลักสำหรับ จำนวน 32 หลักแทน 128 บิต
ตัวอย่างของ UUID คือ - 550e8400-e29b-41d4-a716-446655440000
ประเภท XML
ชนิดข้อมูล XML สามารถใช้เพื่อจัดเก็บข้อมูล XML สำหรับการจัดเก็บข้อมูล XML อันดับแรกคุณต้องสร้างค่า XML โดยใช้ฟังก์ชัน xmlparse ดังนี้ -
XMLPARSE (DOCUMENT '<?xml version="1.0"?>
<tutorial>
<title>PostgreSQL Tutorial </title>
<topics>...</topics>
</tutorial>')
XMLPARSE (CONTENT 'xyz<foo>bar</foo><bar>foo</bar>')ประเภท JSON
JSONชนิดข้อมูลสามารถนำมาใช้ในการจัดเก็บข้อมูล JSON (JavaScript Object สัญลักษณ์) ข้อมูลดังกล่าวสามารถจัดเก็บเป็นข้อความได้เช่นกัน แต่ชนิดข้อมูลjsonมีข้อดีในการตรวจสอบว่าค่าที่จัดเก็บแต่ละค่าเป็นค่า JSON ที่ถูกต้อง นอกจากนี้ยังมีฟังก์ชันการสนับสนุนที่เกี่ยวข้องซึ่งสามารถใช้โดยตรงเพื่อจัดการกับประเภทข้อมูล JSON ดังต่อไปนี้
| ตัวอย่าง | ตัวอย่างผลลัพธ์ |
|---|---|
| array_to_json ('{{1,5}, {99,100}}' :: int []) | [[1,5], [99,100]] |
| row_to_json (แถว (1, 'foo')) | {"f1": 1, "f2": "foo"} |
ประเภทอาร์เรย์
PostgreSQL เปิดโอกาสให้กำหนดคอลัมน์ของตารางเป็นอาร์เรย์หลายมิติที่มีความยาวตัวแปร สามารถสร้างอาร์เรย์ของประเภทฐานในตัวหรือชนิดของ enum หรือประเภทคอมโพสิตที่กำหนดเองได้
การประกาศอาร์เรย์
ประเภทอาร์เรย์สามารถประกาศเป็น
CREATE TABLE monthly_savings (
name text,
saving_per_quarter integer[],
scheme text[][]
);หรือโดยใช้คำหลัก "ARRAY" เป็น
CREATE TABLE monthly_savings (
name text,
saving_per_quarter integer ARRAY[4],
scheme text[][]
);การแทรกค่า
ค่าอาร์เรย์สามารถแทรกเป็นค่าคงที่ตามตัวอักษรโดยใส่ค่าองค์ประกอบไว้ในวงเล็บปีกกาและคั่นด้วยเครื่องหมายจุลภาค ตัวอย่างแสดงด้านล่าง -
INSERT INTO monthly_savings
VALUES (‘Manisha’,
‘{20000, 14600, 23500, 13250}’,
‘{{“FD”, “MF”}, {“FD”, “Property”}}’);การเข้าถึงอาร์เรย์
ตัวอย่างสำหรับการเข้าถึง Arrays แสดงอยู่ด้านล่าง คำสั่งที่ระบุด้านล่างนี้จะเลือกผู้ที่มีเงินออมในไตรมาสที่สองมากกว่าไตรมาสที่สี่
SELECT name FROM monhly_savings WHERE saving_per_quarter[2] > saving_per_quarter[4];การปรับเปลี่ยนอาร์เรย์
ตัวอย่างการแก้ไขอาร์เรย์มีดังที่แสดงด้านล่าง
UPDATE monthly_savings SET saving_per_quarter = '{25000,25000,27000,27000}'
WHERE name = 'Manisha';หรือใช้ไวยากรณ์ของนิพจน์ ARRAY -
UPDATE monthly_savings SET saving_per_quarter = ARRAY[25000,25000,27000,27000]
WHERE name = 'Manisha';กำลังค้นหาอาร์เรย์
ตัวอย่างการค้นหาอาร์เรย์มีดังที่แสดงด้านล่าง
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;หากทราบขนาดของอาร์เรย์สามารถใช้วิธีการค้นหาที่ระบุข้างต้นได้ อื่น ๆ ตัวอย่างต่อไปนี้แสดงวิธีการค้นหาเมื่อไม่ทราบขนาด
SELECT * FROM monthly_savings WHERE 10000 = ANY (saving_per_quarter);ประเภทคอมโพสิต
ประเภทนี้แสดงถึงรายชื่อเขตข้อมูลและชนิดข้อมูลกล่าวคือโครงสร้างของแถวหรือระเบียนของตาราง
การประกาศประเภทคอมโพสิต
ตัวอย่างต่อไปนี้แสดงวิธีการประกาศประเภทคอมโพสิต
CREATE TYPE inventory_item AS (
name text,
supplier_id integer,
price numeric
);ชนิดข้อมูลนี้สามารถใช้ในตารางสร้างดังต่อไปนี้ -
CREATE TABLE on_hand (
item inventory_item,
count integer
);การป้อนค่าคอมโพสิต
ค่าคอมโพสิตสามารถแทรกเป็นค่าคงที่ตามตัวอักษรโดยใส่ค่าฟิลด์ไว้ในวงเล็บและคั่นด้วยเครื่องหมายจุลภาค ตัวอย่างแสดงด้านล่าง -
INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);สิ่งนี้ถูกต้องสำหรับรายการสินค้าคงคลังที่กำหนดไว้ด้านบน คีย์เวิร์ด ROW เป็นทางเลือกหากคุณมีฟิลด์มากกว่าหนึ่งฟิลด์ในนิพจน์
การเข้าถึงประเภทคอมโพสิต
ในการเข้าถึงช่องของคอลัมน์ผสมให้ใช้จุดตามด้วยชื่อเขตข้อมูลเช่นเดียวกับการเลือกเขตข้อมูลจากชื่อตาราง ตัวอย่างเช่นในการเลือกเขตข้อมูลย่อยบางส่วนจากตารางตัวอย่างบนมือของเราแบบสอบถามจะเป็นดังที่แสดงด้านล่าง -
SELECT (item).name FROM on_hand WHERE (item).price > 9.99;คุณยังสามารถใช้ชื่อตารางได้เช่นกัน (ตัวอย่างเช่นในการสืบค้นหลายรายการ) เช่นนี้ -
SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;ประเภทช่วง
ประเภทช่วงแสดงถึงชนิดข้อมูลที่ใช้ช่วงข้อมูล ประเภทของช่วงสามารถเป็นช่วงที่ไม่ต่อเนื่อง (เช่นค่าจำนวนเต็ม 1 ถึง 10 ทั้งหมด) หรือช่วงต่อเนื่อง (เช่นช่วงเวลาใด ๆ ระหว่าง 10.00 น. ถึง 11.00 น.)
ประเภทของช่วงในตัวที่มีให้ ได้แก่ ช่วงต่อไปนี้
int4range - ช่วงของจำนวนเต็ม
int8range - ช่วงของ bigint
numrange - ช่วงของตัวเลข
tsrange - ช่วงของการประทับเวลาโดยไม่มีเขตเวลา
tstzrange - ช่วงของการประทับเวลากับเขตเวลา
daterange - ช่วงวันที่
คุณสามารถสร้างประเภทช่วงที่กำหนดเองเพื่อให้มีช่วงประเภทใหม่ ๆ เช่นช่วงที่อยู่ IP โดยใช้ประเภท inet เป็นฐานหรือช่วงลอยโดยใช้ประเภทข้อมูลลอยเป็นฐาน
ประเภทช่วงรองรับขอบเขตช่วงที่รวมและพิเศษโดยใช้อักขระ [] และ () ตามลำดับ ตัวอย่างเช่น "[4,9)" หมายถึงจำนวนเต็มทั้งหมดที่เริ่มต้นจากและรวม 4 ถึง แต่ไม่รวม 9
ประเภทตัวระบุวัตถุ
ตัวระบุอ็อบเจ็กต์ (OID) ถูกใช้ภายในโดย PostgreSQL เป็นคีย์หลักสำหรับตารางระบบต่างๆ หากระบุด้วย OIDSหรือเปิดใช้งานตัวแปรคอนฟิกูเรชันdefault_with_oidsเฉพาะในกรณีเช่นนี้จะเพิ่ม OID ลงในตารางที่ผู้ใช้สร้าง ตารางต่อไปนี้แสดงนามแฝงหลายประเภท ชนิดนามแฝง OID ไม่มีการดำเนินการของตนเองยกเว้นรูทีนอินพุตและเอาต์พุตเฉพาะ
| ชื่อ | อ้างอิง | คำอธิบาย | ตัวอย่างค่า |
|---|---|---|---|
| oid | ใด ๆ | ตัวระบุวัตถุที่เป็นตัวเลข | 564182 |
| regproc | pg_proc | ชื่อฟังก์ชัน | ผลรวม |
| regprocedure | pg_proc | ฟังก์ชันที่มีประเภทอาร์กิวเมนต์ | ผลรวม (int4) |
| regoper | pg_operator | ชื่อผู้ดำเนินการ | + |
| ผู้ควบคุม | pg_operator | ตัวดำเนินการที่มีประเภทอาร์กิวเมนต์ | * (จำนวนเต็มจำนวนเต็ม) หรือ - (ไม่มีจำนวนเต็ม) |
| regclass | pg_class | ชื่อความสัมพันธ์ | pg_type |
| regtype | pg_type | ชื่อชนิดข้อมูล | จำนวนเต็ม |
| regconfig | pg_ts_config | การกำหนดค่าการค้นหาข้อความ | ภาษาอังกฤษ |
| regdictionary | pg_ts_dict | พจนานุกรมค้นหาข้อความ | เรียบง่าย |
ประเภทหลอก
ระบบชนิด PostgreSQL ประกอบด้วยรายการวัตถุประสงค์พิเศษจำนวนหนึ่งซึ่งเรียกรวมกันว่าประเภทหลอก ไม่สามารถใช้ประเภทหลอกเป็นชนิดข้อมูลคอลัมน์ แต่สามารถใช้เพื่อประกาศอาร์กิวเมนต์ของฟังก์ชันหรือประเภทผลลัพธ์ได้
ตารางด้านล่างแสดงรายการประเภทหลอกที่มีอยู่
| ส. เลขที่ | ชื่อและคำอธิบาย |
|---|---|
| 1 | any ระบุว่าฟังก์ชันยอมรับชนิดข้อมูลอินพุตใด ๆ |
| 2 | anyelement ระบุว่าฟังก์ชันยอมรับชนิดข้อมูลใด ๆ |
| 3 | anyarray ระบุว่าฟังก์ชันยอมรับชนิดข้อมูลอาร์เรย์ใด ๆ |
| 4 | anynonarray ระบุว่าฟังก์ชันยอมรับชนิดข้อมูลที่ไม่ใช่อาร์เรย์ |
| 5 | anyenum ระบุว่าฟังก์ชันยอมรับชนิดข้อมูล enum ใด ๆ |
| 6 | anyrange ระบุว่าฟังก์ชันยอมรับชนิดข้อมูลช่วงใด ๆ |
| 7 | cstring ระบุว่าฟังก์ชันยอมรับหรือส่งคืนสตริง C ที่สิ้นสุดด้วยค่า null |
| 8 | internal บ่งชี้ว่าฟังก์ชันยอมรับหรือส่งคืนชนิดข้อมูลภายในเซิร์ฟเวอร์ |
| 9 | language_handler ตัวจัดการการเรียกภาษาขั้นตอนถูกประกาศให้ส่งคืน language_handler |
| 10 | fdw_handler มีการประกาศว่า Foreign-data wrapper handler จะส่งคืน fdw_handler |
| 11 | record ระบุฟังก์ชันที่ส่งคืนประเภทแถวที่ไม่ระบุ |
| 12 | trigger มีการประกาศฟังก์ชันทริกเกอร์เพื่อส่งคืนทริกเกอร์ |
| 13 | void ระบุว่าฟังก์ชันไม่ส่งคืนค่า |
บทนี้กล่าวถึงวิธีการสร้างฐานข้อมูลใหม่ใน PostgreSQL ของคุณ PostgreSQL มีสองวิธีในการสร้างฐานข้อมูลใหม่ -
- ใช้ CREATE DATABASE คำสั่ง SQL
- ใช้createdbบรรทัดคำสั่งปฏิบัติการ
การใช้ CREATE DATABASE
คำสั่งนี้จะสร้างฐานข้อมูลจาก PostgreSQL shell prompt แต่คุณควรมีสิทธิ์ที่เหมาะสมในการสร้างฐานข้อมูล ตามค่าเริ่มต้นฐานข้อมูลใหม่จะถูกสร้างขึ้นโดยการโคลนเทมเพลตฐานข้อมูลระบบมาตรฐาน1
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง CREATE DATABASE มีดังนี้ -
CREATE DATABASE dbname;โดยที่dbnameเป็นชื่อของฐานข้อมูลที่จะสร้าง
ตัวอย่าง
ต่อไปนี้เป็นตัวอย่างง่ายๆซึ่งจะสร้าง testdb ในสคีมา PostgreSQL ของคุณ
postgres=# CREATE DATABASE testdb;
postgres-#ใช้คำสั่ง createdb
PostgreSQL บรรทัดคำสั่งปฏิบัติการcreatedbเป็นเสื้อคลุมรอบคำสั่งของ SQL สร้างฐานข้อมูล ข้อแตกต่างเพียงอย่างเดียวระหว่างคำสั่งนี้และคำสั่ง SQL สร้างฐานข้อมูลคือคำสั่งเดิมสามารถเรียกใช้โดยตรงจากบรรทัดคำสั่งและอนุญาตให้เพิ่มข้อคิดเห็นลงในฐานข้อมูลทั้งหมดในคำสั่งเดียว
ไวยากรณ์
ไวยากรณ์สำหรับcreatedbดังที่แสดงด้านล่าง -
createdb [option...] [dbname [description]]พารามิเตอร์
ตารางด้านล่างแสดงรายการพารามิเตอร์พร้อมคำอธิบาย
| ส. เลขที่ | พารามิเตอร์และคำอธิบาย |
|---|---|
| 1 | dbname ชื่อของฐานข้อมูลที่จะสร้าง |
| 2 | description ระบุข้อคิดเห็นที่จะเชื่อมโยงกับฐานข้อมูลที่สร้างขึ้นใหม่ |
| 3 | options อาร์กิวเมนต์บรรทัดคำสั่งซึ่ง createdb ยอมรับ |
ตัวเลือก
ตารางต่อไปนี้แสดงรายการอาร์กิวเมนต์บรรทัดคำสั่งที่สร้างขึ้น b ยอมรับ -
| ส. เลขที่ | ตัวเลือกและคำอธิบาย |
|---|---|
| 1 | -D tablespace ระบุพื้นที่ตารางเริ่มต้นสำหรับฐานข้อมูล |
| 2 | -e สะท้อนคำสั่งที่ createdb สร้างและส่งไปยังเซิร์ฟเวอร์ |
| 3 | -E encoding ระบุโครงร่างการเข้ารหัสอักขระที่จะใช้ในฐานข้อมูลนี้ |
| 4 | -l locale ระบุโลแคลที่จะใช้ในฐานข้อมูลนี้ |
| 5 | -T template ระบุฐานข้อมูลเทมเพลตที่จะสร้างฐานข้อมูลนี้ |
| 6 | --help แสดงความช่วยเหลือเกี่ยวกับอาร์กิวเมนต์บรรทัดคำสั่ง createdb และออก |
| 7 | -h host ระบุชื่อโฮสต์ของเครื่องที่เซิร์ฟเวอร์กำลังรัน |
| 8 | -p port ระบุพอร์ต TCP หรือนามสกุลไฟล์ซ็อกเก็ตโดเมน Unix โลคัลที่เซิร์ฟเวอร์กำลังรับฟังการเชื่อมต่อ |
| 9 | -U username ชื่อผู้ใช้ที่จะเชื่อมต่อเป็น. |
| 10 | -w อย่าออกพร้อมท์รหัสผ่าน |
| 11 | -W บังคับให้ createdb แจ้งรหัสผ่านก่อนเชื่อมต่อกับฐานข้อมูล |
เปิดพรอมต์คำสั่งและไปที่ไดเร็กทอรีที่ติดตั้ง PostgreSQL ไปที่ไดเร็กทอรี bin และดำเนินการคำสั่งต่อไปนี้เพื่อสร้างฐานข้อมูล
createdb -h localhost -p 5432 -U postgres testdb
password ******คำสั่งที่ระบุข้างต้นจะแจ้งให้คุณป้อนรหัสผ่านของผู้ใช้ผู้ดูแลระบบ PostgreSQL ซึ่งก็คือ postgres, โดยค่าเริ่มต้น. ดังนั้นระบุรหัสผ่านและดำเนินการสร้างฐานข้อมูลใหม่ของคุณ
เมื่อสร้างฐานข้อมูลโดยใช้วิธีการใดวิธีการหนึ่งที่กล่าวมาแล้วคุณสามารถตรวจสอบได้ในรายการฐานข้อมูลโดยใช้ \lกล่าวคือคำสั่ง backslash el ดังนี้ -
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-#บทนี้จะอธิบายวิธีการต่างๆในการเข้าถึงฐานข้อมูล สมมติว่าเราได้สร้างฐานข้อมูลไว้แล้วในบทที่แล้ว คุณสามารถเลือกฐานข้อมูลโดยใช้วิธีใดวิธีหนึ่งต่อไปนี้ -
- พร้อมรับคำ SQL ฐานข้อมูล
- พรอมต์คำสั่ง OS
พร้อมรับคำ SQL ฐานข้อมูล
สมมติว่าคุณได้เปิดตัวไคลเอนต์ PostgreSQL ของคุณแล้วและคุณได้มาที่พรอมต์ SQL ต่อไปนี้ -
postgres=#คุณสามารถตรวจสอบรายการฐานข้อมูลที่มีได้โดยใช้ \lกล่าวคือคำสั่ง backslash el ดังนี้ -
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-#ตอนนี้พิมพ์คำสั่งต่อไปนี้เพื่อเชื่อมต่อ / เลือกฐานข้อมูลที่ต้องการ ที่นี่เราจะเชื่อมต่อกับฐานข้อมูลtestdb
postgres=# \c testdb;
psql (9.2.4)
Type "help" for help.
You are now connected to database "testdb" as user "postgres".
testdb=#พรอมต์คำสั่ง OS
คุณสามารถเลือกฐานข้อมูลของคุณจากพรอมต์คำสั่งในเวลาที่คุณเข้าสู่ระบบฐานข้อมูลของคุณ ต่อไปนี้เป็นตัวอย่างง่ายๆ -
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=#ตอนนี้คุณเข้าสู่ PostgreSQL testdb และพร้อมที่จะดำเนินการคำสั่งของคุณใน testdb หากต้องการออกจากฐานข้อมูลคุณสามารถใช้คำสั่ง \ q
ในบทนี้เราจะพูดถึงวิธีการลบฐานข้อมูลใน PostgreSQL มีสองตัวเลือกในการลบฐานข้อมูล -
- การใช้ฐานข้อมูล DROP ซึ่งเป็นคำสั่ง SQL
- การใช้dropdbบรรทัดคำสั่งเรียกใช้งานได้
โปรดใช้ความระมัดระวังก่อนใช้การดำเนินการนี้เนื่องจากการลบฐานข้อมูลที่มีอยู่จะทำให้ข้อมูลทั้งหมดที่เก็บไว้ในฐานข้อมูลสูญหาย
การใช้ฐานข้อมูล DROP
คำสั่งนี้ลดฐานข้อมูล จะลบรายการแค็ตตาล็อกสำหรับฐานข้อมูลและลบไดเร็กทอรีที่มีข้อมูล สามารถดำเนินการได้โดยเจ้าของฐานข้อมูลเท่านั้น คำสั่งนี้ไม่สามารถดำเนินการได้ในขณะที่คุณหรือใครก็ตามเชื่อมต่อกับฐานข้อมูลเป้าหมาย (เชื่อมต่อกับ postgres หรือฐานข้อมูลอื่นเพื่อออกคำสั่งนี้)
ไวยากรณ์
ไวยากรณ์สำหรับฐานข้อมูล DROP ได้รับด้านล่าง -
DROP DATABASE [ IF EXISTS ] nameพารามิเตอร์
ตารางแสดงรายการพารามิเตอร์พร้อมคำอธิบาย
| ส. เลขที่ | พารามิเตอร์และคำอธิบาย |
|---|---|
| 1 | IF EXISTS อย่าโยนข้อผิดพลาดหากไม่มีฐานข้อมูล มีการออกประกาศในกรณีนี้ |
| 2 | name ชื่อของฐานข้อมูลที่จะลบ |
เราไม่สามารถวางฐานข้อมูลที่มีการเปิดการเชื่อมต่อใด ๆ รวมทั้งการเชื่อมต่อของเราเองจาก psqlหรือ pgAdmin III เราต้องเปลี่ยนไปใช้ฐานข้อมูลอื่นหรือ template1ถ้าเราต้องการลบฐานข้อมูลที่เราเชื่อมต่ออยู่ ดังนั้นจึงอาจสะดวกกว่าในการใช้โปรแกรม dropdbแทนซึ่งเป็น wrapper รอบคำสั่งนี้
ตัวอย่าง
ต่อไปนี้เป็นตัวอย่างง่ายๆซึ่งจะลบ testdb จากสคีมา PostgreSQL ของคุณ -
postgres=# DROP DATABASE testdb;
postgres-#ใช้คำสั่ง dropdb
สามารถเรียกใช้บรรทัดคำสั่ง PostgresSQL ได้ dropdbเป็นเสื้อคลุมบรรทัดคำสั่งรอบ SQL คำสั่งDROP DATABASE ไม่มีความแตกต่างที่มีประสิทธิภาพระหว่างการทิ้งฐานข้อมูลผ่านยูทิลิตี้นี้และด้วยวิธีการอื่นในการเข้าถึงเซิร์ฟเวอร์ dropdb ทำลายฐานข้อมูล PostgreSQL ที่มีอยู่ ผู้ใช้ที่เรียกใช้คำสั่งนี้ต้องเป็นผู้ใช้ขั้นสูงของฐานข้อมูลหรือเจ้าของฐานข้อมูล
ไวยากรณ์
ไวยากรณ์สำหรับdropdbดังที่แสดงด้านล่าง -
dropdb [option...] dbnameพารามิเตอร์
ตารางต่อไปนี้แสดงรายการพารามิเตอร์พร้อมคำอธิบาย
| ส. เลขที่ | พารามิเตอร์และคำอธิบาย |
|---|---|
| 1 | dbname ชื่อของฐานข้อมูลที่จะลบ |
| 2 | option อาร์กิวเมนต์บรรทัดคำสั่งซึ่ง dropdb ยอมรับ |
ตัวเลือก
ตารางต่อไปนี้แสดงรายการอาร์กิวเมนต์บรรทัดคำสั่งที่ dropdb ยอมรับ -
| ส. เลขที่ | ตัวเลือกและคำอธิบาย |
|---|---|
| 1 | -e แสดงคำสั่งที่ส่งไปยังเซิร์ฟเวอร์ |
| 2 | -i ออกข้อความแจ้งการตรวจสอบก่อนที่จะดำเนินการใด ๆ ที่เป็นการทำลายล้าง |
| 3 | -V พิมพ์เวอร์ชัน dropdb แล้วออก |
| 4 | --if-exists อย่าโยนข้อผิดพลาดหากไม่มีฐานข้อมูล มีการออกประกาศในกรณีนี้ |
| 5 | --help แสดงความช่วยเหลือเกี่ยวกับอาร์กิวเมนต์บรรทัดคำสั่ง dropdb และออก |
| 6 | -h host ระบุชื่อโฮสต์ของเครื่องที่เซิร์ฟเวอร์กำลังรัน |
| 7 | -p port ระบุพอร์ต TCP หรือนามสกุลไฟล์ซ็อกเก็ตโดเมน UNIX โลคัลที่เซิร์ฟเวอร์กำลังรับฟังการเชื่อมต่อ |
| 8 | -U username ชื่อผู้ใช้ที่จะเชื่อมต่อเป็น. |
| 9 | -w อย่าออกพร้อมท์รหัสผ่าน |
| 10 | -W บังคับให้ dropdb แจ้งรหัสผ่านก่อนเชื่อมต่อกับฐานข้อมูล |
| 11 | --maintenance-db=dbname ระบุชื่อของฐานข้อมูลที่จะเชื่อมต่อเพื่อดร็อปฐานข้อมูลเป้าหมาย |
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการลบฐานข้อมูลจากพรอมต์คำสั่ง OS -
dropdb -h localhost -p 5432 -U postgress testdb
Password for user postgress: ****คำสั่งดังกล่าวลดฐานข้อมูล testdb. ที่นี่ฉันใช้ไฟล์postgres (อยู่ภายใต้ pg_roles ของ template1) ชื่อผู้ใช้เพื่อวางฐานข้อมูล
คำสั่ง PostgreSQL CREATE TABLE ใช้เพื่อสร้างตารางใหม่ในฐานข้อมูลที่กำหนด
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง CREATE TABLE มีดังนี้ -
CREATE TABLE table_name(
column1 datatype,
column2 datatype,
column3 datatype,
.....
columnN datatype,
PRIMARY KEY( one or more columns )
);CREATE TABLE คือคีย์เวิร์ดบอกระบบฐานข้อมูลให้สร้างตารางใหม่ ชื่อเฉพาะหรือตัวระบุสำหรับตารางเป็นไปตามคำสั่ง CREATE TABLE ในขั้นต้นตารางว่างในฐานข้อมูลปัจจุบันเป็นของผู้ใช้ที่ออกคำสั่ง
จากนั้นในวงเล็บจะแสดงรายการกำหนดแต่ละคอลัมน์ในตารางและประเภทข้อมูลประเภทใด ไวยากรณ์จะชัดเจนขึ้นด้วยตัวอย่างด้านล่าง
ตัวอย่าง
ต่อไปนี้เป็นตัวอย่างซึ่งสร้างตาราง COMPANY ที่มี ID เป็นคีย์หลักและ NOT NULL เป็นข้อ จำกัด ที่แสดงว่าฟิลด์เหล่านี้ไม่สามารถเป็น NULL ได้ในขณะที่สร้างเรกคอร์ดในตารางนี้ -
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);ให้เราสร้างตารางขึ้นมาอีกหนึ่งตารางซึ่งเราจะใช้ในแบบฝึกหัดในบทต่อ ๆ ไป -
CREATE TABLE DEPARTMENT(
ID INT PRIMARY KEY NOT NULL,
DEPT CHAR(50) NOT NULL,
EMP_ID INT NOT NULL
);คุณสามารถตรวจสอบได้ว่าตารางของคุณสร้างสำเร็จหรือไม่โดยใช้ \d คำสั่งซึ่งจะใช้เพื่อแสดงรายการตารางทั้งหมดในฐานข้อมูลที่แนบมา
testdb-# \dคำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | company | table | postgres
public | department | table | postgres
(2 rows)ใช้ \d tablename เพื่ออธิบายแต่ละตารางดังที่แสดงด้านล่าง -
testdb-# \d companyคำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)คำสั่ง PostgreSQL DROP TABLE ใช้เพื่อลบนิยามตารางและข้อมูลดัชนีกฎทริกเกอร์และข้อ จำกัด ที่เกี่ยวข้องทั้งหมดสำหรับตารางนั้น
คุณต้องระวังขณะใช้คำสั่งนี้เพราะเมื่อลบตารางแล้วข้อมูลทั้งหมดที่มีอยู่ในตารางก็จะหายไปตลอดกาล
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง DROP TABLE มีดังนี้ -
DROP TABLE table_name;ตัวอย่าง
เราได้สร้างตาราง DEPARTMENT และ COMPANY ในบทที่แล้ว ขั้นแรกตรวจสอบตารางเหล่านี้ (ใช้\d เพื่อแสดงรายการตาราง) -
testdb-# \dสิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
List of relations
Schema | Name | Type | Owner
--------+------------+-------+----------
public | company | table | postgres
public | department | table | postgres
(2 rows)ซึ่งหมายความว่ามีตาราง DEPARTMENT และ COMPANY ดังนั้นให้เราวางไว้ดังนี้ -
testdb=# drop table department, company;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
DROP TABLE
testdb=# \d
relations found.
testdb=#ข้อความที่ส่งคืน DROP TABLE บ่งชี้ว่าคำสั่ง drop ดำเนินการสำเร็จแล้ว
ก schemaคือชุดของตารางที่มีชื่อ สคีมายังสามารถมีมุมมองดัชนีลำดับชนิดข้อมูลตัวดำเนินการและฟังก์ชัน Schemas นั้นคล้ายคลึงกับไดเร็กทอรีในระดับระบบปฏิบัติการยกเว้นว่าสกีมาจะไม่สามารถซ้อนกันได้ คำสั่ง PostgreSQL CREATE SCHEMA สร้างสคีมา
ไวยากรณ์
ไวยากรณ์พื้นฐานของ CREATE SCHEMA มีดังนี้ -
CREATE SCHEMA name;โดยที่ชื่อคือชื่อของสคีมา
ไวยากรณ์ในการสร้างตารางในสคีมา
ไวยากรณ์พื้นฐานในการสร้างตารางในสคีมามีดังนี้ -
CREATE TABLE myschema.mytable (
...
);ตัวอย่าง
ให้เราดูตัวอย่างสำหรับการสร้างสคีมา เชื่อมต่อกับฐานข้อมูลtestdbและสร้าง schema myschemaดังนี้ -
testdb=# create schema myschema;
CREATE SCHEMAข้อความ "CREATE SCHEMA" แสดงว่าสร้างสคีมาสำเร็จแล้ว
ตอนนี้ให้เราสร้างตารางในสคีมาด้านบนดังนี้ -
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)
);สิ่งนี้จะสร้างตารางว่าง คุณสามารถตรวจสอบตารางที่สร้างขึ้นด้วยคำสั่งด้านล่าง -
testdb=# select * from myschema.company;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+------+-----+---------+--------
(0 rows)ไวยากรณ์ที่จะวางสคีมา
หากต้องการวางสคีมาหากว่างเปล่า (วัตถุทั้งหมดในนั้นถูกทิ้ง) ให้ใช้คำสั่ง -
DROP SCHEMA myschema;ในการวางสคีมารวมทั้งวัตถุที่มีอยู่ทั้งหมดให้ใช้คำสั่ง -
DROP SCHEMA myschema CASCADE;ข้อดีของการใช้ Schema
ช่วยให้ผู้ใช้จำนวนมากสามารถใช้ฐานข้อมูลเดียวโดยไม่รบกวนกันและกัน
จัดระเบียบวัตถุฐานข้อมูลเป็นกลุ่มตรรกะเพื่อให้จัดการได้ง่ายขึ้น
แอปพลิเคชันของบุคคลที่สามสามารถใส่ลงในสกีมาแยกกันเพื่อไม่ให้ชนกับชื่อของวัตถุอื่น ๆ
PostgreSQL INSERT INTOคำสั่งอนุญาตให้แทรกแถวใหม่ลงในตาราง หนึ่งสามารถแทรกทีละแถวหรือหลายแถวอันเป็นผลมาจากแบบสอบถาม
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง INSERT INTO มีดังนี้ -
INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);ที่นี่ column1, column2, ... columnN คือชื่อของคอลัมน์ในตารางที่คุณต้องการแทรกข้อมูล
ชื่อคอลัมน์เป้าหมายสามารถแสดงในลำดับใดก็ได้ ค่าที่จัดทำโดยส่วนคำสั่งหรือแบบสอบถาม VALUES เชื่อมโยงกับรายการคอลัมน์ที่ชัดเจนหรือโดยปริยายจากซ้ายไปขวา
คุณอาจไม่จำเป็นต้องระบุชื่อคอลัมน์ในแบบสอบถาม SQL หากคุณกำลังเพิ่มค่าสำหรับคอลัมน์ทั้งหมดของตาราง อย่างไรก็ตามตรวจสอบให้แน่ใจว่าลำดับของค่าอยู่ในลำดับเดียวกันกับคอลัมน์ในตาราง ไวยากรณ์ของ SQL INSERT INTO จะเป็นดังนี้ -
INSERT INTO TABLE_NAME VALUES (value1,value2,value3,...valueN);เอาต์พุต
ตารางต่อไปนี้สรุปข้อความผลลัพธ์และความหมาย -
| ส. เลขที่ | ข้อความแสดงผลและคำอธิบาย |
|---|---|
| 1 | INSERT oid 1 ข้อความจะกลับมาหากมีการแทรกเพียงแถวเดียว oid คือ OID ที่เป็นตัวเลขของแถวที่แทรก |
| 2 | INSERT 0 # ข้อความจะส่งคืนหากมีการแทรกมากกว่าหนึ่งแถว # คือจำนวนแถวที่แทรก |
ตัวอย่าง
ให้เราสร้างตาราง COMPANY ใน testdb ดังต่อไปนี้ -
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
);ตัวอย่างต่อไปนี้แทรกแถวในตาราง COMPANY -
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (1, 'Paul', 32, 'California', 20000.00,'2001-07-13');ตัวอย่างต่อไปนี้คือการแทรกแถว คอลัมน์เงินเดือนที่นี่จะถูกละเว้นดังนั้นจึงมีค่าเริ่มต้น -
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,JOIN_DATE) VALUES (2, 'Allen', 25, 'Texas', '2007-12-13');ตัวอย่างต่อไปนี้ใช้อนุประโยค DEFAULT สำหรับคอลัมน์ JOIN_DATE แทนที่จะระบุค่า -
INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY,JOIN_DATE) VALUES (3, 'Teddy', 23, 'Norway', 20000.00, DEFAULT );ตัวอย่างต่อไปนี้แทรกหลายแถวโดยใช้ไวยากรณ์ 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');ข้อความข้างต้นทั้งหมดจะสร้างบันทึกต่อไปนี้ในตาราง COMPANY บทต่อไปจะสอนวิธีแสดงระเบียนเหล่านี้ทั้งหมดจากตาราง
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-13PostgreSQL SELECTคำสั่งใช้เพื่อดึงข้อมูลจากตารางฐานข้อมูลซึ่งส่งคืนข้อมูลในรูปแบบของตารางผลลัพธ์ ตารางผลลัพธ์เหล่านี้เรียกว่าชุดผลลัพธ์
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง SELECT มีดังนี้ -
SELECT column1, column2, columnN FROM table_name;ที่นี่ column1, column2 ... คือฟิลด์ของตารางซึ่งมีค่าที่คุณต้องการดึงข้อมูล หากคุณต้องการดึงฟิลด์ทั้งหมดที่มีอยู่ในฟิลด์คุณสามารถใช้ไวยากรณ์ต่อไปนี้ -
SELECT * FROM table_name;ตัวอย่าง
พิจารณาตาราง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)ต่อไปนี้เป็นตัวอย่างซึ่งจะดึงข้อมูล ID ชื่อและฟิลด์เงินเดือนของลูกค้าที่มีอยู่ในตาราง CUSTOMERS -
testdb=# SELECT ID, NAME, SALARY FROM COMPANY ;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)หากคุณต้องการดึงฟิลด์ทั้งหมดของตาราง CUSTOMERS ให้ใช้แบบสอบถามต่อไปนี้ -
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)Operator ใน PostgreSQL คืออะไร?
ตัวดำเนินการคือคำสงวนหรืออักขระที่ใช้เป็นหลักในส่วนคำสั่ง WHERE ของคำสั่ง PostgreSQL เพื่อดำเนินการเช่นการเปรียบเทียบและการคำนวณทางคณิตศาสตร์
ตัวดำเนินการถูกใช้เพื่อระบุเงื่อนไขในคำสั่ง PostgreSQL และเพื่อทำหน้าที่เป็นคำสันธานสำหรับหลายเงื่อนไขในคำสั่ง
- ตัวดำเนินการเลขคณิต
- ตัวดำเนินการเปรียบเทียบ
- ตัวดำเนินการทางตรรกะ
- ตัวดำเนินการ Bitwise
ตัวดำเนินการทางคณิตศาสตร์ PostgreSQL
สมมติตัวแปร a ถือ 2 และตัวแปร b ถือ 3 แล้ว -
ตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| + | การเพิ่ม - เพิ่มค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ | a + b จะให้ 5 |
| - | การลบ - ลบตัวถูกดำเนินการทางขวามือจากตัวถูกดำเนินการด้านซ้าย | a - b จะให้ -1 |
| * | การคูณ - คูณค่าที่ด้านใดด้านหนึ่งของตัวดำเนินการ | a * b จะให้ 6 |
| / | หาร - แบ่งตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการทางขวามือ | b / a จะให้ 1 |
| % | โมดูลัส - แบ่งตัวถูกดำเนินการทางซ้ายด้วยตัวถูกดำเนินการด้านขวาและส่งกลับส่วนที่เหลือ | b% a จะให้ 1 |
| ^ | Exponentiation - ให้ค่าเลขชี้กำลังของตัวถูกดำเนินการทางขวามือ | a ^ b จะให้ 8 |
| | / | รากที่สอง | | / 25.0 จะให้ 5 |
| || / | รูทลูกบาศก์ | || / 27.0 จะให้ 3 |
| ! | แฟกทอเรียล | 5! จะให้ 120 |
| !! | แฟกทอเรียล (ตัวดำเนินการคำนำหน้า) | !! 5 จะให้ 120 |
ตัวดำเนินการเปรียบเทียบ PostgreSQL
สมมติตัวแปร a ถือ 10 และตัวแปร b ถือ 20 จากนั้น -
แสดงตัวอย่าง
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| = | ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (a = b) ไม่เป็นความจริง |
| ! = | ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง | (a! = b) เป็นจริง |
| <> | ตรวจสอบว่าค่าของตัวถูกดำเนินการสองค่าเท่ากันหรือไม่หากค่าไม่เท่ากันเงื่อนไขจะกลายเป็นจริง | (a <> b) เป็นจริง |
| > | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (a> b) ไม่เป็นความจริง |
| < | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (a <b) เป็นจริง |
| > = | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายมากกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (a> = b) ไม่เป็นความจริง |
| <= | ตรวจสอบว่าค่าของตัวถูกดำเนินการด้านซ้ายน้อยกว่าหรือเท่ากับค่าของตัวถูกดำเนินการด้านขวาหรือไม่ถ้าใช่เงื่อนไขจะกลายเป็นจริง | (a <= b) เป็นจริง |
ตัวดำเนินการตรรกะ PostgreSQL
นี่คือรายการของตัวดำเนินการเชิงตรรกะทั้งหมดที่มีอยู่ใน PostgresSQL
แสดงตัวอย่าง
| ส. เลขที่ | ตัวดำเนินการและคำอธิบาย |
|---|---|
| 1 | AND ตัวดำเนินการ AND อนุญาตให้มีหลายเงื่อนไขในคำสั่งของคำสั่ง PostgresSQL WHERE |
| 2 | NOT ตัวดำเนินการ NOT จะกลับความหมายของตัวดำเนินการทางตรรกะที่ใช้ เช่น. ไม่ออกไม่ระหว่างไม่อยู่ใน ฯลฯThis is negate operator. |
| 3 | OR ตัวดำเนินการ OR ใช้เพื่อรวมหลายเงื่อนไขในคำสั่งของคำสั่ง PostgresSQL WHERE |
ตัวดำเนินการ PostgreSQL Bit String
ตัวดำเนินการ Bitwise ทำงานบนบิตและดำเนินการแบบบิตต่อบิต ตารางความจริงสำหรับ & และ | มีดังนี้ -
| น | q | p & q | p | q |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 |
| 1 | 1 | 1 | 1 |
| 1 | 0 | 0 | 1 |
สมมติว่า A = 60; และ B = 13; ตอนนี้ในรูปแบบไบนารีพวกเขาจะเป็นดังนี้ -
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
ก | B = 0011 1101
~ A = 1100 0011
แสดงตัวอย่าง
ตัวดำเนินการ Bitwise ที่รองรับโดย PostgreSQL แสดงอยู่ในตารางต่อไปนี้ -
| ตัวดำเนินการ | คำอธิบาย | ตัวอย่าง |
|---|---|---|
| & | ไบนารี AND Operator จะคัดลอกบิตไปยังผลลัพธ์หากมีอยู่ในตัวถูกดำเนินการทั้งสอง | (A & B) จะให้ 12 ซึ่งเท่ากับ 0000 1100 |
| | | ไบนารีหรือตัวดำเนินการจะคัดลอกบิตหากมีอยู่ในตัวถูกดำเนินการอย่างใดอย่างหนึ่ง | (A | B) จะให้ 61 ซึ่งก็คือ 0011 1101 |
| ~ | Binary Ones Complement Operator เป็นเอกภาพและมีผลของบิต 'พลิก' | (~ A) จะให้ -61 ซึ่งก็คือ 1100 0011 ในรูปแบบส่วนเติมเต็มของ 2 เนื่องจากเลขฐานสองที่ลงนาม |
| << | ตัวดำเนินการกะซ้ายแบบไบนารี ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางซ้ายตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา | A << 2 จะให้ 240 ซึ่งก็คือ 1111 0000 |
| >> | ตัวดำเนินการกะไบนารีขวา ค่าตัวถูกดำเนินการด้านซ้ายจะถูกย้ายไปทางขวาตามจำนวนบิตที่ระบุโดยตัวถูกดำเนินการด้านขวา | A >> 2 จะให้ 15 ซึ่งก็คือ 0000 1111 |
| # | XOR แบบบิต | A # B จะให้ 49 ซึ่งก็คือ 0100 1001 |
นิพจน์คือการรวมกันของค่าตัวดำเนินการและฟังก์ชัน PostgresSQL อย่างน้อยหนึ่งค่าที่ประเมินเป็นค่า
PostgreSQL EXPRESSIONS เป็นเหมือนสูตรและเขียนด้วยภาษาแบบสอบถาม คุณยังสามารถใช้เพื่อสอบถามฐานข้อมูลสำหรับชุดข้อมูลเฉพาะได้
ไวยากรณ์
พิจารณาไวยากรณ์พื้นฐานของคำสั่ง SELECT ดังนี้ -
SELECT column1, column2, columnN
FROM table_name
WHERE [CONDITION | EXPRESSION];นิพจน์ PostgreSQL มีหลายประเภทซึ่งจะกล่าวถึงด้านล่าง -
PostgreSQL - นิพจน์บูลีน
PostgreSQL Boolean Expressions ดึงข้อมูลโดยใช้ค่าเดียวที่ตรงกัน ต่อไปนี้เป็นไวยากรณ์ -
SELECT column1, column2, columnN
FROM table_name
WHERE SINGLE VALUE MATCHTING EXPRESSION;พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)นี่คือตัวอย่างง่ายๆที่แสดงการใช้นิพจน์บูลีนของ PostgreSQL -
testdb=# SELECT * FROM COMPANY WHERE SALARY = 10000;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+----------+--------
7 | James | 24 | Houston | 10000
(1 row)PostgreSQL - นิพจน์ตัวเลข
นิพจน์เหล่านี้ใช้เพื่อดำเนินการทางคณิตศาสตร์ในแบบสอบถามใด ๆ ต่อไปนี้เป็นไวยากรณ์ -
SELECT numerical_expression as OPERATION_NAME
[FROM table_name WHERE CONDITION] ;ที่นี่ numerical_expression ใช้สำหรับนิพจน์ทางคณิตศาสตร์หรือสูตรใด ๆ ต่อไปนี้เป็นตัวอย่างง่ายๆที่แสดงการใช้ SQL Numeric Expressions -
testdb=# SELECT (15 + 6) AS ADDITION ;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
addition
----------
21
(1 row)มีฟังก์ชันในตัวหลายอย่างเช่น avg (), sum (), count () เพื่อดำเนินการในสิ่งที่เรียกว่าการคำนวณข้อมูลรวมกับตารางหรือคอลัมน์ตารางเฉพาะ
testdb=# SELECT COUNT(*) AS "RECORDS" FROM COMPANY;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
RECORDS
---------
7
(1 row)PostgreSQL - นิพจน์วันที่
Date Expressions ส่งคืนค่าวันที่และเวลาของระบบปัจจุบันและนิพจน์เหล่านี้จะใช้ในการจัดการข้อมูลต่างๆ
testdb=# SELECT CURRENT_TIMESTAMP;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
now
-------------------------------
2013-05-06 14:38:28.078+05:30
(1 row)ส่วนคำสั่ง PostgreSQL WHERE ใช้เพื่อระบุเงื่อนไขขณะดึงข้อมูลจากตารางเดียวหรือเข้าร่วมกับหลายตาราง
หากเงื่อนไขที่กำหนดเป็นที่พอใจระบบจะส่งคืนค่าเฉพาะจากตารางเท่านั้น คุณสามารถกรองแถวที่คุณไม่ต้องการให้รวมอยู่ในชุดผลลัพธ์ได้โดยใช้คำสั่ง WHERE
คำสั่ง WHERE ไม่เพียง แต่ใช้ในคำสั่ง SELECT เท่านั้น แต่ยังใช้ในคำสั่ง UPDATE, DELETE และอื่น ๆ อีกด้วยซึ่งเราจะตรวจสอบในบทต่อ ๆ ไป
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง SELECT กับ WHERE clause มีดังนี้ -
SELECT column1, column2, columnN
FROM table_name
WHERE [search_condition]คุณสามารถระบุsearch_conditionโดยใช้ตัวดำเนินการเปรียบเทียบหรือตรรกะ เช่น>, <, =, LIKE, NOT ฯลฯ ตัวอย่างต่อไปนี้จะทำให้แนวคิดนี้ชัดเจน
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)นี่คือตัวอย่างง่ายๆที่แสดงการใช้ตัวดำเนินการตรรกะของ PostgreSQL คำสั่ง SELECT ต่อไปนี้จะแสดงรายการบันทึกทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25AND เงินเดือนมากกว่าหรือเท่ากับ 65000.00 -
testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+------------+--------
4 | Mark | 25 | Rich-Mond | 65000
5 | David | 27 | Texas | 85000
(2 rows)คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25 OR เงินเดือนมากกว่าหรือเท่ากับ 65000.00 -
testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)คำสั่ง SELECT ต่อไปนี้แสดงรายการบันทึกทั้งหมดโดยที่ AGE ไม่ใช่ NULL ซึ่งหมายถึงระเบียนทั้งหมดเนื่องจากไม่มีระเบียนใดที่มี AGE เท่ากับ NULL -
testdb=# SELECT * FROM COMPANY WHERE AGE IS NOT NULL;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ NAME ขึ้นต้นด้วย 'Pa' ไม่สำคัญว่าจะเกิดอะไรขึ้นหลังจาก 'Pa'
testdb=# SELECT * FROM COMPANY WHERE NAME LIKE 'Pa%';คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age |address | salary
----+------+-----+-----------+--------
1 | Paul | 32 | California| 20000คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดโดยที่ค่า AGE เป็น 25 หรือ 27 -
testdb=# SELECT * FROM COMPANY WHERE AGE IN ( 25, 27 );คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+------------+--------
2 | Allen | 25 | Texas | 15000
4 | Mark | 25 | Rich-Mond | 65000
5 | David | 27 | Texas | 85000
(3 rows)คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดโดยที่ค่า AGE ไม่ใช่ 25 หรือ 27 -
testdb=# SELECT * FROM COMPANY WHERE AGE NOT IN ( 25, 27 );คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่มีค่า AGE อยู่ระหว่าง 25 และ 27 -
testdb=# SELECT * FROM COMPANY WHERE AGE BETWEEN 25 AND 27;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+------------+--------
2 | Allen | 25 | Texas | 15000
4 | Mark | 25 | Rich-Mond | 65000
5 | David | 27 | Texas | 85000
(3 rows)คำสั่ง SELECT ต่อไปนี้ใช้ประโยชน์จากการสืบค้นย่อย SQL โดยที่แบบสอบถามย่อยค้นหาระเบียนทั้งหมดที่มีเขตข้อมูล AGE ที่มี SALARY> 65000 ขึ้นไป WHERE clause จะถูกใช้ร่วมกับตัวดำเนินการ EXISTS เพื่อแสดงรายการระเบียนทั้งหมดที่มี AGE จากแบบสอบถามภายนอกอยู่ในผลลัพธ์ที่ส่งคืน ตามแบบสอบถามย่อย -
testdb=# SELECT AGE FROM COMPANY
WHERE EXISTS (SELECT AGE FROM COMPANY WHERE SALARY > 65000);คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
age
-----
32
25
23
25
27
22
24
(7 rows)คำสั่ง SELECT ต่อไปนี้ใช้ประโยชน์จากการสืบค้นย่อย SQL โดยที่แบบสอบถามย่อยค้นหาระเบียนทั้งหมดที่มีเขตข้อมูล AGE ที่มี SALARY> 65000 ขึ้นไป WHERE clause จะถูกใช้ร่วมกับตัวดำเนินการ> เพื่อแสดงรายการระเบียนทั้งหมดโดยที่ AGE จากแบบสอบถามภายนอกมากกว่าอายุใน ผลลัพธ์ที่ส่งคืนโดยแบบสอบถามย่อย -
testdb=# SELECT * FROM COMPANY
WHERE AGE > (SELECT AGE FROM COMPANY WHERE SALARY > 65000);คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+------+-----+------------+--------
1 | Paul | 32 | California | 20000PostgreSQL AND และ ORตัวดำเนินการใช้เพื่อรวมหลายเงื่อนไขเพื่อ จำกัด ข้อมูลที่เลือกให้แคบลงในคำสั่ง PostgreSQL ตัวดำเนินการทั้งสองนี้เรียกว่าตัวดำเนินการผันแปร
ตัวดำเนินการเหล่านี้ให้วิธีการเปรียบเทียบหลายตัวกับตัวดำเนินการที่แตกต่างกันในคำสั่ง PostgreSQL เดียวกัน
ตัวดำเนินการ AND
ANDตัวดำเนินการอนุญาตให้มีเงื่อนไขหลายเงื่อนไขในประโยค WHERE ของคำสั่ง PostgreSQL ในขณะที่ใช้ตัวดำเนินการ AND เงื่อนไขที่สมบูรณ์จะถือว่าเป็นจริงเมื่อเงื่อนไขทั้งหมดเป็นจริง ตัวอย่างเช่น [condition1] AND [condition2] จะเป็นจริงก็ต่อเมื่อทั้ง condition1 และ condition2 เป็นจริง
ไวยากรณ์
ไวยากรณ์พื้นฐานของตัวดำเนินการ AND กับ WHERE อนุประโยคมีดังนี้ -
SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] AND [condition2]...AND [conditionN];คุณสามารถรวม N จำนวนเงื่อนไขโดยใช้ตัวดำเนินการ AND สำหรับการดำเนินการโดยคำสั่ง PostgreSQL ไม่ว่าจะเป็นธุรกรรมหรือแบบสอบถามเงื่อนไขทั้งหมดที่คั่นด้วย AND จะต้องเป็น TRUE
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25 AND เงินเดือนมากกว่าหรือเท่ากับ 65000.00 -
testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 AND SALARY >= 65000;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+------------+--------
4 | Mark | 25 | Rich-Mond | 65000
5 | David | 27 | Texas | 85000
(2 rows)ตัวดำเนินการหรือ
นอกจากนี้ตัวดำเนินการ OR ยังใช้เพื่อรวมหลายเงื่อนไขในส่วนคำสั่ง WHERE ของคำสั่ง PostgreSQL ในขณะที่ใช้ตัวดำเนินการ OR เงื่อนไขที่สมบูรณ์จะถือว่าเป็นจริงเมื่ออย่างน้อยเงื่อนไขใด ๆ เป็นจริง ตัวอย่างเช่น [condition1] หรือ [condition2] จะเป็นจริงถ้า condition1 หรือ condition2 เป็นจริง
ไวยากรณ์
ไวยากรณ์พื้นฐานของ OR Operator กับ WHERE clause มีดังนี้ -
SELECT column1, column2, columnN
FROM table_name
WHERE [condition1] OR [condition2]...OR [conditionN]คุณสามารถรวม N จำนวนเงื่อนไขโดยใช้ตัวดำเนินการ OR สำหรับการดำเนินการโดยคำสั่ง PostgreSQL ไม่ว่าจะเป็นธุรกรรมหรือแบบสอบถามเงื่อนไขใดเงื่อนไขหนึ่งที่คั่นด้วย OR จะต้องเป็น TRUE เท่านั้น
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกต่อไปนี้ -
# 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)คำสั่ง SELECT ต่อไปนี้จะแสดงรายการระเบียนทั้งหมดที่ AGE มากกว่าหรือเท่ากับ 25 OR เงินเดือนมากกว่าหรือเท่ากับ 65000.00 -
testdb=# SELECT * FROM COMPANY WHERE AGE >= 25 OR SALARY >= 65000;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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 UPDATEแบบสอบถามใช้เพื่อแก้ไขระเบียนที่มีอยู่ในตาราง คุณสามารถใช้ WHERE clause กับ UPDATE query เพื่ออัปเดตแถวที่เลือก มิฉะนั้นแถวทั้งหมดจะได้รับการอัปเดต
ไวยากรณ์
ไวยากรณ์พื้นฐานของการสอบถาม UPDATE กับ WHERE clause มีดังนี้ -
UPDATE table_name
SET column1 = value1, column2 = value2...., columnN = valueN
WHERE [condition];คุณสามารถรวม N จำนวนเงื่อนไขโดยใช้ตัวดำเนินการ AND หรือ OR
ตัวอย่าง
พิจารณาตารางCOMPANYซึ่งมีบันทึกดังนี้ -
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)ต่อไปนี้เป็นตัวอย่างซึ่งจะอัปเดต ADDRESS สำหรับลูกค้าซึ่งมี ID คือ 6 -
testdb=# UPDATE COMPANY SET SALARY = 15000 WHERE ID = 3;ตอนนี้ตาราง COMPANY จะมีบันทึกต่อไปนี้ -
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)หากคุณต้องการแก้ไขค่าคอลัมน์ ADDRESS และ SALARY ทั้งหมดในตาราง COMPANY คุณไม่จำเป็นต้องใช้ WHERE clause และ UPDATE query จะเป็นดังนี้ -
testdb=# UPDATE COMPANY SET ADDRESS = 'Texas', SALARY=20000;ตอนนี้ตาราง COMPANY จะมีบันทึกต่อไปนี้ -
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 DELETEแบบสอบถามใช้เพื่อลบระเบียนที่มีอยู่ออกจากตาราง คุณสามารถใช้ WHERE clause กับ DELETE query เพื่อลบแถวที่เลือก มิฉะนั้นบันทึกทั้งหมดจะถูกลบ
ไวยากรณ์
ไวยากรณ์พื้นฐานของ DELETE query กับ WHERE clause มีดังนี้ -
DELETE FROM table_name
WHERE [condition];คุณสามารถรวม N จำนวนเงื่อนไขโดยใช้ตัวดำเนินการ AND หรือ OR
ตัวอย่าง
พิจารณาตารางCOMPANYซึ่งมีบันทึกดังนี้ -
# 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)ต่อไปนี้เป็นตัวอย่างซึ่งจะลบลูกค้าที่มีรหัส 7 -
testdb=# DELETE FROM COMPANY WHERE ID = 2;ตอนนี้ตาราง COMPANY จะมีบันทึกต่อไปนี้ -
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)ถ้าคุณต้องการลบระเบียนทั้งหมดจากตาราง COMPANY คุณไม่จำเป็นต้องใช้ WHERE clause กับ DELETE queries ซึ่งจะเป็นดังนี้ -
testdb=# DELETE FROM COMPANY;ตอนนี้ตาราง COMPANY ไม่มีเรกคอร์ดใด ๆ เนื่องจากบันทึกทั้งหมดถูกลบโดยคำสั่ง DELETE
PostgreSQL LIKEตัวดำเนินการใช้เพื่อจับคู่ค่าข้อความกับรูปแบบโดยใช้สัญลักษณ์แทน หากนิพจน์การค้นหาสามารถจับคู่กับนิพจน์รูปแบบได้ตัวดำเนินการ LIKE จะคืนค่าจริงซึ่งก็คือ1.
มีสัญลักษณ์แทนสองตัวที่ใช้ร่วมกับตัวดำเนินการ LIKE -
- เครื่องหมายเปอร์เซ็นต์ (%)
- ขีดล่าง (_)
เครื่องหมายเปอร์เซ็นต์แสดงถึงตัวเลขหรืออักขระที่เป็นศูนย์หนึ่งหรือหลายตัว ขีดล่างแสดงถึงตัวเลขหรืออักขระตัวเดียว สัญลักษณ์เหล่านี้สามารถใช้ร่วมกันได้
หากไม่ได้ใช้เครื่องหมายทั้งสองนี้ร่วมกับประโยค LIKE LIKE จะทำหน้าที่เหมือนตัวดำเนินการเท่ากับ
ไวยากรณ์
ไวยากรณ์พื้นฐานของ% และ _ มีดังนี้ -
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_'คุณสามารถรวม N จำนวนเงื่อนไขโดยใช้ตัวดำเนินการ AND หรือ OR XXXX อาจเป็นค่าตัวเลขหรือสตริงก็ได้
ตัวอย่าง
ต่อไปนี้เป็นตัวอย่างจำนวนหนึ่งที่แสดงว่าส่วนไหนที่มีคำสั่ง LIKE ต่างกันโดยมีตัวดำเนินการ '%' และ '_'
| ส. เลขที่ | คำชี้แจงและคำอธิบาย |
|---|---|
| 1 | WHERE SALARY::text LIKE '200%' ค้นหาค่าใด ๆ ที่เริ่มต้นด้วย 200 |
| 2 | WHERE SALARY::text LIKE '%200%' ค้นหาค่าใด ๆ ที่มี 200 ในตำแหน่งใด ๆ |
| 3 | WHERE SALARY::text LIKE '_00%' ค้นหาค่าใด ๆ ที่มี 00 ในตำแหน่งที่สองและสาม |
| 4 | WHERE SALARY::text LIKE '2_%_%' ค้นหาค่าใด ๆ ที่ขึ้นต้นด้วย 2 และมีความยาวอย่างน้อย 3 อักขระ |
| 5 | WHERE SALARY::text LIKE '%2' ค้นหาค่าใด ๆ ที่ลงท้ายด้วย 2 |
| 6 | WHERE SALARY::text LIKE '_2%3' ค้นหาค่าใด ๆ ที่มี 2 ในตำแหน่งที่สองและลงท้ายด้วย 3 |
| 7 | WHERE SALARY::text LIKE '2___3' ค้นหาค่าใด ๆ ในตัวเลขห้าหลักที่ขึ้นต้นด้วย 2 และลงท้ายด้วย 3 |
Postgres LIKE เป็นสตริงเปรียบเทียบเท่านั้น ดังนั้นเราจำเป็นต้องโยนคอลัมน์จำนวนเต็มเป็นสตริงอย่างชัดเจนดังตัวอย่างด้านบน
ขอยกตัวอย่างจริงพิจารณาตารางCOMPANYมีบันทึกดังนี้ -
# 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)ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนทั้งหมดจากตาราง COMPANY โดยที่ AGE เริ่มต้นด้วย 2 -
testdb=# SELECT * FROM COMPANY WHERE AGE::text LIKE '2%';สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงระเบียนทั้งหมดจากตาราง COMPANY โดยที่ ADDRESS จะมีเครื่องหมายยัติภังค์ (-) อยู่ภายในข้อความ -
testdb=# SELECT * FROM COMPANY WHERE ADDRESS LIKE '%-%';สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+------+-----+-------------------------------------------+--------
4 | Mark | 25 | Rich-Mond | 65000
6 | Kim | 22 | South-Hall | 45000
(2 rows)PostgreSQL LIMIT อนุประโยคถูกใช้เพื่อ จำกัด ปริมาณข้อมูลที่ส่งคืนโดยคำสั่ง SELECT
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง SELECT ที่มีส่วนคำสั่ง LIMIT มีดังนี้ -
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows]ต่อไปนี้เป็นไวยากรณ์ของ LIMIT clause เมื่อใช้ร่วมกับประโยค OFFSET -
SELECT column1, column2, columnN
FROM table_name
LIMIT [no of rows] OFFSET [row num]LIMIT และ OFFSET ช่วยให้คุณสามารถดึงข้อมูลเพียงบางส่วนของแถวที่สร้างขึ้นโดยส่วนที่เหลือของแบบสอบถาม
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
# 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)ต่อไปนี้เป็นตัวอย่างซึ่ง จำกัด แถวในตารางตามจำนวนแถวที่คุณต้องการดึงข้อมูลจากตาราง -
testdb=# SELECT * FROM COMPANY LIMIT 4;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)อย่างไรก็ตามในบางสถานการณ์คุณอาจต้องเลือกชุดระเบียนจากค่าชดเชยเฉพาะ นี่คือตัวอย่างซึ่งเลือกบันทึกสามรายการโดยเริ่มจากตำแหน่งที่สาม -
testdb=# SELECT * FROM COMPANY LIMIT 3 OFFSET 2;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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 อนุประโยคใช้เพื่อเรียงลำดับข้อมูลจากน้อยไปมากหรือมากไปหาน้อยโดยยึดตามคอลัมน์อย่างน้อยหนึ่งคอลัมน์
ไวยากรณ์
ไวยากรณ์พื้นฐานของคำสั่ง ORDER BY มีดังนี้ -
SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];คุณสามารถใช้คอลัมน์ได้มากกว่าหนึ่งคอลัมน์ในคำสั่ง ORDER BY ตรวจสอบให้แน่ใจว่าคอลัมน์ใดที่คุณใช้จัดเรียงคอลัมน์นั้นควรมีอยู่ในรายการคอลัมน์
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)ต่อไปนี้เป็นตัวอย่างซึ่งจะเรียงลำดับผลลัพธ์จากน้อยไปหามากโดย SALARY -
testdb=# SELECT * FROM COMPANY ORDER BY AGE ASC;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)ต่อไปนี้เป็นตัวอย่างซึ่งจะเรียงลำดับผลลัพธ์จากน้อยไปหามากตาม NAME และ SALARY -
testdb=# SELECT * FROM COMPANY ORDER BY NAME, SALARY ASC;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)ต่อไปนี้เป็นตัวอย่างซึ่งจะเรียงลำดับผลลัพธ์จากมากไปหาน้อยตาม NAME -
testdb=# SELECT * FROM COMPANY ORDER BY NAME DESC;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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 BYอนุประโยคถูกใช้ร่วมกับคำสั่ง SELECT เพื่อจัดกลุ่มแถวเหล่านั้นเข้าด้วยกันในตารางที่มีข้อมูลเหมือนกัน สิ่งนี้ทำเพื่อกำจัดความซ้ำซ้อนในเอาต์พุตและ / หรือการคำนวณการรวมที่ใช้กับกลุ่มเหล่านี้
GROUP BY clause ตามหลัง WHERE clause ในคำสั่ง SELECT และนำหน้า ORDER BY clause
ไวยากรณ์
ไวยากรณ์พื้นฐานของ GROUP BY clause ได้รับด้านล่าง GROUP BY clause ต้องเป็นไปตามเงื่อนไขใน WHERE clause และต้องนำหน้า ORDER BY clause ถ้ามีการใช้
SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnNคุณสามารถใช้คอลัมน์มากกว่าหนึ่งคอลัมน์ใน GROUP BY clause ตรวจสอบให้แน่ใจว่าคุณใช้คอลัมน์ใดในการจัดกลุ่มคอลัมน์นั้นควรอยู่ในรายการคอลัมน์
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
# 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)หากคุณต้องการทราบจำนวนเงินเดือนทั้งหมดของลูกค้าแต่ละรายคำถาม GROUP BY จะเป็นดังนี้ -
testdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
name | sum
-------+-------
Teddy | 20000
Paul | 20000
Mark | 65000
David | 85000
Allen | 15000
Kim | 45000
James | 10000
(7 rows)ตอนนี้ให้เราสร้างระเบียนอีกสามรายการในตาราง COMPANY โดยใช้คำสั่ง INSERT ต่อไปนี้ -
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);ตอนนี้ตารางของเรามีบันทึกต่อไปนี้ที่มีชื่อซ้ำกัน -
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)อีกครั้งให้เราใช้คำสั่งเดียวกันเพื่อจัดกลุ่มตามระเบียนทั้งหมดโดยใช้คอลัมน์ NAME ดังนี้ -
testdb=# SELECT NAME, SUM(SALARY) FROM COMPANY GROUP BY NAME ORDER BY NAME;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
name | sum
-------+-------
Allen | 15000
David | 85000
James | 20000
Kim | 45000
Mark | 65000
Paul | 40000
Teddy | 20000
(7 rows)ให้เราใช้ ORDER BY clause พร้อมกับ GROUP BY clause ดังนี้ -
testdb=# SELECT NAME, SUM(SALARY)
FROM COMPANY GROUP BY NAME ORDER BY NAME DESC;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
name | sum
-------+-------
Teddy | 20000
Paul | 40000
Mark | 65000
Kim | 45000
James | 20000
David | 85000
Allen | 15000
(7 rows)ใน PostgreSQL คิวรี WITH มีวิธีการเขียนคำสั่งเสริมเพื่อใช้ในแบบสอบถามขนาดใหญ่ ช่วยในการแบ่งแบบสอบถามที่ซับซ้อนและมีขนาดใหญ่ออกเป็นรูปแบบที่ง่ายขึ้นซึ่งสามารถอ่านได้ง่าย คำสั่งเหล่านี้มักเรียกว่า Common Table Expressions หรือ CTEs สามารถคิดได้ว่าเป็นการกำหนดตารางชั่วคราวที่มีอยู่สำหรับแบบสอบถามเดียว
แบบสอบถาม WITH เป็นแบบสอบถาม CTE มีประโยชน์อย่างยิ่งเมื่อมีการเรียกใช้แบบสอบถามย่อยหลาย ๆ ครั้ง มันเป็นประโยชน์อย่างเท่าเทียมกันในการแทนที่ตารางชั่วคราว จะคำนวณการรวมครั้งเดียวและช่วยให้เราอ้างอิงตามชื่อ (อาจมีหลายครั้ง) ในการสืบค้น
ต้องกำหนดส่วนคำสั่ง WITH ก่อนที่จะใช้ในแบบสอบถาม
ไวยากรณ์
ไวยากรณ์พื้นฐานของคิวรี C มีดังนี้ -
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]โดยที่name_for_summary_dataคือชื่อที่กำหนดให้กับอนุประโยคC name_for_summary_data อาจเหมือนกับชื่อตารางที่มีอยู่และจะมีความสำคัญ
คุณสามารถใช้คำสั่งปรับเปลี่ยนข้อมูล (INSERT, UPDATE หรือ DELETE) ใน C สิ่งนี้ช่วยให้คุณสามารถดำเนินการต่างๆในแบบสอบถามเดียวกันได้
เรียกซ้ำด้วย
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)ตอนนี้ให้เราเขียนแบบสอบถามโดยใช้ส่วนคำสั่ง WITH เพื่อเลือกบันทึกจากตารางด้านบนดังนี้ -
With CTE AS
(Select
ID
, NAME
, AGE
, ADDRESS
, SALARY
FROM COMPANY )
Select * From CTE;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)ตอนนี้ให้เราเขียนคำค้นหาโดยใช้คำหลัก RECURSIVE พร้อมกับประโยค C เพื่อหาผลรวมของเงินเดือนที่น้อยกว่า 20,000 ดังต่อไปนี้ -
WITH RECURSIVE t(n) AS (
VALUES (0)
UNION ALL
SELECT SALARY FROM COMPANY WHERE SALARY < 20000
)
SELECT sum(n) FROM t;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
sum
-------
25000
(1 row)ให้เราเขียนข้อความค้นหาโดยใช้คำสั่งปรับเปลี่ยนข้อมูลพร้อมกับอนุประโยคดังที่แสดงด้านล่าง
ขั้นแรกให้สร้างตาราง COMPANY1 ที่คล้ายกับตาราง COMPANY แบบสอบถามในตัวอย่างย้ายแถวจาก COMPANY ไป COMPANY1 ได้อย่างมีประสิทธิภาพ DELETE in WITH จะลบแถวที่ระบุจาก COMPANY ส่งคืนเนื้อหาโดยใช้ประโยค RETURNING จากนั้นแบบสอบถามหลักอ่านผลลัพธ์นั้นและแทรกลงใน 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);คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
INSERT 0 3ตอนนี้บันทึกในตาราง COMPANY และ COMPANY1 มีดังนี้ -
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)HAVING อนุประโยคช่วยให้เราสามารถเลือกแถวเฉพาะที่ผลลัพธ์ของฟังก์ชันตรงตามเงื่อนไขบางประการ
WHERE clause วางเงื่อนไขบนคอลัมน์ที่เลือกในขณะที่ HAVING clause วางเงื่อนไขบนกลุ่มที่สร้างโดย GROUP BY clause
ไวยากรณ์
ต่อไปนี้เป็นตำแหน่งของ HAVING clause ในคำสั่ง SELECT -
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BYHAVING clause ต้องเป็นไปตาม GROUP BY clause ในเคียวรีและต้องนำหน้า ORDER BY clause ด้วยถ้าใช้ ต่อไปนี้เป็นไวยากรณ์ของคำสั่ง SELECT ซึ่งรวมถึง HAVING clause -
SELECT column1, column2
FROM table1, table2
WHERE [ conditions ]
GROUP BY column1, column2
HAVING [ conditions ]
ORDER BY column1, column2ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
# 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)ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงบันทึกที่จำนวนชื่อน้อยกว่า 2 -
testdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) < 2;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
name
-------
Teddy
Paul
Mark
David
Allen
Kim
James
(7 rows)ตอนนี้ให้เราสร้างระเบียนอีกสามรายการในตาราง COMPANY โดยใช้คำสั่ง INSERT ต่อไปนี้ -
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);ตอนนี้ตารางของเรามีบันทึกต่อไปนี้ที่มีชื่อซ้ำกัน -
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)ต่อไปนี้เป็นตัวอย่างซึ่งจะแสดงบันทึกที่จำนวนชื่อมากกว่า 1 -
testdb-# SELECT NAME FROM COMPANY GROUP BY name HAVING count(name) > 1;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
name
-------
Paul
James
(2 rows)PostgreSQL DISTINCT คีย์เวิร์ดใช้ร่วมกับคำสั่ง SELECT เพื่อกำจัดเร็กคอร์ดที่ซ้ำกันทั้งหมดและดึงเฉพาะเร็กคอร์ดที่ไม่ซ้ำกัน
อาจเกิดสถานการณ์ขึ้นเมื่อคุณมีระเบียนที่ซ้ำกันหลายรายการในตาราง ในขณะที่เรียกข้อมูลดังกล่าวควรดึงเฉพาะระเบียนที่ไม่ซ้ำกันแทนที่จะดึงข้อมูลที่ซ้ำกัน
ไวยากรณ์
ไวยากรณ์พื้นฐานของคีย์เวิร์ด DISTINCT เพื่อกำจัดเร็กคอร์ดที่ซ้ำกันมีดังนี้ -
SELECT DISTINCT column1, column2,.....columnN
FROM table_name
WHERE [condition]ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
# 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)ให้เราเพิ่มอีกสองระเบียนในตารางนี้ดังนี้ -
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 );ตอนนี้บันทึกในตาราง 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
8 | Paul | 32 | California | 20000
9 | Allen | 25 | Texas | 15000
(9 rows)ขั้นแรกให้เราดูว่าแบบสอบถาม SELECT ต่อไปนี้ส่งคืนบันทึกเงินเดือนที่ซ้ำกันอย่างไร -
testdb=# SELECT name FROM COMPANY;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
name
-------
Paul
Allen
Teddy
Mark
David
Kim
James
Paul
Allen
(9 rows)ตอนนี้ให้เราใช้ DISTINCT คำหลักที่มีคำค้นหา SELECT ด้านบนและดูผลลัพธ์ -
testdb=# SELECT DISTINCT name FROM COMPANY;สิ่งนี้จะให้ผลลัพธ์ต่อไปนี้โดยที่เราไม่มีรายการที่ซ้ำกัน -
name
-------
Teddy
Paul
Mark
David
Allen
Kim
James
(7 rows)ข้อ จำกัด คือกฎที่บังคับใช้กับคอลัมน์ข้อมูลบนตาราง สิ่งเหล่านี้ใช้เพื่อป้องกันไม่ให้ป้อนข้อมูลที่ไม่ถูกต้องลงในฐานข้อมูล สิ่งนี้ทำให้มั่นใจได้ถึงความถูกต้องและความน่าเชื่อถือของข้อมูลในฐานข้อมูล
ข้อ จำกัด อาจเป็นระดับคอลัมน์หรือระดับตาราง ข้อ จำกัด ระดับคอลัมน์จะใช้กับคอลัมน์เดียวเท่านั้นในขณะที่ข้อ จำกัด ระดับตารางจะใช้กับทั้งตาราง การกำหนดชนิดข้อมูลสำหรับคอลัมน์เป็นข้อ จำกัด ในตัวเอง ตัวอย่างเช่นคอลัมน์ประเภท DATE จำกัด คอลัมน์เป็นวันที่ที่ถูกต้อง
ต่อไปนี้เป็นข้อ จำกัด ที่ใช้โดยทั่วไปที่มีอยู่ใน PostgreSQL
NOT NULL Constraint - ตรวจสอบให้แน่ใจว่าคอลัมน์ต้องไม่มีค่า NULL
UNIQUE Constraint - ตรวจสอบให้แน่ใจว่าค่าทั้งหมดในคอลัมน์แตกต่างกัน
PRIMARY Key - ระบุแต่ละแถว / ระเบียนในตารางฐานข้อมูลโดยไม่ซ้ำกัน
FOREIGN Key - จำกัด ข้อมูลตามคอลัมน์ในตารางอื่น ๆ
CHECK Constraint - ข้อ จำกัด CHECK ช่วยให้มั่นใจได้ว่าค่าทั้งหมดในคอลัมน์เป็นไปตามเงื่อนไขบางประการ
EXCLUSION Constraint - ข้อ จำกัด EXCLUDE ทำให้มั่นใจได้ว่าหากมีการเปรียบเทียบสองแถวในคอลัมน์หรือนิพจน์ที่ระบุโดยใช้ตัวดำเนินการที่ระบุการเปรียบเทียบเหล่านี้ทั้งหมดจะไม่ส่งคืนค่า TRUE
ข้อ จำกัด ไม่ใช่โมฆะ
ตามค่าเริ่มต้นคอลัมน์สามารถเก็บค่า NULL ได้ หากคุณไม่ต้องการให้คอลัมน์มีค่า NULL คุณต้องกำหนดข้อ จำกัด ดังกล่าวในคอลัมน์นี้โดยระบุว่าตอนนี้ไม่อนุญาตให้มีค่า NULL สำหรับคอลัมน์นั้น ข้อ จำกัด NOT NULL จะเขียนเป็นข้อ จำกัด ของคอลัมน์เสมอ
NULL ไม่เหมือนกับไม่มีข้อมูล แต่แสดงถึงข้อมูลที่ไม่รู้จัก
ตัวอย่าง
ตัวอย่างเช่นคำสั่ง PostgreSQL ต่อไปนี้สร้างตารางใหม่ชื่อ COMPANY1 และเพิ่มห้าคอลัมน์ซึ่งสามคอลัมน์คือ ID และ NAME และ AGE ระบุว่าไม่ยอมรับค่า NULL -
CREATE TABLE COMPANY1(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);ข้อ จำกัด ที่ไม่ซ้ำใคร
UNIQUE Constraint ป้องกันไม่ให้สองระเบียนมีค่าเหมือนกันในคอลัมน์ใดคอลัมน์หนึ่ง ตัวอย่างเช่นในตาราง COMPANY คุณอาจต้องการป้องกันไม่ให้คนสองคนหรือมากกว่านั้นมีอายุเท่ากัน
ตัวอย่าง
ตัวอย่างเช่นคำสั่ง PostgreSQL ต่อไปนี้สร้างตารางใหม่ชื่อ COMPANY3 และเพิ่มห้าคอลัมน์ ที่นี่คอลัมน์ AGE ถูกตั้งค่าเป็น UNIQUE ดังนั้นคุณจึงไม่สามารถมีสองระเบียนที่มีอายุเท่ากันได้ -
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 จะระบุแต่ละระเบียนในตารางฐานข้อมูลโดยไม่ซ้ำกัน สามารถมีคอลัมน์ที่ไม่ซ้ำกันได้มากกว่า แต่จะมีคีย์หลักเพียงรายการเดียวในตาราง คีย์หลักมีความสำคัญเมื่อออกแบบตารางฐานข้อมูล คีย์หลักคือรหัสเฉพาะ
เราใช้เพื่ออ้างถึงแถวของตาราง คีย์หลักกลายเป็นคีย์ต่างประเทศในตารางอื่นเมื่อสร้างความสัมพันธ์ระหว่างตาราง เนื่องจาก 'การกำกับดูแลการเข้ารหัสเป็นเวลานาน' คีย์หลักอาจเป็น NULL ใน SQLite นี่ไม่ใช่กรณีของฐานข้อมูลอื่น
คีย์หลักคือฟิลด์ในตารางซึ่งจะระบุแต่ละแถว / ระเบียนในตารางฐานข้อมูลโดยไม่ซ้ำกัน คีย์หลักต้องมีค่าที่ไม่ซ้ำกัน คอลัมน์คีย์หลักต้องไม่มีค่า NULL
ตารางสามารถมีคีย์หลักได้เพียงคีย์เดียวซึ่งอาจประกอบด้วยฟิลด์เดียวหรือหลายฟิลด์ เมื่อใช้หลายช่องเป็นคีย์หลักจะเรียกว่า acomposite key.
หากตารางมีคีย์หลักที่กำหนดไว้ในฟิลด์ใด ๆ คุณจะไม่สามารถมีสองระเบียนที่มีค่าเดียวกันของฟิลด์นั้น
ตัวอย่าง
คุณได้เห็นตัวอย่างต่างๆด้านบนแล้วซึ่งเราได้สร้างตาราง COMAPNY4 โดยมี ID เป็นคีย์หลัก -
CREATE TABLE COMPANY4(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);ข้อ จำกัด สำคัญต่างประเทศ
ข้อ จำกัด ของคีย์ต่างประเทศระบุว่าค่าในคอลัมน์ (หรือกลุ่มของคอลัมน์) ต้องตรงกับค่าที่ปรากฏในบางแถวของตารางอื่น เรากล่าวว่าสิ่งนี้รักษาความสมบูรณ์ของการอ้างอิงระหว่างสองตารางที่เกี่ยวข้อง พวกเขาเรียกว่าคีย์ต่างประเทศเนื่องจากข้อ จำกัด เป็นสิ่งแปลกปลอม นั่นคือนอกตาราง คีย์ต่างประเทศบางครั้งเรียกว่าคีย์อ้างอิง
ตัวอย่าง
ตัวอย่างเช่นคำสั่ง PostgreSQL ต่อไปนี้สร้างตารางใหม่ชื่อ COMPANY5 และเพิ่มห้าคอลัมน์
CREATE TABLE COMPANY6(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);ตัวอย่างเช่นคำสั่ง PostgreSQL ต่อไปนี้สร้างตารางใหม่ชื่อ DEPARTMENT1 ซึ่งเพิ่มสามคอลัมน์ คอลัมน์ EMP_ID เป็นคีย์นอกและอ้างอิงฟิลด์ ID ของตาราง COMPANY6
CREATE TABLE DEPARTMENT1(
ID INT PRIMARY KEY NOT NULL,
DEPT CHAR(50) NOT NULL,
EMP_ID INT references COMPANY6(ID)
);ตรวจสอบข้อ จำกัด
CHECK Constraint ช่วยให้เงื่อนไขในการตรวจสอบค่าที่ป้อนลงในเรกคอร์ด หากเงื่อนไขประเมินว่าเป็นเท็จบันทึกจะละเมิดข้อ จำกัด และไม่ได้ป้อนลงในตาราง
ตัวอย่าง
ตัวอย่างเช่นคำสั่ง PostgreSQL ต่อไปนี้สร้างตารางใหม่ชื่อ COMPANY5 และเพิ่มห้าคอลัมน์ ในที่นี้เราเพิ่มคอลัมน์ CHECK with SALARY เพื่อไม่ให้คุณมี SALARY เป็นศูนย์
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)
);ข้อ จำกัด การยกเว้น
ข้อ จำกัด การยกเว้นทำให้แน่ใจว่าหากมีการเปรียบเทียบแถวสองแถวบนคอลัมน์หรือนิพจน์ที่ระบุโดยใช้ตัวดำเนินการที่ระบุการเปรียบเทียบตัวดำเนินการอย่างน้อยหนึ่งรายการจะส่งคืนค่าเท็จหรือค่าว่าง
ตัวอย่าง
ตัวอย่างเช่นคำสั่ง PostgreSQL ต่อไปนี้สร้างตารางใหม่ชื่อ COMPANY7 และเพิ่มห้าคอลัมน์ ที่นี่เราเพิ่มข้อ จำกัด EXCLUDE -
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 <>)
);ในที่นี้การใช้ส่วนสำคัญคือประเภทของดัชนีในการสร้างและใช้สำหรับการบังคับใช้
คุณต้องดำเนินการคำสั่ง CREATE EXTENSION btree_gistหนึ่งครั้งต่อฐานข้อมูล สิ่งนี้จะติดตั้งส่วนขยาย btree_gist ซึ่งกำหนดข้อ จำกัด การยกเว้นในประเภทข้อมูลสเกลาร์ธรรมดา
เนื่องจากเราได้บังคับใช้อายุจะต้องเท่ากันให้เราดูสิ่งนี้โดยการแทรกระเบียนลงในตาราง -
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 );สำหรับสองคำสั่ง INSERT แรกระเบียนจะถูกเพิ่มลงในตาราง COMPANY7 สำหรับคำสั่ง INSERT ที่สามข้อผิดพลาดต่อไปนี้จะปรากฏขึ้น -
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).การลดข้อ จำกัด
ในการลบข้อ จำกัด คุณจำเป็นต้องทราบชื่อของมัน ถ้าขึ้นชื่อก็ปล่อยวางได้ง่ายๆ มิฉะนั้นคุณต้องหาชื่อที่ระบบสร้างขึ้น ชื่อตารางคำสั่ง psql มีประโยชน์ที่นี่ ไวยากรณ์ทั่วไปคือ -
ALTER TABLE table_name DROP CONSTRAINT some_name;PostgreSQL Joinsอนุประโยคใช้เพื่อรวมระเบียนจากตารางสองตารางขึ้นไปในฐานข้อมูล JOIN เป็นวิธีการรวมฟิลด์จากสองตารางโดยใช้ค่าร่วมกันของแต่ละตาราง
ประเภทการเข้าร่วมใน PostgreSQL คือ -
- CROSS เข้าร่วม
- การเข้าร่วมภายใน
- ด้านซ้ายเข้าร่วม
- เข้าร่วมด้านนอกที่ถูกต้อง
- เข้าร่วมเต็มรูปแบบภายนอก
ก่อนที่เราจะดำเนินการต่อขอให้เราพิจารณาตารางสองตาราง บริษัท และแผนก เราได้เห็นคำสั่ง INSERT เพื่อเติมข้อมูลตาราง COMPANY แล้ว ดังนั้นให้เราถือว่ารายการบันทึกที่มีอยู่ในตาราง COMPANY -
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ตารางอื่นคือ DEPARTMENT มีคำจำกัดความดังต่อไปนี้ -
CREATE TABLE DEPARTMENT(
ID INT PRIMARY KEY NOT NULL,
DEPT CHAR(50) NOT NULL,
EMP_ID INT NOT NULL
);นี่คือรายการของคำสั่ง INSERT เพื่อเติมข้อมูลตาราง DEPARTMENT -
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (1, 'IT Billing', 1 );
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (2, 'Engineering', 2 );
INSERT INTO DEPARTMENT (ID, DEPT, EMP_ID)
VALUES (3, 'Finance', 7 );ในที่สุดเรามีรายการบันทึกต่อไปนี้ในตาราง DEPARTMENT -
id | dept | emp_id
----+-------------+--------
1 | IT Billing | 1
2 | Engineering | 2
3 | Finance | 7CROSS เข้าร่วม
CROSS JOIN จะจับคู่ทุกแถวของตารางแรกกับทุกแถวของตารางที่สอง หากตารางอินพุตมีคอลัมน์ x และ y ตามลำดับตารางผลลัพธ์จะมีคอลัมน์ x + y เนื่องจาก CROSS JOINs มีศักยภาพในการสร้างตารางขนาดใหญ่มากจึงต้องใช้ความระมัดระวังในการใช้งานเมื่อเหมาะสมเท่านั้น
ต่อไปนี้เป็นไวยากรณ์ของ CROSS JOIN -
SELECT ... FROM table1 CROSS JOIN table2 ...จากตารางด้านบนเราสามารถเขียน CROSS JOIN ได้ดังนี้ -
testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY CROSS JOIN DEPARTMENT;แบบสอบถามที่ระบุข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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การเข้าร่วมภายใน
INNER JOIN สร้างตารางผลลัพธ์ใหม่โดยการรวมค่าคอลัมน์ของสองตาราง (table1 และ table2) โดยยึดตามการเข้าร่วม - เพรดิเคต แบบสอบถามเปรียบเทียบแต่ละแถวของ table1 กับแต่ละแถวของ table2 เพื่อค้นหาคู่ของแถวทั้งหมดซึ่งตรงตามเงื่อนไขการรวม เมื่อสมการรวม - เพรดิเคตค่าของคอลัมน์สำหรับแต่ละคู่ของแถว table1 และ table2 ที่ตรงกันจะรวมกันเป็นแถวผลลัพธ์
INNER JOIN เป็นประเภทการเข้าร่วมที่พบบ่อยที่สุดและเป็นประเภทเริ่มต้นของการเข้าร่วม คุณสามารถใช้คำหลักภายในหรือไม่ก็ได้
ต่อไปนี้เป็นไวยากรณ์ของ INNER JOIN -
SELECT table1.column1, table2.column2...
FROM table1
INNER JOIN table2
ON table1.common_filed = table2.common_field;จากตารางด้านบนเราสามารถเขียน INNER JOIN ได้ดังนี้ -
testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY INNER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;แบบสอบถามที่ระบุข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
emp_id | name | dept
--------+-------+------------
1 | Paul | IT Billing
2 | Allen | Engineeringด้านซ้ายเข้าร่วม
OUTER JOIN เป็นส่วนเสริมของ INNER JOIN มาตรฐาน SQL กำหนดการเข้าร่วมภายนอกสามประเภท: LEFT, RIGHT และ FULL และ PostgreSQL รองรับสิ่งเหล่านี้ทั้งหมด
ในกรณีของ LEFT OUTER JOIN การรวมภายในจะดำเนินการก่อน จากนั้นสำหรับแต่ละแถวในตาราง T1 ที่ไม่ตรงตามเงื่อนไขการรวมกับแถวใด ๆ ในตาราง T2 แถวที่รวมจะถูกเพิ่มด้วยค่า null ในคอลัมน์ของ T2 ดังนั้นตารางที่เข้าร่วมจะมีอย่างน้อยหนึ่งแถวสำหรับแต่ละแถวใน T1
ต่อไปนี้เป็นไวยากรณ์ของ LEFT OUTER JOIN -
SELECT ... FROM table1 LEFT OUTER JOIN table2 ON conditional_expression ...จากตารางด้านบนเราสามารถเขียนการรวมภายในได้ดังนี้ -
testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY LEFT OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;แบบสอบถามที่ระบุข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
emp_id | name | dept
--------+-------+------------
1 | Paul | IT Billing
2 | Allen | Engineering
| James |
| David |
| Paul |
| Mark |
| Teddy |
| James |เข้าร่วมด้านนอกที่ถูกต้อง
ขั้นแรกให้ทำการรวมภายใน จากนั้นสำหรับแต่ละแถวในตาราง T2 ที่ไม่ตรงตามเงื่อนไขการรวมกับแถวใด ๆ ในตาราง T1 แถวที่รวมจะถูกเพิ่มด้วยค่า null ในคอลัมน์ของ T1 นี่คือการสนทนาของการเข้าร่วมทางซ้าย ตารางผลลัพธ์จะมีแถวสำหรับแต่ละแถวใน T2 เสมอ
ต่อไปนี้เป็นไวยากรณ์ของ RIGHT OUTER JOIN -
SELECT ... FROM table1 RIGHT OUTER JOIN table2 ON conditional_expression ...จากตารางด้านบนเราสามารถเขียนการรวมภายในได้ดังนี้ -
testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY RIGHT OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;แบบสอบถามที่ระบุข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
emp_id | name | dept
--------+-------+--------
1 | Paul | IT Billing
2 | Allen | Engineering
7 | | Financeเข้าร่วมเต็มรูปแบบภายนอก
ขั้นแรกให้ทำการรวมภายใน จากนั้นสำหรับแต่ละแถวในตาราง T1 ที่ไม่ตรงตามเงื่อนไขการรวมกับแถวใด ๆ ในตาราง T2 แถวที่รวมจะถูกเพิ่มด้วยค่า null ในคอลัมน์ของ T2 นอกจากนี้สำหรับแต่ละแถวของ T2 ที่ไม่เป็นไปตามเงื่อนไขการรวมกับแถวใด ๆ ใน T1 จะมีการเพิ่มแถวที่เข้าร่วมที่มีค่า null ในคอลัมน์ของ T1
ต่อไปนี้เป็นไวยากรณ์ของ FULL OUTER JOIN -
SELECT ... FROM table1 FULL OUTER JOIN table2 ON conditional_expression ...จากตารางด้านบนเราสามารถเขียนการรวมภายในได้ดังนี้ -
testdb=# SELECT EMP_ID, NAME, DEPT FROM COMPANY FULL OUTER JOIN DEPARTMENT
ON COMPANY.ID = DEPARTMENT.EMP_ID;แบบสอบถามที่ระบุข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
emp_id | name | dept
--------+-------+---------------
1 | Paul | IT Billing
2 | Allen | Engineering
7 | | Finance
| James |
| David |
| Paul |
| Mark |
| Teddy |
| James |PostgreSQL UNION อนุประโยค / ตัวดำเนินการใช้เพื่อรวมผลลัพธ์ของคำสั่ง SELECT สองคำขึ้นไปโดยไม่ส่งคืนแถวที่ซ้ำกัน
ในการใช้ UNION แต่ละ SELECT ต้องมีจำนวนคอลัมน์ที่เลือกเท่ากันจำนวนนิพจน์คอลัมน์เดียวกันชนิดข้อมูลเดียวกันและจัดเรียงไว้ในลำดับเดียวกัน แต่ไม่จำเป็นต้องมีความยาวเท่ากัน
ไวยากรณ์
ไวยากรณ์พื้นฐานของ UNION มีดังนี้ -
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]เงื่อนไขที่กำหนดอาจเป็นนิพจน์ใดก็ได้ตามความต้องการของคุณ
ตัวอย่าง
พิจารณาสองตารางต่อไปนี้ (a) ตารางCOMPANYมีดังนี้ -
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) ตารางอื่นคือDEPARTMENTดังต่อไปนี้ -
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)ตอนนี้ให้เราเข้าร่วมสองตารางนี้โดยใช้คำสั่ง SELECT พร้อมกับอนุประโยคดังนี้ -
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;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)UNION ALL Clause
ตัวดำเนินการ UNION ALL ใช้เพื่อรวมผลลัพธ์ของคำสั่ง SELECT สองรายการรวมทั้งแถวที่ซ้ำกัน กฎเดียวกันที่ใช้กับ UNION จะใช้กับตัวดำเนินการ UNION ALL ด้วยเช่นกัน
ไวยากรณ์
ไวยากรณ์พื้นฐานของ UNION ALL มีดังนี้ -
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]
UNION ALL
SELECT column1 [, column2 ]
FROM table1 [, table2 ]
[WHERE condition]เงื่อนไขที่กำหนดอาจเป็นนิพจน์ใดก็ได้ตามความต้องการของคุณ
ตัวอย่าง
ตอนนี้ให้เราเข้าร่วมสองตารางข้างต้นในคำสั่ง SELECT ของเราดังนี้ -
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;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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 NULLคือคำที่ใช้แทนค่าที่ขาดหายไป ค่า NULL ในตารางคือค่าในเขตข้อมูลที่ดูเหมือนจะว่างเปล่า
เขตข้อมูลที่มีค่า NULL คือเขตข้อมูลที่ไม่มีค่า เป็นสิ่งสำคัญมากที่จะต้องเข้าใจว่าค่า NULL แตกต่างจากค่าศูนย์หรือเขตข้อมูลที่มีช่องว่าง
ไวยากรณ์
ไวยากรณ์พื้นฐานของการใช้ NULL ในขณะที่สร้างตารางมีดังนี้ -
CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);ที่นี่ NOT NULLหมายความว่าคอลัมน์ควรยอมรับค่าที่ชัดเจนของชนิดข้อมูลที่กำหนดเสมอ มีสองคอลัมน์ที่เราไม่ได้ใช้ NOT NULL ดังนั้นหมายความว่าคอลัมน์เหล่านี้อาจเป็นโมฆะ
ฟิลด์ที่มีค่า NULL คือฟิลด์ที่เว้นว่างไว้ระหว่างการสร้างเรกคอร์ด
ตัวอย่าง
ค่า NULL อาจทำให้เกิดปัญหาเมื่อเลือกข้อมูลเนื่องจากเมื่อเปรียบเทียบค่าที่ไม่รู้จักกับค่าอื่น ๆ ผลลัพธ์จะไม่ทราบเสมอและไม่รวมอยู่ในผลลัพธ์สุดท้าย พิจารณาตารางต่อไปนี้COMPANYมีบันทึกดังต่อไปนี้ -
ID NAME AGE ADDRESS SALARY
---------- ---------- ---------- ---------- ----------
1 Paul 32 California 20000.0
2 Allen 25 Texas 15000.0
3 Teddy 23 Norway 20000.0
4 Mark 25 Rich-Mond 65000.0
5 David 27 Texas 85000.0
6 Kim 22 South-Hall 45000.0
7 James 24 Houston 10000.0ให้เราใช้คำสั่ง UPDATE เพื่อกำหนดค่าว่างไม่กี่ค่าเป็น NULL ดังนี้ -
testdb=# UPDATE COMPANY SET ADDRESS = NULL, SALARY = NULL where ID IN(6,7);ตอนนี้ตาราง 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 | |
7 | James | 24 | |
(7 rows)ต่อไปให้เราดูการใช้งานของ IS NOT NULL ตัวดำเนินการเพื่อแสดงรายการบันทึกทั้งหมดโดยที่ SALARY ไม่ใช่ NULL -
testdb=# SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM COMPANY
WHERE SALARY IS NOT NULL;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)ต่อไปนี้คือการใช้งาน IS NULL ตัวดำเนินการซึ่งจะแสดงรายการบันทึกทั้งหมดโดยที่ SALARY เป็น NULL -
testdb=# SELECT ID, NAME, AGE, ADDRESS, SALARY
FROM COMPANY
WHERE SALARY IS NULL;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+---------+--------
6 | Kim | 22 | |
7 | James | 24 | |
(2 rows)คุณสามารถเปลี่ยนชื่อตารางหรือคอลัมน์ชั่วคราวโดยตั้งชื่ออื่นซึ่งเรียกว่า ALIAS. การใช้นามแฝงของตารางหมายถึงการเปลี่ยนชื่อตารางในคำสั่ง PostgreSQL เฉพาะ การเปลี่ยนชื่อเป็นการเปลี่ยนแปลงชั่วคราวและชื่อตารางจริงจะไม่เปลี่ยนแปลงในฐานข้อมูล
นามแฝงของคอลัมน์ใช้เพื่อเปลี่ยนชื่อคอลัมน์ของตารางเพื่อวัตถุประสงค์ในการสืบค้น PostgreSQL โดยเฉพาะ
ไวยากรณ์
ไวยากรณ์พื้นฐานของ table นามแฝงมีดังนี้ -
SELECT column1, column2....
FROM table_name AS alias_name
WHERE [condition];ไวยากรณ์พื้นฐานของ column นามแฝงมีดังนี้ -
SELECT column_name AS alias_name
FROM table_name
WHERE [condition];ตัวอย่าง
พิจารณาสองตารางต่อไปนี้ (a) ตารางCOMPANYมีดังนี้ -
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) ตารางอื่นคือ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)ต่อไปนี้คือการใช้งาน TABLE ALIAS โดยที่เราใช้ C และ D เป็นนามแฝงสำหรับตาราง COMPANY และ DEPARTMENT ตามลำดับ -
testdb=# SELECT C.ID, C.NAME, C.AGE, D.DEPT
FROM COMPANY AS C, DEPARTMENT AS D
WHERE C.ID = D.EMP_ID;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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)ให้เราดูตัวอย่างสำหรับการใช้งาน COLUMN ALIAS โดย COMPANY_ID เป็นนามแฝงของคอลัมน์ ID และ COMPANY_NAME เป็นชื่อแทนของคอลัมน์ -
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;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
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 เป็นฟังก์ชันเรียกกลับฐานข้อมูลซึ่งจะดำเนินการ / เรียกใช้โดยอัตโนมัติเมื่อเกิดเหตุการณ์ฐานข้อมูลที่ระบุ
ต่อไปนี้เป็นประเด็นสำคัญเกี่ยวกับทริกเกอร์ PostgreSQL -
สามารถระบุทริกเกอร์ PostgreSQL เพื่อเริ่มการทำงาน
ก่อนที่จะมีการพยายามดำเนินการในแถว (ก่อนที่จะมีการตรวจสอบข้อ จำกัด และจะพยายาม INSERT, UPDATE หรือ DELETE)
หลังจากการดำเนินการเสร็จสิ้น (หลังจากตรวจสอบข้อ จำกัด และ INSERT, UPDATE หรือ DELETE เสร็จสิ้น)
แทนการดำเนินการ (ในกรณีของการแทรกอัพเดตหรือลบในมุมมอง)
ทริกเกอร์ที่ถูกทำเครื่องหมายสำหรับแต่ละแถวจะถูกเรียกหนึ่งครั้งสำหรับทุกแถวที่การดำเนินการปรับเปลี่ยน ในทางตรงกันข้ามทริกเกอร์ที่ทำเครื่องหมายสำหรับแต่ละ STATEMENT จะดำเนินการเพียงครั้งเดียวสำหรับการดำเนินการใด ๆ ก็ตามไม่ว่าจะแก้ไขกี่แถวก็ตาม
ทั้งคำสั่ง WHEN และการดำเนินการทริกเกอร์อาจเข้าถึงองค์ประกอบของแถวที่กำลังแทรกลบหรืออัปเดตโดยใช้การอ้างอิงของแบบฟอร์ม NEW.column-name และ OLD.column-nameโดยที่ชื่อคอลัมน์คือชื่อของคอลัมน์จากตารางที่เกี่ยวข้องกับทริกเกอร์
หากมีการระบุคำสั่ง WHEN คำสั่ง PostgreSQL ที่ระบุจะถูกเรียกใช้สำหรับแถวที่มีคำสั่ง WHEN เป็นจริงเท่านั้น หากไม่มีการระบุคำสั่ง WHEN คำสั่ง PostgreSQL จะดำเนินการสำหรับทุกแถว
หากมีการกำหนดทริกเกอร์ชนิดเดียวกันหลายตัวสำหรับเหตุการณ์เดียวกันทริกเกอร์จะเริ่มทำงานตามลำดับตัวอักษรตามชื่อ
คำหลักก่อนหลังหรือแทนคำหลักกำหนดว่าเมื่อใดที่จะเรียกใช้การดำเนินการทริกเกอร์ที่สัมพันธ์กับการแทรกการแก้ไขหรือการลบแถวที่เกี่ยวข้อง
ทริกเกอร์จะหลุดโดยอัตโนมัติเมื่อตารางที่เกี่ยวข้องถูกทิ้ง
ตารางที่จะแก้ไขต้องมีอยู่ในฐานข้อมูลเดียวกับตารางหรือมุมมองที่แนบทริกเกอร์และต้องใช้เพียง tablenameไม่ใช่ database.tablename.
ตัวเลือกข้อ จำกัด เมื่อระบุสร้างไก จำกัด สิ่งนี้เหมือนกับทริกเกอร์ทั่วไปยกเว้นว่าสามารถปรับระยะเวลาของการยิงไกได้โดยใช้ข้อ จำกัด ของชุด ทริกเกอร์ข้อ จำกัด คาดว่าจะเพิ่มข้อยกเว้นเมื่อมีการละเมิดข้อ จำกัด ที่ใช้
ไวยากรณ์
ไวยากรณ์พื้นฐานของการสร้างไฟล์ trigger มีดังนี้ -
CREATE TRIGGER trigger_name [BEFORE|AFTER|INSTEAD OF] event_name
ON table_name
[
-- Trigger logic goes here....
];ที่นี่ event_nameอาจเป็นการดำเนินการINSERT, DELETE, UPDATEและTRUNCATEในตารางที่กล่าวถึงtable_name. คุณสามารถเลือกระบุสำหรับแต่ละแถวหลังชื่อตารางได้
ต่อไปนี้เป็นไวยากรณ์ของการสร้างทริกเกอร์ในการดำเนินการ UPDATE บนคอลัมน์ที่ระบุอย่างน้อยหนึ่งคอลัมน์ของตารางดังนี้ -
CREATE TRIGGER trigger_name [BEFORE|AFTER] UPDATE OF column_name
ON table_name
[
-- Trigger logic goes here....
];ตัวอย่าง
ให้เราพิจารณากรณีที่เราต้องการให้มีการทดลองตรวจสอบสำหรับทุกระเบียนที่แทรกในตาราง COMPANY ซึ่งเราจะสร้างขึ้นใหม่ดังต่อไปนี้ (วางตาราง COMPANY หากคุณมีอยู่แล้ว)
testdb=# CREATE TABLE COMPANY(
ID INT PRIMARY KEY NOT NULL,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);เพื่อทำการทดลองตรวจสอบต่อไปเราจะสร้างตารางใหม่ชื่อ AUDIT ซึ่งจะแทรกข้อความบันทึกเมื่อใดก็ตามที่มีรายการในตาราง COMPANY สำหรับบันทึกใหม่ -
testdb=# CREATE TABLE AUDIT(
EMP_ID INT NOT NULL,
ENTRY_DATE TEXT NOT NULL
);ในที่นี้ ID คือ ID เร็กคอร์ด AUDIT และ EMP_ID คือ ID ซึ่งจะมาจากตาราง COMPANY และ DATE จะเก็บการประทับเวลาเมื่อสร้างเรกคอร์ดในตาราง COMPANY ตอนนี้ให้เราสร้างทริกเกอร์ในตาราง COMPANY ดังนี้ -
testdb=# CREATE TRIGGER example_trigger AFTER INSERT ON COMPANY
FOR EACH ROW EXECUTE PROCEDURE auditlogfunc();โดย auditlogfunc () คือ PostgreSQL procedure และมีคำจำกัดความดังต่อไปนี้ -
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;ตอนนี้เราจะเริ่มการทำงานจริง ให้เราเริ่มแทรกบันทึกในตาราง COMPANY ซึ่งจะส่งผลให้สร้างบันทึกบันทึกการตรวจสอบในตาราง AUDIT ดังนั้นให้เราสร้างหนึ่งระเบียนในตาราง COMPANY ดังนี้ -
testdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );สิ่งนี้จะสร้างหนึ่งระเบียนในตาราง COMPANY ซึ่งมีดังต่อไปนี้ -
id | name | age | address | salary
----+------+-----+--------------+--------
1 | Paul | 32 | California | 20000ในเวลาเดียวกันจะมีการสร้างหนึ่งระเบียนในตาราง AUDIT บันทึกนี้เป็นผลมาจากทริกเกอร์ซึ่งเราได้สร้างขึ้นในการดำเนินการ INSERT บนตาราง COMPANY ในทำนองเดียวกันคุณสามารถสร้างทริกเกอร์ของคุณในการอัปเดตและลบการดำเนินการตามความต้องการของคุณ
emp_id | entry_date
--------+-------------------------------
1 | 2013-05-05 15:49:59.968+05:30
(1 row)รายชื่อทริกเกอร์
คุณสามารถแสดงรายการทริกเกอร์ทั้งหมดในฐานข้อมูลปัจจุบันได้จาก pg_trigger ตารางดังนี้ -
testdb=# SELECT * FROM pg_trigger;คำสั่ง PostgreSQL ข้างต้นจะแสดงรายการทริกเกอร์ทั้งหมด
หากคุณต้องการแสดงรายการทริกเกอร์บนตารางใดตารางหนึ่งให้ใช้ AND clause กับชื่อตารางดังนี้ -
testdb=# SELECT tgname FROM pg_trigger, pg_class WHERE tgrelid=pg_class.oid AND relname='company';คำสั่ง PostgreSQL ข้างต้นจะแสดงรายการเพียงรายการเดียวดังนี้ -
tgname
-----------------
example_trigger
(1 row)การทิ้งทริกเกอร์
ต่อไปนี้เป็นคำสั่ง DROP ซึ่งสามารถใช้เพื่อวางทริกเกอร์ที่มีอยู่ -
testdb=# DROP TRIGGER trigger_name;ดัชนีคือตารางการค้นหาพิเศษที่เครื่องมือค้นหาฐานข้อมูลสามารถใช้เพื่อเร่งความเร็วในการดึงข้อมูล พูดง่ายๆคือดัชนีเป็นตัวชี้ไปยังข้อมูลในตาราง ดัชนีในฐานข้อมูลคล้ายกับดัชนีที่อยู่ด้านหลังของหนังสือ
ตัวอย่างเช่นหากคุณต้องการอ้างอิงทุกหน้าในหนังสือที่กล่าวถึงหัวข้อใดหัวข้อหนึ่งก่อนอื่นคุณต้องอ้างถึงดัชนีซึ่งแสดงรายการหัวข้อทั้งหมดตามลำดับตัวอักษรจากนั้นอ้างถึงหมายเลขหน้าหนึ่งหรือหลายหน้า
ดัชนีช่วยเร่งความเร็วในการสืบค้น SELECT และ WHERE clauses; อย่างไรก็ตามมันทำให้การป้อนข้อมูลช้าลงด้วยคำสั่ง UPDATE และ INSERT ดัชนีสามารถสร้างหรือลดลงได้โดยไม่มีผลกระทบต่อข้อมูล
การสร้างดัชนีเกี่ยวข้องกับคำสั่ง CREATE INDEX ซึ่งช่วยให้คุณสามารถตั้งชื่อดัชนีเพื่อระบุตารางและคอลัมน์หรือคอลัมน์ใดที่จะจัดทำดัชนีและเพื่อระบุว่าดัชนีอยู่ในลำดับจากน้อยไปมากหรือมากไปน้อย
ดัชนีสามารถไม่ซ้ำกันได้เช่นเดียวกับข้อ จำกัด UNIQUE เนื่องจากดัชนีป้องกันรายการที่ซ้ำกันในคอลัมน์หรือการรวมกันของคอลัมน์ที่มีดัชนี
คำสั่ง CREATE INDEX
ไวยากรณ์พื้นฐานของ CREATE INDEX มีดังนี้ -
CREATE INDEX index_name ON table_name;ประเภทดัชนี
PostgreSQL มีดัชนีหลายประเภท: B-tree, Hash, GiST, SP-GiST และ GIN ดัชนีแต่ละประเภทใช้อัลกอริทึมที่แตกต่างกันซึ่งเหมาะที่สุดสำหรับการสืบค้นประเภทต่างๆ ตามค่าเริ่มต้นคำสั่ง CREATE INDEX จะสร้างดัชนี B-tree ซึ่งเหมาะกับสถานการณ์ที่พบบ่อยที่สุด
ดัชนีคอลัมน์เดียว
ดัชนีคอลัมน์เดียวคือดัชนีที่สร้างขึ้นจากคอลัมน์ในตารางเดียวเท่านั้น ไวยากรณ์พื้นฐานมีดังนี้ -
CREATE INDEX index_name
ON table_name (column_name);ดัชนีหลายคอลัมน์
ดัชนีหลายคอลัมน์ถูกกำหนดไว้ในคอลัมน์มากกว่าหนึ่งคอลัมน์ของตาราง ไวยากรณ์พื้นฐานมีดังนี้ -
CREATE INDEX index_name
ON table_name (column1_name, column2_name);ไม่ว่าจะสร้างดัชนีคอลัมน์เดียวหรือดัชนีหลายคอลัมน์ให้พิจารณาคอลัมน์ที่คุณอาจใช้บ่อยมากในส่วนคำสั่ง WHERE ของคิวรีเป็นเงื่อนไขตัวกรอง
หากมีเพียงคอลัมน์เดียวที่ใช้ดัชนีคอลัมน์เดียวควรเป็นตัวเลือก หากมีคอลัมน์สองคอลัมน์ขึ้นไปที่ใช้บ่อยในส่วนคำสั่ง WHERE เป็นตัวกรองดัชนีหลายคอลัมน์จะเป็นตัวเลือกที่ดีที่สุด
ดัชนีเฉพาะ
ดัชนีเฉพาะไม่เพียง แต่ใช้เพื่อประสิทธิภาพเท่านั้น แต่ยังใช้เพื่อความสมบูรณ์ของข้อมูลด้วย ดัชนีที่ไม่ซ้ำกันไม่อนุญาตให้แทรกค่าที่ซ้ำกันลงในตาราง ไวยากรณ์พื้นฐานมีดังนี้ -
CREATE UNIQUE INDEX index_name
on table_name (column_name);ดัชนีบางส่วน
ดัชนีบางส่วนคือดัชนีที่สร้างขึ้นจากส่วนย่อยของตาราง ชุดย่อยถูกกำหนดโดยนิพจน์เงื่อนไข (เรียกว่าเพรดิเคตของดัชนีบางส่วน) ดัชนีประกอบด้วยรายการสำหรับแถวตารางที่ตรงตามเพรดิเคตเท่านั้น ไวยากรณ์พื้นฐานมีดังนี้ -
CREATE INDEX index_name
on table_name (conditional_expression);ดัชนีโดยนัย
ดัชนีโดยนัยคือดัชนีที่เซิร์ฟเวอร์ฐานข้อมูลสร้างขึ้นโดยอัตโนมัติเมื่อสร้างวัตถุ ดัชนีจะถูกสร้างขึ้นโดยอัตโนมัติสำหรับข้อ จำกัด ของคีย์หลักและข้อ จำกัด เฉพาะ
ตัวอย่าง
ต่อไปนี้เป็นตัวอย่างที่เราจะสร้างดัชนีในตารางCOMPANYสำหรับคอลัมน์เงินเดือน -
# CREATE INDEX salary_index ON COMPANY (salary);ตอนนี้ให้เราแสดงรายการดัชนีทั้งหมดที่มีอยู่ในตาราง COMPANY โดยใช้ \d company คำสั่ง
# \d companyสิ่งนี้จะให้ผลลัพธ์ต่อไปนี้โดยที่company_pkeyเป็นดัชนีโดยนัยซึ่งถูกสร้างขึ้นเมื่อสร้างตาราง
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)คุณสามารถแสดงรายการฐานข้อมูลดัชนีทั้งหมดได้โดยใช้ไฟล์ \di คำสั่ง -
คำสั่ง DROP INDEX
ดัชนีสามารถลดลงได้โดยใช้ PostgreSQL DROPคำสั่ง ควรใช้ความระมัดระวังเมื่อวางดัชนีเนื่องจากประสิทธิภาพอาจช้าลงหรือดีขึ้น
ไวยากรณ์พื้นฐานมีดังนี้ -
DROP INDEX index_name;คุณสามารถใช้คำสั่งต่อไปนี้เพื่อลบดัชนีที่สร้างไว้ก่อนหน้านี้ -
# DROP INDEX salary_index;เมื่อใดควรหลีกเลี่ยงดัชนี
แม้ว่าดัชนีจะมีจุดมุ่งหมายเพื่อเพิ่มประสิทธิภาพของฐานข้อมูล แต่ก็มีบางครั้งที่ควรหลีกเลี่ยง แนวทางต่อไปนี้ระบุว่าควรพิจารณาการใช้ดัชนีใหม่เมื่อใด -
ไม่ควรใช้ดัชนีบนโต๊ะขนาดเล็ก
ตารางที่มีการอัปเดตแบตช์จำนวนมากบ่อยครั้งหรือการแทรกการดำเนินการ
ไม่ควรใช้ดัชนีในคอลัมน์ที่มีค่า NULL จำนวนมาก
ไม่ควรจัดทำดัชนีคอลัมน์ที่มีการจัดการบ่อยๆ
PostgreSQL ALTER TABLE คำสั่งใช้เพื่อเพิ่มลบหรือแก้ไขคอลัมน์ในตารางที่มีอยู่
คุณยังสามารถใช้คำสั่ง ALTER TABLE เพื่อเพิ่มและวางข้อ จำกัด ต่างๆบนตารางที่มีอยู่
ไวยากรณ์
ไวยากรณ์พื้นฐานของ ALTER TABLE ในการเพิ่มคอลัมน์ใหม่ในตารางที่มีอยู่มีดังนี้ -
ALTER TABLE table_name ADD column_name datatype;ไวยากรณ์พื้นฐานของ ALTER TABLE เป็น DROP COLUMN ในตารางที่มีอยู่มีดังนี้ -
ALTER TABLE table_name DROP COLUMN column_name;ไวยากรณ์พื้นฐานของ ALTER TABLE เพื่อเปลี่ยน DATA TYPE ของคอลัมน์ในตารางมีดังนี้ -
ALTER TABLE table_name ALTER COLUMN column_name TYPE datatype;ไวยากรณ์พื้นฐานของ ALTER TABLE เพื่อเพิ่มไฟล์ NOT NULL ข้อ จำกัด ของคอลัมน์ในตารางมีดังนี้ -
ALTER TABLE table_name MODIFY column_name datatype NOT NULL;ไวยากรณ์พื้นฐานของ ALTER TABLE เป็น ADD UNIQUE CONSTRAINT ตารางเป็นดังนี้ -
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint UNIQUE(column1, column2...);ไวยากรณ์พื้นฐานของ ALTER TABLE เป็น ADD CHECK CONSTRAINT ตารางเป็นดังนี้ -
ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);ไวยากรณ์พื้นฐานของ ALTER TABLE เป็น ADD PRIMARY KEY ข้อ จำกัด ของตารางมีดังนี้ -
ALTER TABLE table_name
ADD CONSTRAINT MyPrimaryKey PRIMARY KEY (column1, column2...);ไวยากรณ์พื้นฐานของ ALTER TABLE เป็น DROP CONSTRAINT จากตารางมีดังนี้ -
ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;หากคุณใช้ MySQL รหัสจะเป็นดังนี้ -
ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;ไวยากรณ์พื้นฐานของ ALTER TABLE เป็น DROP PRIMARY KEY ข้อ จำกัด จากตารางมีดังนี้ -
ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;หากคุณใช้ MySQL รหัสจะเป็นดังนี้ -
ALTER TABLE table_name
DROP PRIMARY KEY;ตัวอย่าง
พิจารณาตาราง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ต่อไปนี้เป็นตัวอย่างในการเพิ่มคอลัมน์ใหม่ในตารางที่มีอยู่ -
testdb=# ALTER TABLE COMPANY ADD GENDER char(1);ตอนนี้ตาราง COMPANY มีการเปลี่ยนแปลงและต่อไปนี้จะเป็นผลลัพธ์จากคำสั่ง 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)ต่อไปนี้เป็นตัวอย่างของคอลัมน์ DROP gender จากตารางที่มีอยู่ -
testdb=# ALTER TABLE COMPANY DROP GENDER;ตอนนี้ตาราง COMPANY มีการเปลี่ยนแปลงและต่อไปนี้จะเป็นผลลัพธ์จากคำสั่ง 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 | 10000PostgreSQL TRUNCATE TABLEคำสั่งใช้เพื่อลบข้อมูลทั้งหมดจากตารางที่มีอยู่ คุณยังสามารถใช้คำสั่ง DROP TABLE เพื่อลบตารางทั้งหมดได้ แต่จะลบโครงสร้างตารางทั้งหมดออกจากฐานข้อมูลและคุณจะต้องสร้างตารางนี้ใหม่อีกครั้งหากคุณต้องการจัดเก็บข้อมูลบางส่วน
มีผลเช่นเดียวกับ DELETE ในแต่ละตาราง แต่เนื่องจากไม่ได้สแกนตารางจริงจึงเร็วกว่า นอกจากนี้ยังเรียกคืนพื้นที่ดิสก์ทันทีแทนที่จะต้องใช้การดำเนินการ VACUUM ในภายหลัง สิ่งนี้มีประโยชน์ที่สุดบนโต๊ะขนาดใหญ่
ไวยากรณ์
ไวยากรณ์พื้นฐานของ TRUNCATE TABLE มีดังนี้ -
TRUNCATE TABLE table_name;ตัวอย่าง
พิจารณาตาราง 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)ต่อไปนี้เป็นตัวอย่างในการตัดทอน -
testdb=# TRUNCATE TABLE COMPANY;ตอนนี้ตาราง COMPANY ถูกตัดทอนและต่อไปนี้จะเป็นผลลัพธ์ของคำสั่ง SELECT -
testdb=# SELECT * FROM CUSTOMERS;
id | name | age | address | salary
----+------+-----+---------+--------
(0 rows)มุมมองเป็นตารางหลอก นั่นคือไม่ใช่ตารางจริง อย่างไรก็ตามจะปรากฏเป็นตารางธรรมดาให้เลือก มุมมองสามารถแสดงส่วนย่อยของตารางจริงโดยเลือกคอลัมน์บางคอลัมน์หรือบางแถวจากตารางธรรมดา มุมมองสามารถแสดงตารางที่เข้าร่วมได้ เนื่องจากมุมมองถูกกำหนดสิทธิ์แยกกันคุณสามารถใช้เพื่อ จำกัด การเข้าถึงตารางเพื่อให้ผู้ใช้เห็นเฉพาะแถวหรือคอลัมน์ของตาราง
มุมมองสามารถมีแถวทั้งหมดของตารางหรือแถวที่เลือกจากตารางอย่างน้อยหนึ่งตาราง สามารถสร้างมุมมองได้จากตารางเดียวหรือหลายตารางซึ่งขึ้นอยู่กับคิวรี PostgreSQL ที่เขียนขึ้นเพื่อสร้างมุมมอง
มุมมองซึ่งเป็นตารางเสมือนช่วยให้ผู้ใช้ทำสิ่งต่อไปนี้ -
จัดโครงสร้างข้อมูลในลักษณะที่ผู้ใช้หรือคลาสของผู้ใช้พบว่าเป็นธรรมชาติหรือใช้งานง่าย
จำกัด การเข้าถึงข้อมูลเพื่อให้ผู้ใช้เห็นเฉพาะข้อมูลที่ จำกัด แทนที่จะเป็นตารางทั้งหมด
สรุปข้อมูลจากตารางต่างๆซึ่งสามารถใช้ในการสร้างรายงาน
เนื่องจากมุมมองไม่ใช่ตารางธรรมดาคุณจึงไม่สามารถดำเนินการคำสั่ง DELETE, INSERT หรือ UPDATE บนมุมมองได้ อย่างไรก็ตามคุณสามารถสร้างกฎเพื่อแก้ไขปัญหานี้ในการใช้ DELETE, INSERT หรือ UPDATE ในมุมมอง
การสร้างมุมมอง
มุมมอง PostgreSQL ถูกสร้างขึ้นโดยใช้ไฟล์ CREATE VIEWคำให้การ. มุมมอง PostgreSQL สามารถสร้างได้จากตารางเดียวหลายตารางหรือมุมมองอื่น
ไวยากรณ์ CREATE VIEW พื้นฐานมีดังนี้ -
CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];คุณสามารถรวมหลายตารางในคำสั่ง SELECT ของคุณในลักษณะที่คล้ายกันมากกับที่คุณใช้ในแบบสอบถาม PostgreSQL SELECT ปกติ หากมีคีย์เวิร์ด TEMP หรือ TEMPORARY ที่เป็นทางเลือกมุมมองจะถูกสร้างขึ้นในช่องว่างชั่วคราว มุมมองชั่วคราวจะลดลงโดยอัตโนมัติเมื่อสิ้นสุดเซสชันปัจจุบัน
ตัวอย่าง
พิจารณาตาราง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ต่อไปนี้เป็นตัวอย่างการสร้างมุมมองจากตาราง COMPANY มุมมองนี้จะใช้เพื่อให้มีคอลัมน์เพียงไม่กี่คอลัมน์จากตาราง COMPANY -
testdb=# CREATE VIEW COMPANY_VIEW AS
SELECT ID, NAME, AGE
FROM COMPANY;ตอนนี้คุณสามารถสืบค้น COMPANY_VIEW ในลักษณะเดียวกับที่คุณค้นหาตารางจริง ต่อไปนี้เป็นตัวอย่าง -
testdb=# SELECT * FROM COMPANY_VIEW;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
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)การลดมุมมอง
ในการวางมุมมองเพียงใช้คำสั่ง DROP VIEW กับ view_name. ไวยากรณ์ DROP VIEW พื้นฐานมีดังนี้ -
testdb=# DROP VIEW view_name;คำสั่งต่อไปนี้จะลบมุมมอง COMPANY_VIEW ซึ่งเราสร้างไว้ในส่วนสุดท้าย -
testdb=# DROP VIEW COMPANY_VIEW;ธุรกรรมคือหน่วยของงานที่ดำเนินการกับฐานข้อมูล ธุรกรรมคือหน่วยหรือลำดับของงานที่ทำตามลำดับตรรกะไม่ว่าจะเป็นแบบกำหนดเองโดยผู้ใช้หรือโดยอัตโนมัติโดยโปรแกรมฐานข้อมูลบางประเภท
ธุรกรรมคือการเผยแพร่การเปลี่ยนแปลงอย่างน้อยหนึ่งรายการในฐานข้อมูล ตัวอย่างเช่นหากคุณกำลังสร้างบันทึกอัปเดตระเบียนหรือลบระเบียนออกจากตารางแสดงว่าคุณกำลังทำธุรกรรมบนโต๊ะ เป็นสิ่งสำคัญในการควบคุมธุรกรรมเพื่อให้แน่ใจว่าข้อมูลมีความสมบูรณ์และจัดการข้อผิดพลาดของฐานข้อมูล
ในทางปฏิบัติคุณจะรวบรวมแบบสอบถาม PostgreSQL จำนวนมากเป็นกลุ่มและคุณจะดำเนินการทั้งหมดร่วมกันเป็นส่วนหนึ่งของธุรกรรม
คุณสมบัติของธุรกรรม
ธุรกรรมมีคุณสมบัติมาตรฐานสี่ประการดังต่อไปนี้โดยปกติจะอ้างถึงโดยตัวย่อ ACID -
Atomicity- ตรวจสอบให้แน่ใจว่าการดำเนินการทั้งหมดภายในหน่วยงานเสร็จสมบูรณ์ มิฉะนั้นธุรกรรมจะถูกยกเลิกเมื่อถึงจุดที่ล้มเหลวและการดำเนินการก่อนหน้านี้จะย้อนกลับไปสู่สถานะเดิม
Consistency - ตรวจสอบให้แน่ใจว่าฐานข้อมูลมีการเปลี่ยนแปลงสถานะอย่างเหมาะสมเมื่อทำธุรกรรมสำเร็จ
Isolation - ช่วยให้การทำธุรกรรมดำเนินการอย่างอิสระและโปร่งใสซึ่งกันและกัน
Durability - ตรวจสอบให้แน่ใจว่าผลลัพธ์หรือผลของธุรกรรมที่ตกลงกันยังคงมีอยู่ในกรณีที่ระบบล้มเหลว
การควบคุมธุรกรรม
คำสั่งต่อไปนี้ใช้เพื่อควบคุมธุรกรรม -
BEGIN TRANSACTION - เพื่อเริ่มการทำธุรกรรม
COMMIT - หากต้องการบันทึกการเปลี่ยนแปลงหรือคุณสามารถใช้ END TRANSACTION คำสั่ง
ROLLBACK - เพื่อย้อนกลับการเปลี่ยนแปลง
คำสั่งควบคุมธุรกรรมใช้เฉพาะกับคำสั่ง DML INSERT, UPDATE และ DELETE เท่านั้น ไม่สามารถใช้ในขณะที่สร้างตารางหรือวางตารางได้เนื่องจากการดำเนินการเหล่านี้ถูกส่งโดยอัตโนมัติในฐานข้อมูล
คำสั่ง BEGIN TRANSACTION
ธุรกรรมสามารถเริ่มต้นได้โดยใช้ BEGIN TRANSACTION หรือคำสั่ง BEGIN ธุรกรรมดังกล่าวมักจะคงอยู่จนกว่าจะพบคำสั่ง COMMIT หรือ ROLLBACK ถัดไป แต่ธุรกรรมจะ ROLLBACK ด้วยหากฐานข้อมูลถูกปิดหรือหากเกิดข้อผิดพลาด
ต่อไปนี้เป็นไวยากรณ์ง่ายๆในการเริ่มต้นธุรกรรม -
BEGIN;
or
BEGIN TRANSACTION;คำสั่ง COMMIT
คำสั่ง COMMIT เป็นคำสั่งธุรกรรมที่ใช้เพื่อบันทึกการเปลี่ยนแปลงที่เรียกใช้โดยธุรกรรมไปยังฐานข้อมูล
คำสั่ง COMMIT บันทึกธุรกรรมทั้งหมดลงในฐานข้อมูลตั้งแต่คำสั่ง COMMIT หรือ ROLLBACK สุดท้าย
ไวยากรณ์สำหรับคำสั่ง COMMIT มีดังนี้ -
COMMIT;
or
END TRANSACTION;คำสั่ง ROLLBACK
คำสั่ง ROLLBACK เป็นคำสั่งธุรกรรมที่ใช้ในการเลิกทำธุรกรรมที่ยังไม่ได้บันทึกลงในฐานข้อมูล
คำสั่ง ROLLBACK สามารถใช้เพื่อเลิกทำธุรกรรมได้ตั้งแต่คำสั่ง COMMIT หรือ ROLLBACK ล่าสุดถูกออก
ไวยากรณ์สำหรับคำสั่ง ROLLBACK มีดังนี้ -
ROLLBACK;ตัวอย่าง
พิจารณาว่าตาราง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ตอนนี้ให้เราเริ่มต้นธุรกรรมและลบบันทึกจากตารางที่มี age = 25 และในที่สุดเราก็ใช้คำสั่ง ROLLBACK เพื่อยกเลิกการเปลี่ยนแปลงทั้งหมด
testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
ROLLBACK;หากคุณจะตรวจสอบตาราง 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ตอนนี้ให้เราเริ่มการทำธุรกรรมใหม่และลบบันทึกจากตารางที่มี age = 25 และในที่สุดเราก็ใช้คำสั่ง COMMIT เพื่อยืนยันการเปลี่ยนแปลงทั้งหมด
testdb=# BEGIN;
DELETE FROM COMPANY WHERE AGE = 25;
COMMIT;หากคุณจะตรวจสอบตาราง COMPANY ก็ยังมีบันทึกต่อไปนี้ -
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)ล็อคหรือExclusive ล็อคหรือล็อคเขียนป้องกันผู้ใช้จากการปรับเปลี่ยนแถวหรือทั้งตาราง แถวที่แก้ไขโดย UPDATE และ DELETE จะถูกล็อคโดยอัตโนมัติในช่วงเวลาของการทำธุรกรรม ซึ่งจะป้องกันไม่ให้ผู้ใช้รายอื่นเปลี่ยนแถวจนกว่าธุรกรรมจะเสร็จสมบูรณ์หรือย้อนกลับ
เวลาเดียวที่ผู้ใช้ต้องรอผู้ใช้รายอื่นคือเมื่อพวกเขาพยายามแก้ไขแถวเดียวกัน หากมีการปรับเปลี่ยนแถวต่างๆไม่จำเป็นต้องรอ เลือกแบบสอบถามไม่ต้องรอ
ฐานข้อมูลจะทำการล็อกโดยอัตโนมัติ อย่างไรก็ตามในบางกรณีต้องควบคุมการล็อกด้วยตนเอง การล็อคแบบแมนนวลสามารถทำได้โดยใช้คำสั่ง LOCK ช่วยให้สามารถกำหนดประเภทการล็อกและขอบเขตของธุรกรรมได้
ไวยากรณ์สำหรับคำสั่ง LOCK
ไวยากรณ์พื้นฐานสำหรับคำสั่ง LOCK มีดังนี้ -
LOCK [ TABLE ]
name
IN
lock_modename- ชื่อ (ที่มีคุณสมบัติตามสคีมา) ของตารางที่มีอยู่เพื่อล็อก ถ้าระบุไว้หน้าชื่อตารางเท่านั้นตารางนั้นจะถูกล็อก หากไม่ได้ระบุไว้เท่านั้นตารางและตารางลำดับถัดมาทั้งหมด (ถ้ามี) จะถูกล็อก
lock_mode- โหมดล็อคจะระบุว่าล็อคใดที่ล็อคนี้ขัดแย้งกับ หากไม่ได้ระบุโหมดล็อคระบบจะใช้ ACCESS EXCLUSIVE ซึ่งเป็นโหมดที่ จำกัด มากที่สุด ค่าที่เป็นไปได้ ได้แก่ ACCESS SHARE, ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE, EXCLUSIVE, ACCESS EXCLUSIVE
เมื่อได้รับแล้วจะมีการล็อคส่วนที่เหลือของธุรกรรมปัจจุบัน ไม่มีคำสั่ง UNLOCK TABLE การล็อกจะถูกปลดล็อกเมื่อสิ้นสุดธุรกรรมเสมอ
DeadLocks
การหยุดชะงักสามารถเกิดขึ้นได้เมื่อธุรกรรมสองรายการกำลังรอให้กันและกันดำเนินการให้เสร็จสิ้น ในขณะที่ PostgreSQL สามารถตรวจจับและปิดท้ายด้วย ROLLBACK การหยุดชะงักก็ยังไม่สะดวก เพื่อป้องกันไม่ให้แอปพลิเคชันของคุณประสบปัญหานี้ตรวจสอบให้แน่ใจว่าได้ออกแบบแอปพลิเคชันในลักษณะที่จะล็อกวัตถุในลำดับเดียวกัน
คำแนะนำล็อค
PostgreSQL มีวิธีการสร้างการล็อกที่มีความหมายที่กำหนดโดยแอปพลิเคชัน เหล่านี้เรียกว่าล็อคที่ปรึกษา เนื่องจากระบบไม่บังคับใช้งานจึงขึ้นอยู่กับแอปพลิเคชันที่จะใช้อย่างถูกต้อง การล็อกคำแนะนำมีประโยชน์สำหรับกลยุทธ์การล็อกที่เหมาะกับโมเดล MVCC
ตัวอย่างเช่นการใช้คำแนะนำทั่วไปในการล็อกคือการเลียนแบบกลยุทธ์การล็อกในแง่ร้ายตามแบบฉบับของระบบการจัดการข้อมูลที่เรียกว่า "ไฟล์แบน" แม้ว่าแฟล็กที่เก็บไว้ในตารางสามารถใช้เพื่อวัตถุประสงค์เดียวกันได้ แต่การล็อกคำแนะนำจะเร็วกว่าหลีกเลี่ยงการขยายตารางและเซิร์ฟเวอร์จะล้างข้อมูลโดยอัตโนมัติเมื่อสิ้นสุดเซสชัน
ตัวอย่าง
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)ตัวอย่างต่อไปนี้ล็อกตาราง COMPANY ภายในฐานข้อมูล testdb ในโหมด ACCESS EXCLUSIVE คำสั่ง LOCK ทำงานในโหมดธุรกรรมเท่านั้น -
testdb=#BEGIN;
LOCK TABLE company1 IN ACCESS EXCLUSIVE MODE;คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
LOCK TABLEข้อความด้านบนระบุว่าตารางถูกล็อกจนกว่าธุรกรรมจะสิ้นสุดและเพื่อสิ้นสุดธุรกรรมคุณจะต้องย้อนกลับหรือกระทำธุรกรรม
แบบสอบถามย่อยหรือแบบสอบถามภายในหรือแบบสอบถามที่ซ้อนกันคือแบบสอบถามภายในแบบสอบถาม PostgreSQL อื่นและฝังอยู่ภายในส่วนคำสั่ง WHERE
แบบสอบถามย่อยใช้เพื่อส่งคืนข้อมูลที่จะใช้ในแบบสอบถามหลักเป็นเงื่อนไขในการ จำกัด ข้อมูลที่จะเรียกเพิ่มเติม
สามารถใช้แบบสอบถามย่อยกับคำสั่ง SELECT, INSERT, UPDATE และ DELETE พร้อมกับตัวดำเนินการเช่น =, <,>,> =, <=, IN เป็นต้น
มีกฎสองสามข้อที่ต้องปฏิบัติตามแบบสอบถามย่อย -
แบบสอบถามย่อยต้องอยู่ในวงเล็บ
แบบสอบถามย่อยสามารถมีได้เพียงคอลัมน์เดียวในส่วนคำสั่ง SELECT เว้นแต่ว่าจะมีหลายคอลัมน์ในแบบสอบถามหลักเพื่อให้แบบสอบถามย่อยเปรียบเทียบคอลัมน์ที่เลือก
ไม่สามารถใช้ ORDER BY ในแบบสอบถามย่อยแม้ว่าแบบสอบถามหลักจะสามารถใช้ ORDER BY ได้ GROUP BY สามารถใช้เพื่อดำเนินการฟังก์ชันเดียวกับ ORDER BY ในแบบสอบถามย่อย
แบบสอบถามย่อยที่ส่งคืนมากกว่าหนึ่งแถวสามารถใช้ได้กับตัวดำเนินการหลายค่าเท่านั้นเช่นตัวดำเนินการ IN, EXISTS, NOT IN, ANY / SOME, ALL
ไม่สามารถใช้ตัวดำเนินการ BETWEEN กับเคียวรีย่อยได้ อย่างไรก็ตาม BETWEEN สามารถใช้ในแบบสอบถามย่อยได้
แบบสอบถามย่อยที่มีคำสั่ง SELECT
แบบสอบถามย่อยมักใช้กับคำสั่ง SELECT ไวยากรณ์พื้นฐานมีดังนี้ -
SELECT column_name [, column_name ]
FROM table1 [, table2 ]
WHERE column_name OPERATOR
(SELECT column_name [, column_name ]
FROM table1 [, table2 ]
[WHERE])ตัวอย่าง
พิจารณาตาราง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)ตอนนี้ให้เราตรวจสอบแบบสอบถามย่อยต่อไปนี้ด้วยคำสั่ง SELECT -
testdb=# SELECT *
FROM COMPANY
WHERE ID IN (SELECT ID
FROM COMPANY
WHERE SALARY > 45000) ;สิ่งนี้จะให้ผลลัพธ์ดังต่อไปนี้ -
id | name | age | address | salary
----+-------+-----+-------------+--------
4 | Mark | 25 | Rich-Mond | 65000
5 | David | 27 | Texas | 85000
(2 rows)แบบสอบถามย่อยที่มีคำสั่ง INSERT
นอกจากนี้ยังสามารถใช้แบบสอบถามย่อยกับคำสั่ง INSERT คำสั่ง INSERT ใช้ข้อมูลที่ส่งกลับจากเคียวรีย่อยเพื่อแทรกลงในตารางอื่น ข้อมูลที่เลือกในแบบสอบถามย่อยสามารถแก้ไขได้ด้วยฟังก์ชันอักขระวันที่หรือตัวเลขใด ๆ
ไวยากรณ์พื้นฐานมีดังนี้ -
INSERT INTO table_name [ (column1 [, column2 ]) ]
SELECT [ *|column1 [, column2 ] ]
FROM table1 [, table2 ]
[ WHERE VALUE OPERATOR ]ตัวอย่าง
พิจารณาตาราง COMPANY_BKP ที่มีโครงสร้างคล้ายกับตาราง COMPANY และสามารถสร้างได้โดยใช้ CREATE TABLE เดียวกันโดยใช้ COMPANY_BKP เป็นชื่อตาราง ตอนนี้เพื่อคัดลอกตาราง COMPANY ที่สมบูรณ์ไปยัง COMPANY_BKP ต่อไปนี้เป็นไวยากรณ์ -
testdb=# INSERT INTO COMPANY_BKP
SELECT * FROM COMPANY
WHERE ID IN (SELECT ID
FROM COMPANY) ;แบบสอบถามย่อยที่มีคำสั่ง UPDATE
สามารถใช้แบบสอบถามย่อยร่วมกับคำสั่ง UPDATE สามารถอัปเดตคอลัมน์เดียวหรือหลายคอลัมน์ในตารางได้เมื่อใช้แบบสอบถามย่อยกับคำสั่ง UPDATE
ไวยากรณ์พื้นฐานมีดังนี้ -
UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]ตัวอย่าง
สมมติว่าเรามีตาราง COMPANY_BKP ซึ่งเป็นข้อมูลสำรองของตาราง COMPANY
ตัวอย่างต่อไปนี้อัปเดต SALARY 0.50 เท่าในตาราง COMPANY สำหรับลูกค้าทั้งหมดที่มี AGE มากกว่าหรือเท่ากับ 27 -
testdb=# UPDATE COMPANY
SET SALARY = SALARY * 0.50
WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
WHERE AGE >= 27 );สิ่งนี้จะส่งผลกระทบต่อสองแถวและสุดท้ายตาราง COMPANY จะมีบันทึกต่อไปนี้ -
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)แบบสอบถามย่อยที่มีคำสั่ง DELETE
แบบสอบถามย่อยสามารถใช้ร่วมกับคำสั่ง DELETE เช่นเดียวกับข้อความอื่น ๆ ที่กล่าวถึงข้างต้น
ไวยากรณ์พื้นฐานมีดังนี้ -
DELETE FROM TABLE_NAME
[ WHERE OPERATOR [ VALUE ]
(SELECT COLUMN_NAME
FROM TABLE_NAME)
[ WHERE) ]ตัวอย่าง
สมมติว่าเรามีตาราง COMPANY_BKP ซึ่งเป็นข้อมูลสำรองของตาราง COMPANY
ตัวอย่างต่อไปนี้จะลบบันทึกจากตาราง COMPANY สำหรับลูกค้าทั้งหมดที่มี AGE มากกว่าหรือเท่ากับ 27 -
testdb=# DELETE FROM COMPANY
WHERE AGE IN (SELECT AGE FROM COMPANY_BKP
WHERE AGE > 27 );สิ่งนี้จะส่งผลกระทบต่อสองแถวและสุดท้ายตาราง COMPANY จะมีบันทึกต่อไปนี้ -
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 มีชนิดข้อมูลsmallserialอนุกรมและbigserial ; สิ่งเหล่านี้ไม่ใช่ประเภทที่แท้จริง แต่เป็นเพียงความสะดวกสบายในการสร้างคอลัมน์ตัวระบุที่ไม่ซ้ำกัน สิ่งเหล่านี้คล้ายกับคุณสมบัติ AUTO_INCREMENT ที่สนับสนุนโดยฐานข้อมูลอื่น ๆ
หากคุณต้องการให้คอลัมน์อนุกรมมีข้อ จำกัด เฉพาะหรือเป็นคีย์หลักตอนนี้ต้องระบุเช่นเดียวกับข้อมูลประเภทอื่น ๆ
ชื่อชนิดอนุกรมสร้างคอลัมน์จำนวนเต็ม ชื่อชนิดbigserialสร้างคอลัมน์bigint ควรใช้bigserialหากคุณคาดว่าจะมีการใช้ตัวระบุมากกว่า 2 31ตัวตลอดอายุการใช้งานของตาราง ชื่อชนิดsmallserialสร้างคอลัมน์smallint
ไวยากรณ์
การใช้งานพื้นฐานของ SERIAL dataype มีดังนี้ -
CREATE TABLE tablename (
colname SERIAL
);ตัวอย่าง
พิจารณาตาราง COMPANY ที่จะสร้างดังต่อไปนี้ -
testdb=# CREATE TABLE COMPANY(
ID SERIAL PRIMARY KEY,
NAME TEXT NOT NULL,
AGE INT NOT NULL,
ADDRESS CHAR(50),
SALARY REAL
);ตอนนี้แทรกบันทึกต่อไปนี้ลงในตาราง 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 );สิ่งนี้จะแทรกเจ็ด tuples ลงในตาราง COMPANY และ 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เมื่อใดก็ตามที่วัตถุถูกสร้างขึ้นในฐานข้อมูลเจ้าของจะถูกกำหนดให้กับมัน เจ้าของมักจะเป็นผู้ดำเนินการคำสั่งสร้าง สำหรับวัตถุส่วนใหญ่สถานะเริ่มต้นคือมีเพียงเจ้าของ (หรือผู้ใช้ขั้นสูง) เท่านั้นที่สามารถแก้ไขหรือลบวัตถุได้ ในการอนุญาตให้บทบาทหรือผู้ใช้อื่น ๆ ใช้งานได้ต้องให้สิทธิ์พิเศษหรือการอนุญาต
สิทธิพิเศษประเภทต่างๆใน PostgreSQL ได้แก่ -
- SELECT,
- INSERT,
- UPDATE,
- DELETE,
- TRUNCATE,
- REFERENCES,
- TRIGGER,
- CREATE,
- CONNECT,
- TEMPORARY,
- ดำเนินการและ
- USAGE
ขึ้นอยู่กับประเภทของวัตถุ (ตารางฟังก์ชัน ฯลฯ ) สิทธิ์จะถูกนำไปใช้กับวัตถุ ในการกำหนดสิทธิ์ให้กับผู้ใช้จะใช้คำสั่ง GRANT
ไวยากรณ์สำหรับ GRANT
ไวยากรณ์พื้นฐานสำหรับคำสั่ง GRANT มีดังนี้ -
GRANT privilege [, ...]
ON object [, ...]
TO { PUBLIC | GROUP group | username }privilege - ค่าอาจเป็น: SELECT, INSERT, UPDATE, DELETE, RULE, ALL
object- ชื่อของวัตถุที่จะให้สิทธิ์เข้าถึง วัตถุที่เป็นไปได้ ได้แก่ ตารางมุมมองลำดับ
PUBLIC - รูปแบบสั้น ๆ ที่แสดงถึงผู้ใช้ทั้งหมด
กลุ่ม group - กลุ่มที่ให้สิทธิ์
username- ชื่อผู้ใช้ที่จะให้สิทธิ์ PUBLIC เป็นรูปแบบสั้น ๆ ที่แสดงถึงผู้ใช้ทั้งหมด
สามารถเพิกถอนสิทธิ์ได้โดยใช้คำสั่ง REVOKE
ไวยากรณ์สำหรับ REVOKE
ไวยากรณ์พื้นฐานสำหรับคำสั่ง REVOKE มีดังนี้ -
REVOKE privilege [, ...]
ON object [, ...]
FROM { PUBLIC | GROUP groupname | username }privilege - ค่าอาจเป็น: SELECT, INSERT, UPDATE, DELETE, RULE, ALL
object- ชื่อของวัตถุที่จะให้สิทธิ์เข้าถึง วัตถุที่เป็นไปได้ ได้แก่ ตารางมุมมองลำดับ
PUBLIC - รูปแบบสั้น ๆ ที่แสดงถึงผู้ใช้ทั้งหมด
กลุ่ม group - กลุ่มที่ให้สิทธิ์
username- ชื่อผู้ใช้ที่จะให้สิทธิ์ PUBLIC เป็นรูปแบบสั้น ๆ ที่แสดงถึงผู้ใช้ทั้งหมด
ตัวอย่าง
เพื่อทำความเข้าใจเกี่ยวกับสิทธิพิเศษให้เราสร้าง USER ก่อนดังนี้ -
testdb=# CREATE USER manisha WITH PASSWORD 'password';
CREATE ROLEข้อความ CREATE ROLE ระบุว่ามีการสร้าง USER "manisha"
พิจารณาตารางCOMPANY ที่มีบันทึกดังนี้ -
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)ต่อไปให้เรามอบสิทธิพิเศษทั้งหมดบนโต๊ะ COMPANY ให้กับผู้ใช้ "manisha" ดังนี้ -
testdb=# GRANT ALL ON COMPANY TO manisha;
GRANTข้อความ GRANT ระบุว่ามีการกำหนดสิทธิ์ทั้งหมดให้กับ USER
ต่อไปให้เราเพิกถอนสิทธิพิเศษจาก USER "manisha" ดังนี้ -
testdb=# REVOKE ALL ON COMPANY FROM manisha;
REVOKEข้อความ REVOKE ระบุว่าสิทธิ์ทั้งหมดถูกเพิกถอนจาก USER
คุณสามารถลบผู้ใช้ดังต่อไปนี้ -
testdb=# DROP USER manisha;
DROP ROLEข้อความ DROP ROLE ระบุว่า USER 'Manisha' ถูกลบออกจากฐานข้อมูล
เราได้พูดคุยกันเกี่ยวกับวันที่ / เวลาชนิดข้อมูลในบทที่ชนิดข้อมูล ตอนนี้ให้เราดูตัวดำเนินการวันที่ / เวลาและฟังก์ชัน
ตารางต่อไปนี้แสดงพฤติกรรมของตัวดำเนินการเลขคณิตพื้นฐาน -
| ตัวดำเนินการ | ตัวอย่าง | ผลลัพธ์ |
|---|---|---|
| + | วันที่ '2001-09-28' + จำนวนเต็ม '7' | วันที่ '2001-10-05' |
| + | วันที่ '2001-09-28' + ช่วงเวลา '1 ชั่วโมง' | ประทับเวลา '2001-09-28 01:00:00' |
| + | วันที่ '2001-09-28' + เวลา '03: 00 ' | ประทับเวลา '2001-09-28 03:00:00' |
| + | ช่วงเวลา '1 วัน' + ช่วงเวลา '1 ชั่วโมง' | ช่วง '1 วัน 01:00:00' |
| + | เวลาประทับ '2001-09-28 01:00' + ช่วงเวลา '23 ชั่วโมง ' | ประทับเวลา '2001-09-29 00:00:00' |
| + | เวลา '01: 00 '+ ช่วงเวลา' 3 ชั่วโมง ' | เวลา '04: 00: 00 น. |
| - | - ช่วงเวลา '23 ชั่วโมง ' | ช่วง '-23: 00: 00 น. |
| - | วันที่ '2001-10-01' - วันที่ '2001-09-28' | จำนวนเต็ม '3' (วัน) |
| - | วันที่ '2001-10-01' - จำนวนเต็ม '7' | วันที่ '2001-09-24' |
| - | วันที่ '2001-09-28' - ช่วงเวลา '1 ชั่วโมง' | เวลา '2001-09-27 23:00:00' |
| - | เวลา '05: 00 '- เวลา '03: 00' | ช่วงเวลา '02: 00: 00 น. |
| - | เวลา '05: 00 '- ช่วงเวลา' 2 ชั่วโมง ' | เวลา '03: 00: 00 น. |
| - | ประทับเวลา '2001-09-28 23:00' - ช่วงเวลา '23 ชั่วโมง ' | ประทับเวลา '2001-09-28 00:00:00' |
| - | ช่วงเวลา '1 วัน' - ช่วงเวลา '1 ชั่วโมง' | ช่วง '1 วัน -01: 00: 00' |
| - | เวลาประทับ '2001-09-29 03:00' - ประทับเวลา '2001-09-27 12:00' | ช่วง '1 วัน 15:00:00' |
| * | 900 * ช่วงเวลา '1 วินาที' | ช่วงเวลา '00: 15: 00 น. |
| * | 21 * ช่วง '1 วัน' | ช่วง '21 วัน ' |
| * | ความแม่นยำสองเท่า '3.5' * ช่วงเวลา '1 ชั่วโมง' | ช่วงเวลา '03: 30: 00 น. |
| / | ช่วงเวลา '1 ชั่วโมง' / ความแม่นยำสองเท่า '1.5' | ช่วงเวลา '00: 40: 00 ' |
ต่อไปนี้เป็นรายการฟังก์ชันที่เกี่ยวข้องกับวันที่และเวลาที่สำคัญทั้งหมดที่มีอยู่
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | อายุ() ลบอาร์กิวเมนต์ |
| 2 | วันที่ / เวลาปัจจุบัน () วันที่และเวลาปัจจุบัน |
| 3 | DATE_PART () รับฟิลด์ย่อย (เทียบเท่ากับการแยก) |
| 4 | สารสกัด () รับฟิลด์ย่อย |
| 5 | ISFINITE () ทดสอบวันที่เวลาและช่วงเวลาที่ จำกัด (ไม่ใช่ +/- อินฟินิตี้) |
| 6 | ยุติธรรม ปรับช่วงเวลา |
อายุ (ประทับเวลาประทับเวลา) อายุ (ประทับเวลา)
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | AGE(timestamp, timestamp) เมื่อเรียกใช้ด้วยรูปแบบ TIMESTAMP ของอาร์กิวเมนต์ที่สอง AGE () จะลบอาร์กิวเมนต์ทำให้ได้ผลลัพธ์ "สัญลักษณ์" ที่ใช้ปีและเดือนและเป็นประเภท INTERVAL |
| 2 | AGE(timestamp) เมื่อเรียกใช้โดยมีเพียง TIMESTAMP เป็นอาร์กิวเมนต์ AGE () จะลบออกจาก current_date (ตอนเที่ยงคืน) |
ตัวอย่างของฟังก์ชัน AGE (timestamp, timestamp) คือ -
testdb=# SELECT AGE(timestamp '2001-04-10', timestamp '1957-06-13');คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
age
-------------------------
43 years 9 mons 27 daysตัวอย่างของฟังก์ชัน AGE (การประทับเวลา) คือ -
testdb=# select age(timestamp '1957-06-13');คำสั่ง PostgreSQL ข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้ -
age
--------------------------
55 years 10 mons 22 daysวันที่ / เวลาปัจจุบัน ()
PostgreSQL มีฟังก์ชันจำนวนมากที่ส่งคืนค่าที่เกี่ยวข้องกับวันที่และเวลาปัจจุบัน ต่อไปนี้เป็นฟังก์ชั่นบางอย่าง -
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | CURRENT_DATE ส่งวันที่ปัจจุบัน |
| 2 | CURRENT_TIME แสดงค่าด้วยเขตเวลา |
| 3 | CURRENT_TIMESTAMP แสดงค่าด้วยเขตเวลา |
| 4 | CURRENT_TIME(precision) เลือกใช้พารามิเตอร์ที่มีความแม่นยำซึ่งทำให้ผลลัพธ์ถูกปัดเศษเป็นตัวเลขเศษส่วนจำนวนมากในฟิลด์วินาที |
| 5 | CURRENT_TIMESTAMP(precision) เลือกใช้พารามิเตอร์ที่มีความแม่นยำซึ่งทำให้ผลลัพธ์ถูกปัดเศษเป็นตัวเลขเศษส่วนจำนวนมากในฟิลด์วินาที |
| 6 | LOCALTIME แสดงค่าโดยไม่มีเขตเวลา |
| 7 | LOCALTIMESTAMP แสดงค่าโดยไม่มีเขตเวลา |
| 8 | LOCALTIME(precision) เลือกใช้พารามิเตอร์ที่มีความแม่นยำซึ่งทำให้ผลลัพธ์ถูกปัดเศษเป็นตัวเลขเศษส่วนจำนวนมากในฟิลด์วินาที |
| 9 | LOCALTIMESTAMP(precision) เลือกใช้พารามิเตอร์ที่มีความแม่นยำซึ่งทำให้ผลลัพธ์ถูกปัดเศษเป็นตัวเลขเศษส่วนจำนวนมากในฟิลด์วินาที |
ตัวอย่างการใช้ฟังก์ชันจากตารางด้านบน -
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 ยังมีฟังก์ชันที่ส่งคืนเวลาเริ่มต้นของคำสั่งปัจจุบันเช่นเดียวกับเวลาปัจจุบันจริงในทันทีที่เรียกใช้ฟังก์ชัน ฟังก์ชันเหล่านี้คือ -
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | transaction_timestamp() เทียบเท่ากับ CURRENT_TIMESTAMP แต่ตั้งชื่อเพื่อให้สะท้อนถึงสิ่งที่ส่งคืนอย่างชัดเจน |
| 2 | statement_timestamp() ส่งคืนเวลาเริ่มต้นของคำสั่งปัจจุบัน |
| 3 | clock_timestamp() ส่งคืนเวลาปัจจุบันที่แท้จริงดังนั้นค่าของมันจึงเปลี่ยนไปแม้ในคำสั่ง SQL คำสั่งเดียว |
| 4 | timeofday() ส่งคืนเวลาปัจจุบันจริง แต่เป็นสตริงข้อความที่จัดรูปแบบแล้วแทนที่จะเป็นการประทับเวลาที่มีค่าโซนเวลา |
| 5 | now() เป็น PostgreSQL แบบดั้งเดิมที่เทียบเท่ากับ transaction_timestamp () |
DATE_PART (ข้อความการประทับเวลา) DATE_PART (ข้อความช่วงเวลา) DATE_TRUNC (ข้อความการประทับเวลา)
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | DATE_PART('field', source) ฟังก์ชันเหล่านี้ได้รับเขตข้อมูลย่อย ฟิลด์พารามิเตอร์จะต้องมีค่าสตริงไม่ชื่อ ชื่อเขตข้อมูลที่ถูกต้อง ได้แก่ศตวรรษวันทศวรรษดาวโดยุคสมัยชั่วโมงไอโซโดวไอโซเอียร์ไมโครวินาทีสหัสวรรษมิลลิวินาทีนาทีเดือนไตรมาสที่สองเขตเวลาเขตเวลา _ ชั่วโมงเขตเวลา _ นาทีสัปดาห์ปี |
| 2 | DATE_TRUNC('field', source) ฟังก์ชันนี้มีแนวคิดคล้ายกับฟังก์ชันtruncสำหรับตัวเลข แหล่งที่มาคือนิพจน์ค่าของประเภทการประทับเวลาหรือช่วงเวลา ฟิลด์เลือกว่าความแม่นยำใดที่จะตัดทอนค่าอินพุต ค่าตอบแทนเป็นประเภทการประทับเวลาหรือช่วงเวลา ค่าที่ถูกต้องสำหรับฟิลด์คือไมโครวินาทีมิลลิวินาทีวินาทีนาทีชั่วโมงวันสัปดาห์เดือนไตรมาสปีทศวรรษศตวรรษสหัสวรรษ |
ต่อไปนี้เป็นตัวอย่างสำหรับฟังก์ชัน 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)ต่อไปนี้เป็นตัวอย่างสำหรับฟังก์ชัน 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)EXTRACT (ฟิลด์จากการประทับเวลา), EXTRACT (ฟิลด์จากช่วงเวลา)
EXTRACT(field FROM source)ฟังก์ชันดึงฟิลด์ย่อยเช่นปีหรือชั่วโมงจากค่าวันที่ / เวลา แหล่งที่มาจะต้องมีการแสดงออกค่าของชนิดประทับเวลาเวลาหรือช่วงเวลา สนามเป็นตัวระบุหรือสตริงที่เลือกสิ่งที่จะดึงข้อมูลจากมูลค่าของแหล่งที่มา ฟังก์ชั่นสารสกัดจากผลตอบแทนค่าประเภทความแม่นยำสอง
ต่อไปนี้เป็นชื่อฟิลด์ที่ถูกต้อง (คล้ายกับชื่อฟิลด์ฟังก์ชัน DATE_PART): ศตวรรษ, วัน, ทศวรรษ, ดาวโจนส์, ยุค, ชั่วโมง, ไอโซโดว, ไอโซเอียร์, ไมโครวินาที, สหัสวรรษ, มิลลิวินาที, นาที, เดือน, ไตรมาส, วินาที, เขตเวลา, เขตเวลา, timezone_hour , timezone_minute, สัปดาห์, ปี
ต่อไปนี้เป็นตัวอย่างของฟังก์ชัน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 (วันที่), ISFINITE (ประทับเวลา), ISFINITE (ช่วงเวลา)
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | ISFINITE(date) ทดสอบวันที่ จำกัด |
| 2 | ISFINITE(timestamp) ทดสอบการประทับเวลา จำกัด |
| 3 | ISFINITE(interval) ทดสอบช่วงเวลา จำกัด |
ต่อไปนี้เป็นตัวอย่างของฟังก์ชัน 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 (ช่วงเวลา), JUSTIFY_HOURS (ช่วงเวลา), JUSTIFY_INTERVAL (ช่วงเวลา)
| ส. เลขที่ | ฟังก์ชั่นและคำอธิบาย |
|---|---|
| 1 | JUSTIFY_DAYS(interval) ปรับช่วงเวลาเพื่อให้ช่วงเวลา 30 วันแสดงเป็นเดือน ส่งคืนไฟล์interval ชนิด |
| 2 | JUSTIFY_HOURS(interval) ปรับช่วงเวลาเพื่อให้ช่วงเวลา 24 ชั่วโมงแสดงเป็นวัน ส่งคืนไฟล์interval ชนิด |
| 3 | JUSTIFY_INTERVAL(interval) ปรับช่วงเวลาโดยใช้ JUSTIFY_DAYS และ JUSTIFY_HOURS พร้อมการปรับป้ายเพิ่มเติม ส่งคืนไฟล์interval ชนิด |
ต่อไปนี้เป็นตัวอย่างสำหรับฟังก์ชัน 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หรือที่เรียกว่า Stored Procedures ช่วยให้คุณสามารถดำเนินการที่โดยปกติจะใช้เวลาหลายแบบสอบถามและไปกลับในฟังก์ชันเดียวภายในฐานข้อมูล ฟังก์ชันช่วยให้สามารถใช้ฐานข้อมูลซ้ำได้เนื่องจากแอปพลิเคชันอื่นสามารถโต้ตอบโดยตรงกับโพรซีเดอร์ที่จัดเก็บไว้ของคุณแทนที่จะใช้รหัสระดับกลางหรือรหัสซ้ำ
สามารถสร้างฟังก์ชันในภาษาที่คุณเลือกเช่น SQL, PL / pgSQL, C, Python เป็นต้น
ไวยากรณ์
ไวยากรณ์พื้นฐานในการสร้างฟังก์ชันมีดังนี้ -
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;ที่ไหน
function-name ระบุชื่อของฟังก์ชัน
ตัวเลือก [หรือแทนที่] อนุญาตให้แก้ไขฟังก์ชันที่มีอยู่
ฟังก์ชันต้องมีไฟล์ return คำให้การ.
RETURNอนุประโยคระบุชนิดข้อมูลที่คุณจะส่งคืนจากฟังก์ชัน return_datatype สามารถเป็นประเภทฐานคอมโพสิตหรือโดเมนหรือสามารถอ้างอิงประเภทของคอลัมน์ตาราง
function-body มีส่วนปฏิบัติการ
คีย์เวิร์ด AS ใช้สำหรับสร้างฟังก์ชันแบบสแตนด์อโลน
plpgsqlคือชื่อของภาษาที่ใช้ฟังก์ชันนี้ในที่นี้เราใช้ตัวเลือกนี้สำหรับ PostgreSQL ซึ่งอาจเป็น SQL, C, internal หรือชื่อของภาษาขั้นตอนที่ผู้ใช้กำหนดเอง สำหรับความเข้ากันได้แบบย้อนหลังชื่อสามารถถูกใส่ไว้ด้วยเครื่องหมายคำพูดเดี่ยว
ตัวอย่าง
ตัวอย่างต่อไปนี้แสดงให้เห็นถึงการสร้างและเรียกใช้ฟังก์ชันแบบสแตนด์อโลน ฟังก์ชันนี้ส่งคืนจำนวนระเบียนทั้งหมดในตาราง COMPANY เราจะใช้ตารางCOMPANYซึ่งมีบันทึกดังต่อไปนี้ -
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)ฟังก์ชัน totalRecords () มีดังนี้ -
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;เมื่อดำเนินการค้นหาข้างต้นผลลัพธ์จะเป็น -
testdb# CREATE FUNCTIONตอนนี้ให้เราเรียกใช้ฟังก์ชันนี้และตรวจสอบบันทึกในตาราง COMPANY
testdb=# select totalRecords();เมื่อดำเนินการค้นหาข้างต้นผลลัพธ์จะเป็น -
totalrecords
--------------
7
(1 row)ฟังก์ชันในตัว PostgreSQL เรียกอีกอย่างว่าฟังก์ชัน Aggregate ใช้สำหรับประมวลผลข้อมูลสตริงหรือตัวเลข
ต่อไปนี้เป็นรายการฟังก์ชันในตัว PostgreSQL ที่ใช้งานทั่วไปทั้งหมด -
PostgreSQL COUNT Function - ฟังก์ชันการรวม PostgreSQL COUNT ใช้เพื่อนับจำนวนแถวในตารางฐานข้อมูล
ฟังก์ชัน PostgreSQL MAX - ฟังก์ชันการรวม PostgreSQL MAX ช่วยให้เราสามารถเลือกค่าสูงสุด (สูงสุด) สำหรับคอลัมน์หนึ่ง ๆ
ฟังก์ชัน PostgreSQL MIN - ฟังก์ชันการรวม PostgreSQL MIN ช่วยให้เราสามารถเลือกค่าต่ำสุด (ต่ำสุด) สำหรับคอลัมน์หนึ่ง ๆ
ฟังก์ชัน PostgreSQL AVG - ฟังก์ชันการรวม PostgreSQL AVG จะเลือกค่าเฉลี่ยสำหรับคอลัมน์ตารางบางคอลัมน์
ฟังก์ชัน PostgreSQL SUM - ฟังก์ชันการรวม PostgreSQL SUM อนุญาตให้เลือกผลรวมสำหรับคอลัมน์ตัวเลข
ฟังก์ชัน PostgreSQL ARRAY - ฟังก์ชันการรวมของ PostgreSQL ARRAY จะใส่ค่าอินพุตรวมทั้ง nulls ที่ต่อเข้ากับอาร์เรย์
ฟังก์ชันตัวเลข PostgreSQL - รายการฟังก์ชัน PostgreSQL ทั้งหมดที่จำเป็นในการจัดการกับตัวเลขใน SQL
ฟังก์ชันสตริง PostgreSQL - รายการฟังก์ชัน PostgreSQL ทั้งหมดที่จำเป็นในการจัดการสตริงใน PostgreSQL
บทช่วยสอนนี้จะใช้ libpqxxไลบรารีซึ่งเป็นไคลเอนต์ C ++ API อย่างเป็นทางการสำหรับ PostgreSQL ซอร์สโค้ดสำหรับ libpqxx มีอยู่ภายใต้ใบอนุญาต BSD ดังนั้นคุณจึงมีอิสระที่จะดาวน์โหลดส่งต่อให้ผู้อื่นเปลี่ยนแปลงขายรวมไว้ในรหัสของคุณเองและแบ่งปันการเปลี่ยนแปลงของคุณกับใครก็ตามที่คุณเลือก
การติดตั้ง
รุ่นล่าสุดของ libpqxx สามารถใช้ได้เพื่อดาวน์โหลดได้จากลิงค์ดาวน์โหลด Libpqxx ดังนั้นดาวน์โหลดเวอร์ชันล่าสุดและทำตามขั้นตอนต่อไปนี้ -
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ก่อนที่คุณจะเริ่มใช้อินเตอร์เฟส C / C ++ PostgreSQL ให้ค้นหาไฟล์ pg_hba.conf ไฟล์ในไดเร็กทอรีการติดตั้ง PostgreSQL ของคุณและเพิ่มบรรทัดต่อไปนี้ -
# IPv4 local connections:
host all all 127.0.0.1/32 md5คุณสามารถเริ่ม / รีสตาร์ทเซิร์ฟเวอร์ postgres ในกรณีที่ไม่ได้ทำงานโดยใช้คำสั่งต่อไปนี้ -
[root@host]# service postgresql restart
Stopping postgresql service: [ OK ]
Starting postgresql service: [ OK ]API ของอินเตอร์เฟส C / C ++
ต่อไปนี้เป็นรูทีนอินเทอร์เฟซที่สำคัญซึ่งสามารถตอบสนองความต้องการของคุณในการทำงานกับฐานข้อมูล PostgreSQL จากโปรแกรม C / C ++ ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของ libpqxx หรือคุณสามารถใช้ API ที่มีจำหน่ายทั่วไป
| ส. เลขที่ | API และคำอธิบาย |
|---|---|
| 1 | pqxx::connection C( const std::string & dbstring ) นี่คือ typedef ซึ่งจะใช้เพื่อเชื่อมต่อกับฐานข้อมูล ที่นี่ dbstring จัดเตรียมพารามิเตอร์ที่จำเป็นเพื่อเชื่อมต่อกับฐานข้อมูลตัวอย่างเช่นdbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432. หากตั้งค่าการเชื่อมต่อสำเร็จจะสร้าง C พร้อมวัตถุการเชื่อมต่อซึ่งมีฟังก์ชันสาธารณะที่มีประโยชน์มากมาย |
| 2 | C.is_open() เมธอด is_open () เป็นเมธอดสาธารณะของอ็อบเจ็กต์การเชื่อมต่อและส่งคืนค่าบูลีน หากการเชื่อมต่อทำงานอยู่วิธีนี้จะคืนค่าจริงมิฉะนั้นจะส่งกลับเท็จ |
| 3 | C.disconnect() วิธีนี้ใช้เพื่อยกเลิกการเชื่อมต่อฐานข้อมูลที่เปิดอยู่ |
| 4 | pqxx::work W( C ) นี่คือ typedef ซึ่งจะใช้ในการสร้างวัตถุทรานแซคชันโดยใช้การเชื่อมต่อ C ซึ่งท้ายที่สุดจะใช้เพื่อดำเนินการคำสั่ง SQL ในโหมดธุรกรรม หากสร้างวัตถุธุรกรรมสำเร็จแล้วจะถูกกำหนดให้กับตัวแปร W ซึ่งจะใช้เพื่อเข้าถึงวิธีการสาธารณะที่เกี่ยวข้องกับวัตถุธุรกรรม |
| 5 | W.exec(const std::string & sql) วิธีการสาธารณะจากวัตถุการทำธุรกรรมนี้จะถูกใช้เพื่อดำเนินการคำสั่ง SQL |
| 6 | W.commit() วิธีการสาธารณะจากวัตถุการทำธุรกรรมนี้จะถูกใช้เพื่อกระทำธุรกรรม |
| 7 | W.abort() วิธีการสาธารณะจากวัตถุธุรกรรมนี้จะถูกใช้เพื่อย้อนกลับธุรกรรม |
| 8 | pqxx::nontransaction N( C ) นี่คือ typedef ซึ่งจะใช้ในการสร้างออบเจ็กต์ที่ไม่ใช่ธุรกรรมโดยใช้การเชื่อมต่อ C ซึ่งท้ายที่สุดจะใช้เพื่อดำเนินการคำสั่ง SQL ในโหมดที่ไม่ใช่ธุรกรรม หากสร้างอ็อบเจ็กต์ธุรกรรมสำเร็จแล้วจะถูกกำหนดให้กับตัวแปร N ซึ่งจะใช้เพื่อเข้าถึงเมธอดสาธารณะที่เกี่ยวข้องกับอ็อบเจ็กต์ที่ไม่ใช่ธุรกรรม |
| 9 | N.exec(const std::string & sql) วิธีการสาธารณะจากอ็อบเจ็กต์ที่ไม่ใช่ธุรกรรมนี้จะถูกใช้เพื่อดำเนินการคำสั่ง SQL และส่งคืนอ็อบเจ็กต์ผลลัพธ์ซึ่งเป็นจำนวนเต็มที่เก็บเร็กคอร์ดที่ส่งคืนทั้งหมด |
การเชื่อมต่อกับฐานข้อมูล
ส่วนรหัส C ต่อไปนี้แสดงวิธีการเชื่อมต่อกับฐานข้อมูลที่มีอยู่ซึ่งทำงานบนเครื่องโลคัลที่พอร์ต 5432 ที่นี่ฉันใช้แบ็กสแลช \ สำหรับการต่อเนื่องของบรรทัด
#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;
}
}ตอนนี้ให้เรารวบรวมและเรียกใช้โปรแกรมด้านบนเพื่อเชื่อมต่อกับฐานข้อมูลของเรา testdbซึ่งมีอยู่แล้วในคีมาของคุณและสามารถเข้าถึงได้โดยผู้ใช้Postgresและรหัสผ่านpass123
คุณสามารถใช้ ID ผู้ใช้และรหัสผ่านตามการตั้งค่าฐานข้อมูลของคุณ อย่าลืมเก็บ -lpqxx และ -lpq ตามลำดับที่กำหนด! มิฉะนั้นผู้เชื่อมโยงจะบ่นอย่างขมขื่นเกี่ยวกับฟังก์ชันที่ขาดหายไปโดยมีชื่อขึ้นต้นด้วย "PQ"
$g++ test.cpp -lpqxx -lpq $./a.out
Opened database successfully: testdbสร้างตาราง
ส่วนรหัส C ต่อไปนี้จะถูกใช้เพื่อสร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้ -
#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;
}เมื่อโปรแกรมที่กำหนดข้างต้นถูกคอมไพล์และดำเนินการโปรแกรมจะสร้างตาราง COMPANY ในฐานข้อมูล testdb ของคุณและจะแสดงข้อความต่อไปนี้ -
Opened database successfully: testdb
Table created successfullyการทำงานของ INSERT
ส่วนรหัส C ต่อไปนี้แสดงให้เห็นว่าเราสามารถสร้างเรกคอร์ดในตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
#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;
}เมื่อโปรแกรมที่กำหนดข้างต้นถูกคอมไพล์และดำเนินการโปรแกรมจะสร้างเรกคอร์ดที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -
Opened database successfully: testdb
Records created successfullyเลือกการทำงาน
ส่วนรหัส C ต่อไปนี้แสดงให้เห็นว่าเราสามารถดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
#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;
}เมื่อโปรแกรมที่กำหนดข้างต้นถูกคอมไพล์และดำเนินการโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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อัปเดตการทำงาน
ส่วนรหัส C ต่อไปนี้แสดงให้เห็นว่าเราสามารถใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่อัปเดตจากตาราง COMPANY ของเรา -
#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;
}เมื่อโปรแกรมที่กำหนดข้างต้นถูกคอมไพล์และดำเนินการโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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ลบการดำเนินการ
ส่วนรหัส C ต่อไปนี้แสดงวิธีที่เราสามารถใช้คำสั่ง DELETE เพื่อลบบันทึกใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY
#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;
}เมื่อโปรแกรมที่กำหนดข้างต้นถูกคอมไพล์และดำเนินการโปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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การติดตั้ง
ก่อนที่เราจะเริ่มใช้ PostgreSQL ในโปรแกรม Java ของเราเราต้องตรวจสอบให้แน่ใจว่าได้ตั้งค่า PostgreSQL JDBC และ Java ไว้ในเครื่องแล้ว คุณสามารถตรวจสอบบทช่วยสอน Java สำหรับการติดตั้ง Java บนเครื่องของคุณ ตอนนี้ให้เราตรวจสอบวิธีการตั้งค่าไดรเวอร์ PostgreSQL JDBC
ดาวน์โหลดเวอร์ชันล่าสุดของpostgresql- (VERSION) .jdbc.jarจากที่เก็บpostgresql-jdbc
เพิ่มไฟล์ jar ที่ดาวน์โหลดpostgresql- (VERSION) .jdbc.jarในพา ธ คลาสของคุณหรือคุณสามารถใช้ร่วมกับอ็อพชัน -classpath ตามที่อธิบายไว้ด้านล่างในตัวอย่าง
ส่วนต่อไปนี้ถือว่าคุณมีความรู้เพียงเล็กน้อยเกี่ยวกับแนวคิด Java JDBC หากคุณไม่มีขอแนะนำให้ใช้เวลาครึ่งชั่วโมงกับJDBC Tutorialเพื่อให้คุ้นเคยกับแนวคิดที่อธิบายด้านล่าง
การเชื่อมต่อกับฐานข้อมูล
โค้ด Java ต่อไปนี้แสดงวิธีเชื่อมต่อกับฐานข้อมูลที่มีอยู่ ถ้าฐานข้อมูลไม่มีอยู่ฐานข้อมูลนั้นจะถูกสร้างขึ้นและในที่สุดก็จะส่งคืนวัตถุฐานข้อมูล
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");
}
}ก่อนที่คุณจะคอมไพล์และเรียกใช้โปรแกรมข้างต้นให้ค้นหา pg_hba.conf ไฟล์ในไดเร็กทอรีการติดตั้ง PostgreSQL ของคุณและเพิ่มบรรทัดต่อไปนี้ -
# IPv4 local connections:
host all all 127.0.0.1/32 md5คุณสามารถเริ่ม / รีสตาร์ทเซิร์ฟเวอร์ postgres ได้ในกรณีที่ไม่ได้ทำงานโดยใช้คำสั่งต่อไปนี้ -
[root@host]# service postgresql restart
Stopping postgresql service: [ OK ]
Starting postgresql service: [ OK ]ตอนนี้ให้เรารวบรวมและเรียกใช้โปรแกรมด้านบนเพื่อเชื่อมต่อกับ testdb ที่นี่เรากำลังใช้postgres เป็น ID ผู้ใช้และ 123เป็นรหัสผ่านในการเข้าถึงฐานข้อมูล คุณสามารถเปลี่ยนแปลงได้ตามการกำหนดค่าและการตั้งค่าฐานข้อมูลของคุณ นอกจากนี้เรายังสมมติว่าไดรเวอร์ JDBC เวอร์ชันปัจจุบันpostgresql-9.2-1002.jdbc3.jar มีอยู่ในเส้นทางปัจจุบัน
C:\JavaPostgresIntegration>javac PostgreSQLJDBC.java
C:\JavaPostgresIntegration>java -cp c:\tools\postgresql-9.2-1002.jdbc3.jar;C:\JavaPostgresIntegration PostgreSQLJDBC
Open database successfullyสร้างตาราง
โปรแกรม Java ต่อไปนี้จะถูกใช้เพื่อสร้างตารางในฐานข้อมูลที่เปิดไว้ก่อนหน้านี้ ตรวจสอบให้แน่ใจว่าคุณไม่มีตารางนี้ในฐานข้อมูลเป้าหมายของคุณแล้ว
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");
}
}เมื่อโปรแกรมถูกคอมไพล์และดำเนินการโปรแกรมจะสร้างตาราง COMPANY ในรูปแบบ testdb ฐานข้อมูลและจะแสดงสองบรรทัดต่อไปนี้ -
Opened database successfully
Table created successfullyการทำงานของ INSERT
โปรแกรม Java ต่อไปนี้แสดงให้เห็นว่าเราสามารถสร้างระเบียนในตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร
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");
}
}เมื่อโปรแกรมด้านบนถูกคอมไพล์และดำเนินการโปรแกรมจะสร้างเร็กคอร์ดที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -
Opened database successfully
Records created successfullyเลือกการทำงาน
โปรแกรม Java ต่อไปนี้แสดงให้เห็นว่าเราสามารถดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
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");
}
}เมื่อโปรแกรมถูกคอมไพล์และดำเนินการโปรแกรมจะให้ผลลัพธ์ดังนี้ -
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อัปเดตการทำงาน
โค้ด Java ต่อไปนี้แสดงวิธีที่เราสามารถใช้คำสั่ง UPDATE เพื่ออัปเดตเรกคอร์ดใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่อัปเดตจากตาราง COMPANY ของเรา -
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");
}
}เมื่อโปรแกรมถูกคอมไพล์และดำเนินการโปรแกรมจะให้ผลลัพธ์ดังนี้ -
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ลบการดำเนินการ
โค้ด Java ต่อไปนี้แสดงวิธีที่เราสามารถใช้คำสั่ง DELETE เพื่อลบบันทึกใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่เหลือจากตาราง COMPANY ของเรา -
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");
}
}เมื่อโปรแกรมถูกคอมไพล์และดำเนินการโปรแกรมจะให้ผลลัพธ์ดังนี้ -
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การติดตั้ง
ส่วนขยาย PostgreSQL ถูกเปิดใช้งานโดยค่าเริ่มต้นใน PHP 5.3.x รุ่นล่าสุด เป็นไปได้ที่จะปิดการใช้งานโดยใช้ไฟล์--without-pgsqlในเวลารวบรวม คุณยังสามารถใช้คำสั่ง yum เพื่อติดตั้งอินเทอร์เฟซ PHP -PostgreSQL -
yum install php-pgsqlก่อนที่คุณจะเริ่มใช้อินเทอร์เฟซ PHP PostgreSQL ให้ค้นหาไฟล์ pg_hba.conf ไฟล์ในไดเร็กทอรีการติดตั้ง PostgreSQL ของคุณและเพิ่มบรรทัดต่อไปนี้ -
# IPv4 local connections:
host all all 127.0.0.1/32 md5คุณสามารถเริ่ม / รีสตาร์ทเซิร์ฟเวอร์ postgres ในกรณีที่ไม่ได้ทำงานโดยใช้คำสั่งต่อไปนี้ -
[root@host]# service postgresql restart
Stopping postgresql service: [ OK ]
Starting postgresql service: [ OK ]ผู้ใช้ Windows ต้องเปิดใช้ php_pgsql.dll เพื่อใช้ส่วนขยายนี้ DLL นี้มาพร้อมกับการแจกแจง Windows ใน PHP 5.3.x รุ่นล่าสุด
สำหรับคำแนะนำในการติดตั้งโดยละเอียดโปรดดูบทช่วยสอน PHP และเว็บไซต์อย่างเป็นทางการ
PHP Interface API
ต่อไปนี้เป็นกิจวัตร PHP ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล PostgreSQL จากโปรแกรม PHP ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของ PHP
| ส. เลขที่ | API และคำอธิบาย |
|---|---|
| 1 | resource pg_connect ( string $connection_string [, int $connect_type ] ) สิ่งนี้เปิดการเชื่อมต่อกับฐานข้อมูล PostgreSQL ที่ระบุโดย connection_string ถ้า PGSQL_CONNECT_FORCE_NEW ถูกส่งผ่านเป็น connect_type การเชื่อมต่อใหม่จะถูกสร้างขึ้นในกรณีของการเรียกครั้งที่สองไปที่ pg_connect () แม้ว่า connection_string จะเหมือนกับการเชื่อมต่อที่มีอยู่ |
| 2 | bool pg_connection_reset ( resource $connection ) กิจวัตรนี้จะรีเซ็ตการเชื่อมต่อ เป็นประโยชน์สำหรับการกู้คืนข้อผิดพลาด ส่งกลับค่า TRUE สำหรับความสำเร็จหรือ FALSE เมื่อล้มเหลว |
| 3 | int pg_connection_status ( resource $connection ) รูทีนนี้ส่งคืนสถานะของการเชื่อมต่อที่ระบุ ส่งคืน PGSQL_CONNECTION_OK หรือ PGSQL_CONNECTION_BAD |
| 4 | string pg_dbname ([ resource $connection ] ) รูทีนนี้ส่งคืนชื่อของฐานข้อมูลที่ทรัพยากรการเชื่อมต่อ PostgreSQL ที่กำหนด |
| 5 | resource pg_prepare ([ resource $connection ], string $stmtname, string $query ) สิ่งนี้ส่งคำขอเพื่อสร้างคำสั่งที่เตรียมไว้พร้อมพารามิเตอร์ที่กำหนดและรอให้เสร็จสิ้น |
| 6 | resource pg_execute ([ resource $connection ], string $stmtname, array $params ) รูทีนนี้ส่งคำร้องขอเพื่อเรียกใช้คำสั่งที่เตรียมไว้พร้อมพารามิเตอร์ที่กำหนดและรอผลลัพธ์ |
| 7 | resource pg_query ([ resource $connection ], string $query ) รูทีนนี้รันเคียวรีบนการเชื่อมต่อฐานข้อมูลที่ระบุ |
| 8 | array pg_fetch_row ( resource $result [, int $row ] ) รูทีนนี้ดึงข้อมูลหนึ่งแถวจากผลลัพธ์ที่เชื่อมโยงกับทรัพยากรผลลัพธ์ที่ระบุ |
| 9 | array pg_fetch_all ( resource $result ) รูทีนนี้ส่งคืนอาร์เรย์ที่มีแถวทั้งหมด (ระเบียน) ในทรัพยากรผลลัพธ์ |
| 10 | int pg_affected_rows ( resource $result ) รูทีนนี้ส่งคืนจำนวนแถวที่ได้รับผลกระทบจากการสอบถาม INSERT, UPDATE และ DELETE |
| 11 | int pg_num_rows ( resource $result ) รูทีนนี้ส่งคืนจำนวนแถวในทรัพยากรผลลัพธ์ PostgreSQL สำหรับตัวอย่างจำนวนแถวที่ส่งคืนโดยคำสั่ง SELECT |
| 12 | bool pg_close ([ resource $connection ] ) รูทีนนี้ปิดการเชื่อมต่อแบบไม่ต่อเนื่องกับฐานข้อมูล PostgreSQL ที่เชื่อมโยงกับทรัพยากรการเชื่อมต่อที่กำหนด |
| 13 | string pg_last_error ([ resource $connection ] ) รูทีนนี้ส่งคืนข้อความแสดงข้อผิดพลาดสุดท้ายสำหรับการเชื่อมต่อที่กำหนด |
| 14 | string pg_escape_literal ([ resource $connection ], string $data ) รูทีนนี้จะหลีกเลี่ยงลิเทอรัลสำหรับการแทรกลงในฟิลด์ข้อความ |
| 15 | string pg_escape_string ([ resource $connection ], string $data ) รูทีนนี้จะหลบหนีสตริงสำหรับการสืบค้นฐานข้อมูล |
กำลังเชื่อมต่อกับฐานข้อมูล
โค้ด PHP ต่อไปนี้แสดงวิธีการเชื่อมต่อกับฐานข้อมูลที่มีอยู่บนเครื่องโลคัลและสุดท้ายอ็อบเจ็กต์การเชื่อมต่อฐานข้อมูลจะถูกส่งคืน
<?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";
}
?>ตอนนี้ให้เราเรียกใช้โปรแกรมที่ระบุข้างต้นเพื่อเปิดฐานข้อมูลของเรา testdb: หากเปิดฐานข้อมูลสำเร็จก็จะขึ้นข้อความต่อไปนี้ -
Opened database successfullyสร้างตาราง
โปรแกรม PHP ต่อไปนี้จะใช้สร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้ -
<?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);
?>เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะสร้างตาราง COMPANY ในไฟล์ testdb และจะแสดงข้อความต่อไปนี้ -
Opened database successfully
Table created successfullyการทำงานของ INSERT
โปรแกรม PHP ต่อไปนี้แสดงให้เห็นว่าเราสามารถสร้างเรกคอร์ดในตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
<?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);
?>เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะสร้างระเบียนที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -
Opened database successfully
Records created successfullyเลือกการทำงาน
โปรแกรม PHP ต่อไปนี้แสดงให้เห็นว่าเราสามารถดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
<?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);
?>เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ โปรดทราบว่าฟิลด์จะถูกส่งกลับตามลำดับที่ใช้ในขณะสร้างตาราง
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อัปเดตการทำงาน
โค้ด PHP ต่อไปนี้แสดงให้เห็นว่าเราสามารถใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่อัปเดตจากตาราง COMPANY ของเรา -
<?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);
?>เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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ลบการดำเนินการ
โค้ด PHP ต่อไปนี้แสดงวิธีที่เราสามารถใช้คำสั่ง DELETE เพื่อลบบันทึกใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY ของเรา -
<?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);
?>เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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การติดตั้ง
PostgreSQL สามารถรวมเข้ากับ Perl โดยใช้โมดูล Perl DBI ซึ่งเป็นโมดูลการเข้าถึงฐานข้อมูลสำหรับภาษาโปรแกรม Perl กำหนดชุดวิธีการตัวแปรและการประชุมที่จัดเตรียมอินเตอร์เฟสฐานข้อมูลมาตรฐาน
นี่คือขั้นตอนง่ายๆในการติดตั้งโมดูล DBI บนเครื่อง Linux / Unix ของคุณ -
$ 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หากคุณต้องการติดตั้งไดรเวอร์ SQLite สำหรับ DBI สามารถติดตั้งได้ดังนี้ -
$ 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ก่อนที่คุณจะเริ่มใช้อินเทอร์เฟซ Perl PostgreSQL ให้ค้นหาไฟล์ pg_hba.conf ไฟล์ในไดเร็กทอรีการติดตั้ง PostgreSQL ของคุณและเพิ่มบรรทัดต่อไปนี้ -
# IPv4 local connections:
host all all 127.0.0.1/32 md5คุณสามารถเริ่ม / รีสตาร์ทเซิร์ฟเวอร์ postgres ในกรณีที่ไม่ได้ทำงานโดยใช้คำสั่งต่อไปนี้ -
[root@host]# service postgresql restart
Stopping postgresql service: [ OK ]
Starting postgresql service: [ OK ]DBI Interface API
ต่อไปนี้เป็นกิจวัตร DBI ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล SQLite จากโปรแกรม Perl ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของ Perl DBI
| ส. เลขที่ | API และคำอธิบาย |
|---|---|
| 1 | DBI→connect($data_source, "userid", "password", \%attr) สร้างการเชื่อมต่อฐานข้อมูลหรือเซสชันกับ $ data_source ที่ร้องขอ ส่งคืนอ็อบเจ็กต์ตัวจัดการฐานข้อมูลหากการเชื่อมต่อสำเร็จ Datasource มีรูปแบบดังนี้ DBI:Pg:dbname=$database;host=127.0.0.1;port=5432 Pg คือชื่อไดรเวอร์ PostgreSQL และ testdb เป็นชื่อของฐานข้อมูล |
| 2 | $dbh→do($sql) รูทีนนี้เตรียมและดำเนินการคำสั่ง SQL เดียว ส่งคืนจำนวนแถวที่ได้รับผลกระทบหรือ undef ในข้อผิดพลาด ค่าที่ส่งกลับเป็น -1 หมายถึงไม่ทราบจำนวนแถวไม่เกี่ยวข้องหรือไม่พร้อมใช้งาน ที่นี่ $ dbh คือหมายเลขอ้างอิงที่ส่งคืนโดย DBI → connect () call |
| 3 | $dbh→prepare($sql) รูทีนนี้เตรียมคำสั่งสำหรับการดำเนินการในภายหลังโดยเอ็นจินฐานข้อมูลและส่งคืนการอ้างอิงไปยังอ็อบเจ็กต์การจัดการคำสั่ง |
| 4 | $sth→execute() รูทีนนี้ดำเนินการประมวลผลใด ๆ ที่จำเป็นเพื่อดำเนินการตามคำสั่งที่เตรียมไว้ ค่า undef จะถูกส่งกลับหากเกิดข้อผิดพลาด การดำเนินการที่ประสบความสำเร็จจะคืนค่าจริงเสมอโดยไม่คำนึงถึงจำนวนแถวที่ได้รับผลกระทบ ที่นี่$sth is a statement handle returned by $dbh →จัดเตรียม ($ sql) โทร |
| 5 | $sth→fetchrow_array() รูทีนนี้ดึงข้อมูลแถวถัดไปและส่งคืนเป็นรายการที่มีค่าฟิลด์ ฟิลด์ Null จะถูกส่งกลับเป็นค่า undef ในรายการ |
| 6 | $DBI::err ซึ่งเทียบเท่ากับ $ h → err โดยที่ $h is any of the handle types like $dbh, $sth, or $drh. สิ่งนี้ส่งคืนรหัสข้อผิดพลาดเอ็นจินฐานข้อมูลเนทีฟจากเมธอดไดรเวอร์สุดท้ายที่เรียกว่า |
| 7 | $DBI::errstr ซึ่งเทียบเท่ากับ $ h → errstr โดยที่ $h is any of the handle types like $dbh, $sth, or $drh. ส่งคืนข้อความแสดงข้อผิดพลาดเอ็นจินฐานข้อมูลเนทีฟจากเมธอด DBI ล่าสุดที่เรียก |
| 8 | $dbh->disconnect() กิจวัตรนี้จะปิดการเชื่อมต่อฐานข้อมูลที่เปิดไว้ก่อนหน้านี้โดยการโทรไปยัง DBI → connect () |
กำลังเชื่อมต่อกับฐานข้อมูล
รหัส Perl ต่อไปนี้แสดงวิธีการเชื่อมต่อกับฐานข้อมูลที่มีอยู่ ถ้าฐานข้อมูลไม่มีอยู่ฐานข้อมูลนั้นจะถูกสร้างขึ้นและในที่สุดก็จะส่งคืนวัตถุฐานข้อมูล
#!/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";ตอนนี้ให้เราเรียกใช้โปรแกรมที่ระบุข้างต้นเพื่อเปิดฐานข้อมูลของเรา testdb; หากเปิดฐานข้อมูลสำเร็จก็จะขึ้นข้อความต่อไปนี้ -
Open database successfullyสร้างตาราง
โปรแกรม Perl ต่อไปนี้จะใช้ในการสร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้ -
#!/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();เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะสร้างตาราง COMPANY ในไฟล์ testdb และจะแสดงข้อความต่อไปนี้ -
Opened database successfully
Table created successfullyการทำงานของ INSERT
โปรแกรม Perl ต่อไปนี้แสดงให้เห็นว่าเราสามารถสร้างเรกคอร์ดในตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
#!/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();เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะสร้างระเบียนที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -
Opened database successfully
Records created successfullyเลือกการทำงาน
โปรแกรม Perl ต่อไปนี้แสดงให้เห็นว่าเราสามารถดึงและแสดงบันทึกจากตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
#!/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();เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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อัปเดตการทำงาน
รหัส Perl ต่อไปนี้แสดงให้เห็นว่าเราสามารถใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่อัปเดตจากตาราง COMPANY ของเรา -
#!/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();เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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ลบการดำเนินการ
รหัส Perl ต่อไปนี้แสดงวิธีที่เราสามารถใช้คำสั่ง DELETE เพื่อลบบันทึกใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY ของเรา -
#!/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();เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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การติดตั้ง
PostgreSQL สามารถรวมเข้ากับ Python โดยใช้โมดูล psycopg2 sycopg2 เป็นอะแด็ปเตอร์ฐานข้อมูล PostgreSQL สำหรับภาษาโปรแกรม Python Psycopg2 ถูกเขียนขึ้นโดยมีจุดมุ่งหมายให้มีขนาดเล็กและรวดเร็วและมั่นคงเหมือนหิน คุณไม่จำเป็นต้องติดตั้งโมดูลนี้แยกกันเนื่องจากมีการจัดส่งโดยค่าเริ่มต้นพร้อมกับ Python เวอร์ชัน 2.5.x เป็นต้นไป
หากคุณไม่ได้ติดตั้งไว้ในเครื่องของคุณคุณสามารถใช้คำสั่ง yum เพื่อติดตั้งได้ดังนี้ -
$yum install python-psycopg2ในการใช้โมดูล psycopg2 ก่อนอื่นคุณต้องสร้างวัตถุการเชื่อมต่อที่แสดงถึงฐานข้อมูลจากนั้นคุณสามารถเลือกสร้างวัตถุเคอร์เซอร์ซึ่งจะช่วยคุณในการเรียกใช้คำสั่ง SQL ทั้งหมด
Python Psycopg2 โมดูล API
ต่อไปนี้เป็นรูทีนโมดูล psycopg2 ที่สำคัญซึ่งสามารถเพียงพอต่อความต้องการของคุณในการทำงานกับฐานข้อมูล PostgreSQL จากโปรแกรม Python ของคุณ หากคุณกำลังมองหาแอปพลิเคชันที่ซับซ้อนมากขึ้นคุณสามารถดูเอกสารอย่างเป็นทางการของโมดูล Python psycopg2
| ส. เลขที่ | API และคำอธิบาย |
|---|---|
| 1 | psycopg2.connect(database="testdb", user="postgres", password="cohondob", host="127.0.0.1", port="5432") API นี้เปิดการเชื่อมต่อกับฐานข้อมูล PostgreSQL หากเปิดฐานข้อมูลสำเร็จจะส่งคืนวัตถุการเชื่อมต่อ |
| 2 | connection.cursor() กิจวัตรนี้จะสร้างไฟล์ cursor ซึ่งจะใช้ตลอดการเขียนโปรแกรมฐานข้อมูลด้วย Python |
| 3 | cursor.execute(sql [, optional parameters]) รูทีนนี้รันคำสั่ง SQL คำสั่ง SQL อาจถูกกำหนดพารามิเตอร์ (เช่นตัวยึดแทนตัวอักษร SQL) โมดูล psycopg2 รองรับตัวยึดตำแหน่งโดยใช้เครื่องหมาย% s ตัวอย่างเช่น cursor.execute ("insert into people values (% s,% s)", (who, age)) |
| 4 | cursor.executemany(sql, seq_of_parameters) รูทีนนี้เรียกใช้คำสั่ง SQL กับลำดับพารามิเตอร์หรือการแม็พทั้งหมดที่พบในลำดับ sql |
| 5 | cursor.callproc(procname[, parameters]) รูทีนนี้เรียกใช้โพรซีเดอร์ฐานข้อมูลที่จัดเก็บด้วยชื่อที่กำหนด ลำดับของพารามิเตอร์ต้องมีหนึ่งรายการสำหรับแต่ละอาร์กิวเมนต์ที่โพรซีเดอร์ต้องการ |
| 6 | cursor.rowcount แอตทริบิวต์แบบอ่านอย่างเดียวนี้จะส่งคืนจำนวนแถวฐานข้อมูลทั้งหมดที่ถูกแก้ไขแทรกหรือลบโดยการดำเนินการล่าสุด * () |
| 7 | connection.commit() วิธีนี้ทำธุรกรรมปัจจุบัน หากคุณไม่เรียกใช้เมธอดนี้สิ่งที่คุณทำตั้งแต่การเรียกครั้งสุดท้ายเพื่อกระทำ () จะมองไม่เห็นจากการเชื่อมต่อฐานข้อมูลอื่น |
| 8 | connection.rollback() วิธีนี้ย้อนกลับการเปลี่ยนแปลงใด ๆ ในฐานข้อมูลตั้งแต่การเรียกครั้งสุดท้ายเพื่อกระทำ () |
| 9 | connection.close() วิธีนี้จะปิดการเชื่อมต่อฐานข้อมูล โปรดทราบว่าสิ่งนี้ไม่ได้เรียกใช้การกระทำ () โดยอัตโนมัติ หากคุณเพียงแค่ปิดการเชื่อมต่อฐานข้อมูลโดยไม่เรียกคอมมิต () ก่อนการเปลี่ยนแปลงของคุณจะสูญหาย! |
| 10 | cursor.fetchone() วิธีนี้ดึงข้อมูลแถวถัดไปของชุดผลลัพธ์คิวรีส่งคืนลำดับเดียวหรือไม่มีเมื่อไม่มีข้อมูลเพิ่มเติม |
| 11 | cursor.fetchmany([size=cursor.arraysize]) รูทีนนี้ดึงข้อมูลชุดถัดไปของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถวเพิ่มเติม วิธีนี้พยายามดึงข้อมูลหลายแถวตามที่ระบุโดยพารามิเตอร์ขนาด |
| 12 | cursor.fetchall() รูทีนนี้ดึงข้อมูลแถวทั้งหมด (ที่เหลือ) ของผลลัพธ์คิวรีโดยส่งคืนรายการ รายการว่างจะถูกส่งกลับเมื่อไม่มีแถว |
กำลังเชื่อมต่อกับฐานข้อมูล
รหัส Python ต่อไปนี้แสดงวิธีเชื่อมต่อกับฐานข้อมูลที่มีอยู่ ถ้าฐานข้อมูลไม่มีอยู่ฐานข้อมูลนั้นจะถูกสร้างขึ้นและในที่สุดก็จะส่งคืนวัตถุฐานข้อมูล
#!/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"ที่นี่คุณยังสามารถจัดหาฐานข้อมูล testdb เป็นชื่อและหากเปิดฐานข้อมูลสำเร็จก็จะขึ้นข้อความต่อไปนี้ -
Open database successfullyสร้างตาราง
โปรแกรม Python ต่อไปนี้จะถูกใช้เพื่อสร้างตารางในฐานข้อมูลที่สร้างไว้ก่อนหน้านี้ -
#!/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()เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะสร้างตาราง COMPANY ในไฟล์ test.db และจะแสดงข้อความต่อไปนี้ -
Opened database successfully
Table created successfullyการทำงานของ INSERT
โปรแกรม Python ต่อไปนี้แสดงให้เห็นว่าเราสามารถสร้างเรกคอร์ดในตาราง COMPANY ของเราที่สร้างในตัวอย่างข้างต้นได้อย่างไร -
#!/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()เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะสร้างระเบียนที่กำหนดในตาราง COMPANY และจะแสดงสองบรรทัดต่อไปนี้ -
Opened database successfully
Records created successfullyเลือกการทำงาน
โปรแกรม Python ต่อไปนี้แสดงให้เห็นว่าเราสามารถดึงข้อมูลและแสดงบันทึกจากตาราง COMPANY ของเราที่สร้างขึ้นในตัวอย่างข้างต้นได้อย่างไร -
#!/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()เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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อัปเดตการทำงาน
รหัส Python ต่อไปนี้แสดงให้เห็นว่าเราสามารถใช้คำสั่ง UPDATE เพื่ออัปเดตระเบียนใด ๆ จากนั้นดึงข้อมูลและแสดงบันทึกที่อัปเดตจากตาราง COMPANY ของเรา -
#!/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()เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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ลบการดำเนินการ
รหัส Python ต่อไปนี้แสดงวิธีที่เราสามารถใช้คำสั่ง DELETE เพื่อลบบันทึกใด ๆ จากนั้นดึงข้อมูลและแสดงระเบียนที่เหลือจากตาราง COMPANY ของเรา -
#!/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()เมื่อโปรแกรมที่ระบุข้างต้นถูกเรียกใช้โปรแกรมจะให้ผลลัพธ์ดังต่อไปนี้ -
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