PostgreSQL - त्वरित गाइड

PostgreSQL एक शक्तिशाली, ओपन सोर्स ऑब्जेक्ट-रिलेशनल डेटाबेस सिस्टम है। इसमें 15 साल से अधिक सक्रिय विकास चरण और एक सिद्ध वास्तुकला है जिसने इसे विश्वसनीयता, डेटा अखंडता और शुद्धता के लिए एक मजबूत प्रतिष्ठा अर्जित की है।

यह ट्यूटोरियल आपको PostgreSQL के साथ एक त्वरित शुरुआत देगा और आपको PostgreSQL प्रोग्रामिंग के साथ सहज बना देगा।

PostgreSQL क्या है?

PostgreSQL (के रूप में उच्चारण किया गया post-gress-Q-L) एक खुला स्रोत संबंधपरक डेटाबेस प्रबंधन प्रणाली (DBMS) है जिसे स्वयंसेवकों की विश्वव्यापी टीम द्वारा विकसित किया गया है। PostgreSQL किसी भी निगम या अन्य निजी संस्था द्वारा नियंत्रित नहीं है और स्रोत कोड नि: शुल्क उपलब्ध है।

PostgreSQL का एक संक्षिप्त इतिहास

PostgreSQL, जिसे मूल रूप से Postgres कहा जाता है, यूसीबी में माइकल स्टोनब्रेकर नामक कंप्यूटर विज्ञान के प्रोफेसर द्वारा बनाया गया था। स्टोनब्रेकर ने 1986 में पोस्टग्रेज की शुरुआत एक अनुवर्ती परियोजना के रूप में की थी, जो अब कंप्यूटर एसोसिएट्स के स्वामित्व वाली कंपनी इंग्रिड्स के पास है।

• 1977-1985 - INGRES नामक एक परियोजना विकसित की गई थी।

  • संबंधपरक डेटाबेस के लिए अवधारणा

  • 1980 में कंपनी Ingres की स्थापना की

  • 1994 में कंप्यूटर एसोसिएट्स द्वारा खरीदा गया

• 1986-1994 - POSTGRES

  • INGRES में अवधारणाओं का विकास ऑब्जेक्ट ओरिएंटेशन और क्वेरी लैंग्वेज पर फोकस के साथ - Quel

  • INGRES का कोड आधार POSTGRES के आधार के रूप में उपयोग नहीं किया गया था

  • इलस्ट्र्रा के रूप में वाणिज्यिक (आईबीएम द्वारा खरीदा गया इंफॉर्मिक्स द्वारा खरीदा गया)

• 1994-1995 - पोस्टग्रेज 95

  • SQL के लिए समर्थन 1994 में जोड़ा गया था

  • 1995 में Postgres95 के रूप में जारी किया गया

  • 1996 में PostgreSQL 6.0 के रूप में फिर से जारी किया गया

  • PostgreSQL ग्लोबल डेवलपमेंट टीम की स्थापना

PostgreSQL की मुख्य विशेषताएं

PostgreSQL लिनक्स, UNIX (AIX, BSD, HP-UX, SGI IRIX, मैक OS X, सोलारिस, Tru64), और विंडोज सहित सभी प्रमुख ऑपरेटिंग सिस्टम पर चलता है। यह पाठ, छवियों, ध्वनियों और वीडियो का समर्थन करता है, और इसमें C / C ++, Java, पर्ल, पायथन, रूबी, Tcl और ओपन डेटाबेस कनेक्टिविटी (ODBC) के लिए प्रोग्रामिंग इंटरफेस शामिल हैं।

PostgreSQL SQL मानक के एक बड़े हिस्से का समर्थन करता है और निम्नलिखित सहित कई आधुनिक सुविधाएँ प्रदान करता है -

• जटिल SQL प्रश्न
• SQL उप-चयन करता है
• विदेशी कुंजी
• Trigger
• Views
• Transactions
• मल्टीवर्सन कंसीवेंसी कंट्रोल (MVCC)
• स्ट्रीमिंग प्रतिकृति (9.0 के रूप में)
• हॉट स्टैंडबाई (9.0 के रूप में)

उपर्युक्त सुविधाओं को समझने के लिए आप PostgreSQL के आधिकारिक दस्तावेज की जांच कर सकते हैं। PostgreSQL को उपयोगकर्ता द्वारा कई तरीकों से बढ़ाया जा सकता है। नया जोड़कर उदाहरण के लिए -

• जानकारी का प्रकार
• Functions
• Operators
• अलग-अलग कार्य
• सूचकांक विधियों

प्रक्रियात्मक भाषा समर्थन

PostgreSQL चार मानक प्रक्रियात्मक भाषाओं का समर्थन करता है, जो उपयोगकर्ताओं को किसी भी भाषा में अपना कोड लिखने की अनुमति देता है और इसे PostgreSQL डेटाबेस सर्वर द्वारा निष्पादित किया जा सकता है। ये प्रक्रियात्मक भाषाएं हैं - PL / pgSQL, PL / Tcl, PL / पर्ल और PL / पायथन। इसके अलावा, अन्य गैर-मानक प्रक्रियात्मक भाषाएं जैसे पीएल / पीएचपी, पीएल / वी 8, पीएल / रूबी, पीएल / जावा, आदि भी समर्थित हैं।

PostgreSQL की मूल बातें समझना शुरू करने के लिए, पहले हमें PostgreSQL स्थापित करें। यह अध्याय लिनक्स, विंडोज और मैक ओएस प्लेटफार्मों पर PostgreSQL स्थापित करने के बारे में बताता है।

लिनक्स / यूनिक्स पर PostgreSQL स्थापित करना

अपने लिनक्स मशीन पर PostgreSQL स्थापित करने के लिए दिए गए चरणों का पालन करें। सुनिश्चित करें कि आप लॉग इन हैंroot इससे पहले कि आप स्थापना के लिए आगे बढ़ें।

• आप चाहते हैं कि PostgreSQL के संस्करण संख्या को चुनें, और बिलकुल संभव है, जिस प्लेटफ़ॉर्म को आप EnterpriseDB से चाहते हैं

• मैंने डाउनलोड किया postgresql-9.2.4-1-linux-x64.runमेरे 64 बिट CentOS-6 मशीन के लिए। अब, इसे निम्नानुसार निष्पादित करते हैं -

[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 स्थापित करेगा और निम्नलिखित संदेश प्रदर्शित करेगा -

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

• यदि आप निम्नलिखित कमांड का उपयोग करके नहीं चल रहे हैं, तो आप सर्वर को फिर से शुरू / पुनः आरंभ कर सकते हैं -

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

• यदि आपकी स्थापना सही थी, तो आपके पास PotsgreSQL प्रॉम्प्ट होगा test=# ऊपर दिखाये अनुसार।

विंडोज पर PostgreSQL स्थापित करना

अपने विंडोज मशीन पर PostgreSQL स्थापित करने के लिए दिए गए चरणों का पालन करें। सुनिश्चित करें कि आपने इंस्टॉल करते समय थर्ड पार्टी एंटीवायरस को बंद कर दिया है।

• आप चाहते हैं कि PostgreSQL के संस्करण संख्या को चुनें, और बिलकुल संभव है, जिस प्लेटफ़ॉर्म को आप EnterpriseDB से चाहते हैं

• मैंने अपने विंडोज पीसी को 32 बिट मोड में चलाने के लिए पोस्टग्रैसक्ल-9.2.4-1-windows.exe डाउनलोड किया है, इसलिए हमें चलने दें postgresql-9.2.4-1-windows.exePostgreSQL स्थापित करने के लिए व्यवस्थापक के रूप में। उस स्थान का चयन करें जहां आप इसे स्थापित करना चाहते हैं। डिफ़ॉल्ट रूप से, यह प्रोग्राम फ़ाइल फ़ोल्डर के भीतर स्थापित है।

• स्थापना प्रक्रिया का अगला चरण उस निर्देशिका का चयन करना होगा जहां आपका डेटा संग्रहीत किया जाएगा। डिफ़ॉल्ट रूप से, इसे "डेटा" निर्देशिका के तहत संग्रहीत किया जाता है।

• अगला, सेटअप पासवर्ड मांगता है, जिससे आप अपने पसंदीदा पासवर्ड का उपयोग कर सकते हैं।

• अगला चरण; पोर्ट को डिफ़ॉल्ट रखें।

• अगले चरण में, "लोकेल" के लिए पूछे जाने पर, मैंने "अंग्रेजी, संयुक्त राज्य" का चयन किया।

• आपके सिस्टम पर PostgreSQL स्थापित करने में कुछ समय लगता है। स्थापना प्रक्रिया के पूरा होने पर, आपको निम्न स्क्रीन मिलेगी। चेकबॉक्स को अनचेक करें और फिनिश बटन पर क्लिक करें।

स्थापना प्रक्रिया पूरी होने के बाद, आप अपने प्रोग्राम मेनू से PostgreSQL 9.2 के तहत pgAdmin III, StackBuilder और PostgreSQL शेल का उपयोग कर सकते हैं।

मैक पर PostgreSQL स्थापित करना

अपने मैक मशीन पर PostgreSQL स्थापित करने के लिए दिए गए चरणों का पालन करें। सुनिश्चित करें कि आप लॉग इन हैंadministrator इससे पहले कि आप स्थापना के लिए आगे बढ़ें।

• EnterpriseDB पर उपलब्ध मैक ओएस के लिए PostgreSQL का नवीनतम संस्करण संख्या चुनें

• मैंने डाउनलोड किया postgresql-9.2.4-1-osx.dmgमेरे मैक ओएस के लिए ओएस एक्स संस्करण 10.8.3 के साथ चल रहा है। अब, हम खोजक में dmg छवि खोलें और बस इसे डबल क्लिक करें जो आपको निम्न विंडो में PostgreSQL इंस्टॉलर देगा -

• इसके बाद क्लिक करें postgres-9.2.4-1-osxआइकन, जो एक चेतावनी संदेश देगा। चेतावनी स्वीकार करें और आगे की स्थापना के लिए आगे बढ़ें। यह प्रशासक का पासवर्ड पूछेगा जैसा कि निम्नलिखित विंडो में देखा गया है -

पासवर्ड दर्ज करें, इंस्टॉलेशन के लिए आगे बढ़ें, और इस चरण के बाद, अपने मैक मशीन को पुनरारंभ करें। यदि आप निम्न विंडो नहीं देखते हैं, तो एक बार फिर से अपनी स्थापना शुरू करें।

• एक बार जब आप इंस्टॉलर लॉन्च करते हैं, तो यह आपसे कुछ बुनियादी सवाल पूछता है जैसे इंस्टॉलेशन का स्थान, उपयोगकर्ता का पासवर्ड जो डेटाबेस, पोर्ट नंबर आदि का उपयोग करेगा। इसलिए, पासवर्ड को छोड़कर उन सभी को अपने डिफ़ॉल्ट मानों पर रखें, जिन्हें आप प्रदान कर सकते हैं अपनी पसंद के अनुसार। यह आपके मैक मशीन में PostgreSQL को एप्लिकेशन फ़ोल्डर में स्थापित करेगा जिसे आप देख सकते हैं -

• अब, आप किसी भी प्रोग्राम को शुरू करने के लिए लॉन्च कर सकते हैं। हमें SQL शेल से शुरू करते हैं। जब आप SQL शेल लॉन्च करते हैं, तो इसके अलावा प्रदर्शित होने वाले सभी डिफ़ॉल्ट मानों का उपयोग करें, अपना पासवर्ड दर्ज करें, जिसे आपने स्थापना के समय चुना था। अगर सबकुछ ठीक हो जाता है, तो आप पोस्टग्रेज डेटाबेस और ए के अंदर होंगेpostgress# नीचे दिखाए अनुसार संकेत दिया जाएगा -

बधाई हो!!! अब आपके पास अपना वातावरण PostgreSQL डेटाबेस प्रोग्रामिंग के साथ शुरू करने के लिए तैयार है।

यह अध्याय PostgreSQL SQL कमांड की एक सूची प्रदान करता है, इसके बाद इनमें से प्रत्येक कमांड के लिए सटीक वाक्यविन्यास नियम हैं। कमांड का यह सेट psql कमांड-लाइन टूल से लिया गया है। अब जब आपके पास पोस्टग्रैस स्थापित हो जाए, तो psql को खोलें -

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

Psql का उपयोग करके, आप \ help कमांड का उपयोग करके कमांड की पूरी सूची तैयार कर सकते हैं। किसी विशिष्ट कमांड के सिंटैक्स के लिए, निम्न कमांड का उपयोग करें -

postgres-# \help <command_name>

एसक्यूएल स्टेटमेंट

एक SQL कथन टोकन से युक्त होता है, जहाँ प्रत्येक टोकन कीवर्ड, पहचानकर्ता, उद्धृत पहचानकर्ता, निरंतर, या विशेष वर्ण प्रतीक का प्रतिनिधित्व कर सकता है। नीचे दी गई तालिका एक मूल, लेकिन पूर्ण, SQL कथन और उसके घटकों को चित्रित करने के लिए एक सरल चयन कथन का उपयोग करती है।

	चुनते हैं	आईडी, नाम	से	राज्यों
टोकन प्रकार	कीवर्ड	पहचानकर्ता	कीवर्ड	पहचानकर्ता
विवरण	आदेश	आईडी और नाम कॉलम	धारा	तालिका नाम

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

बदलनेवाला

ऑपरेटर की परिभाषा बदलें।

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

बदलनेवाला वर्ग

ऑपरेटर वर्ग की परिभाषा बदलें।

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

वर्तमान लेनदेन करें।

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 [, ...] ]

AGGREGATE बनाना

एक नया समुच्चय फ़ंक्शन परिभाषित करें।

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 ]

बनाने का काम TRIGGER

एक नई बाधा ट्रिगर परिभाषित करें।

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

रचना का निर्माण

एक नया रूपांतरण परिभाषित करें।

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

DATABASE बनाएं

एक नया डेटाबेस बनाएँ।

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

रचनाकार वर्ग

एक नए ऑपरेटर वर्ग को परिभाषित करें।

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 ]

कॉलम_कॉन्स्ट्रैंट कहाँ है -

[ 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 ]

और सारणी_संस्थान है -

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

टाइप करें

एक नया डेटा प्रकार परिभाषित करें।

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 name [ CASCADE | RESTRICT ]

ड्रॉपडाउन

एक डेटाबेस निकालें।

DROP DATABASE name

ड्रॉप डोमेन

एक डोमेन निकालें।

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

ड्रॉप फंक्शन

कोई फ़ंक्शन निकालें।

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

DROP ग्रुप

उपयोगकर्ता समूह निकालें।

DROP GROUP name

ड्रॉप इंडेक्स

एक सूचकांक निकालें।

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

ड्रॉप भाषा

एक प्रक्रियात्मक भाषा निकालें।

DROP [ PROCEDURAL ] LANGUAGE name [ CASCADE | RESTRICT ]

ड्रॉप ऑपरेटर

कोई ऑपरेटर निकालें।

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

ड्राप ओपरेटर क्लास

एक ऑपरेटर वर्ग निकालें।

DROP OPERATOR CLASS name USING index_method [ CASCADE | RESTRICT ]

ड्रॉप RULE

एक पुनर्लेखन नियम निकालें।

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_name

ड्रॉप ट्राइगर

एक ट्रिगर निकालें।

DROP TRIGGER name ON table [ CASCADE | RESTRICT ]

ड्रॉप प्रकार

एक डेटा प्रकार निकालें।

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 ALL

अनुदान

पहुँच विशेषाधिकार परिभाषित करें।

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 ]

जहां लॉक_मोड में से एक है -

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 statement

पुन: अनुक्रमणिका

अनुक्रमणिका का पुन: निर्माण करें।

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

वर्तमान लेनदेन को निरस्त करें।

ROLLBACK [ WORK | TRANSACTION ]

रोलआउट करने के लिए रोलबैक

एक बैकपॉइंट पर रोल करें।

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 [, ...] ] ]

from_item

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

इन्टो का चयन करें

क्वेरी के परिणामों से एक नई तालिका निर्धारित करें।

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

एक अधिसूचना के लिए सुनना बंद करो।

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 डेटा प्रकारों की एक विस्तृत सेट का समर्थन करता है। इसके अलावा, उपयोगकर्ता क्रिएट टाइप 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 से 922337203685474780807

मौद्रिक प्रकार

पैसा प्रकार एक निश्चित आंशिक परिशुद्धता के साथ एक मुद्रा राशि संग्रहीत करता है। के मान सांख्यिक, पूर्णांक, और bigint डेटा प्रकार के लिए डाली जा सकती है पैसा । राउंडिंग त्रुटियों की क्षमता के कारण पैसे को संभालने के लिए फ्लोटिंग पॉइंट नंबरों का उपयोग करने की अनुशंसा नहीं की जाती है।

नाम	भंडारण का आकार	विवरण	रेंज
पैसे	8 बाइट्स	मुद्रा मूल्य	-92233720368547758.08 से +92233720368547758.07

चरित्र प्रकार

नीचे दी गई तालिका पोस्टग्रेएसक्यूएल में उपलब्ध सामान्य-उद्देश्य चरित्र प्रकारों को सूचीबद्ध करती है।

एस।	नाम और विवरण
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।

नाम	भंडारण का आकार	विवरण	कम मूल्य	उच्च मूल्य
टाइमस्टैम्प [(पी)] [समय क्षेत्र के बिना]	8 बाइट्स	तारीख और समय दोनों (कोई समय क्षेत्र नहीं)	4713 ई.पू.	294276 ई
TIMESTAMPTZ	8 बाइट्स	समय क्षेत्र के साथ दिनांक और समय दोनों	4713 ई.पू.	294276 ई
दिनांक	4 निवाले	तारीख (दिन का कोई समय नहीं)	4713 ई.पू.	5874897 ई
समय [(पी)] [समय क्षेत्र के बिना]	8 बाइट्स	दिन का समय (कोई तारीख नहीं)	00:00:00	24:00:00
समय क्षेत्र के साथ समय [(पी)]	12 बाइट्स	केवल दिन का समय, समय क्षेत्र के साथ	00: 00: 00 + 1459	24: 00: 00-1459
अंतराल [क्षेत्र] [(पी)]	12 बाइट्स	समय अंतराल	-178000000 वर्ष	178000000 वर्ष

बूलियन प्रकार

PostgreSQL मानक SQL प्रकार बूलियन प्रदान करता है। बूलियन डेटा प्रकार में स्थिति सही , गलत और एक तीसरी स्थिति हो सकती है, अज्ञात , जिसे SQL नल मान द्वारा दर्शाया गया है।

नाम	भंडारण का आकार	विवरण
बूलियन	1 बाइट	सत्य या असत्य की अवस्था

प्रगणित प्रकार

Enumerated (enum) प्रकार वे डेटा प्रकार होते हैं जिनमें एक स्थिर, क्रमबद्ध मान शामिल होता है। वे कई प्रोग्रामिंग भाषाओं में समर्थित enum प्रकारों के बराबर हैं।

अन्य प्रकारों के विपरीत, Enumerated Types को CREATE TYPE कमांड का उपयोग करके बनाया जाना चाहिए। इस प्रकार का उपयोग स्थिर, ऑर्डर किए गए मानों को सेट करने के लिए किया जाता है। उदाहरण के लिए कम्पास दिशाएँ, जैसे, उत्तर, दक्षिण, पूर्व और पश्चिम या सप्ताह के दिनों को नीचे दिखाया गया है -

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

एक बार बनाया गया, किसी भी अन्य प्रकार की तरह इस्तेमाल किया जा सकता है।

ज्यामितीय प्रकार

ज्यामितीय डेटा प्रकार दो आयामी स्थानिक वस्तुओं का प्रतिनिधित्व करते हैं। सबसे मौलिक प्रकार, बिंदु, अन्य सभी प्रकारों के लिए आधार बनाता है।

नाम	भंडारण का आकार	प्रतिनिधित्व	विवरण
बिंदु	16 बाइट्स	एक विमान पर इंगित करें	(एक्स, वाई)
लाइन	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 + 16N	बहुभुज (बंद पथ के समान)	((X1, y1), ...)
वृत्त	24 बाइट्स	वृत्त	<(x, y), r> (केंद्र बिंदु और त्रिज्या)

नेटवर्क पता प्रकार

PostgreSQL IPv4, IPv6, और MAC पतों को संग्रहीत करने के लिए डेटा प्रकार प्रदान करता है। नेटवर्क पते को संग्रहीत करने के लिए सादे पाठ प्रकारों के बजाय इन प्रकारों का उपयोग करना बेहतर है, क्योंकि ये प्रकार इनपुट त्रुटि जाँच और विशेष ऑपरेटर और फ़ंक्शन प्रदान करते हैं।

नाम	भंडारण का आकार	विवरण
सीआईडीआर	7 या 19 बाइट्स	IPv4 और IPv6 नेटवर्क
मंत्रिमंडल	7 या 19 बाइट्स	IPv4 और IPv6 होस्ट और नेटवर्क
MACADDR	6 बाइट्स	मैक पते

बिट स्ट्रिंग प्रकार

बिट स्ट्रिंग टाइप करने के लिए बिट स्ट्रिंग प्रकार का उपयोग किया जाता है। वे या तो 0 या 1. दो SQL बिट प्रकार हैं:bit(n) तथा bit varying(n), जहां n एक धनात्मक पूर्णांक है।

पाठ खोज प्रकार

यह प्रकार पूर्ण पाठ खोज का समर्थन करता है, जो कि क्वेरी से मेल खाने वाले लोगों का पता लगाने के लिए प्राकृतिक-भाषा के दस्तावेजों के संग्रह के माध्यम से खोज करने की गतिविधि है। इसके लिए दो डेटा प्रकार हैं -

एस।	नाम और विवरण
1	tsvector यह अलग-अलग शब्दों की एक क्रमबद्ध सूची है, जिसे एक ही शब्द के विभिन्न वेरिएंट्स में विलय करने के लिए सामान्यीकृत किया गया है, जिसे "लेक्समेस" कहा जाता है।
2	tsquery यह उन भंडारों को संग्रहीत करता है जिनकी खोज की जानी है, और उन्हें बूलियन ऑपरेटरों को सम्मानित करते हुए (और),, (या और ! (नहीं)। कोष्ठकों का उपयोग ऑपरेटरों के समूहन को लागू करने के लिए किया जा सकता है।

UUID प्रकार

एक UUID (यूनिवर्सली यूनिक आइडेंटिफ़ायर) को निम्न-मामले हेक्साडेसिमल अंकों के अनुक्रम के रूप में लिखा जाता है, कई समूहों में हाइफ़न, विशेष रूप से आठ अंकों का एक समूह, जिसके बाद चार अंकों के तीन समूह होते हैं, उसके बाद 12 अंकों का एक समूह होता है। 128 बिट्स का प्रतिनिधित्व करने वाले कुल 32 अंक।

UUID का एक उदाहरण है - 550e8400-e29b-41d4-a716-446655440000

XML प्रकार

XML डेटा टाइप को XML डेटा को स्टोर करने के लिए इस्तेमाल किया जा सकता है। XML डेटा संग्रहीत करने के लिए, पहले आपको xmlparse फ़ंक्शन का उपयोग करके XML मान बनाना होगा -

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 (जावास्क्रिप्ट ऑब्जेक्ट नोटेशन) डाटा स्टोर करने के लिए इस्तेमाल किया जा सकता है। इस तरह के डेटा को पाठ के रूप में भी संग्रहीत किया जा सकता है , लेकिन json डेटा प्रकार के पास यह जांचने का लाभ है कि प्रत्येक संग्रहीत मूल्य एक वैध JSON मान है। संबंधित सहायता कार्य भी उपलब्ध हैं, जिनका उपयोग सीधे JSON डेटा प्रकार को संभालने के लिए किया जा सकता है।

उदाहरण	उदाहरण परिणाम
array_to_json ( '{{1,5}, {99,100}}' :: पूर्णांक [])	[[1,5], [99,100]]
row_to_json (पंक्ति (1, 'foo'))	{ "F1": 1, "F2": "foo"}

सरणी प्रकार

PostgreSQL एक तालिका के एक स्तंभ को एक चर लंबाई बहुआयामी सरणी के रूप में परिभाषित करने का अवसर देता है। किसी भी अंतर्निहित या उपयोगकर्ता-परिभाषित आधार प्रकार, एनम प्रकार या समग्र प्रकार की सारणियां बनाई जा सकती हैं।

ऐरे की घोषणा

सरणी प्रकार के रूप में घोषित किया जा सकता है

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

Arrays को संशोधित करना

नीचे दिए गए तरीके से संशोधित सरणियों का एक उदाहरण दिया गया है।

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

Arrays खोजना

खोज सरणियों का एक उदाहरण नीचे दिखाया गया है।

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 कीवर्ड वास्तव में वैकल्पिक है जब तक कि आपके पास अभिव्यक्ति में एक से अधिक फ़ील्ड हैं।

समग्र प्रकारों तक पहुँचना

किसी कंपोजिट कॉलम के क्षेत्र तक पहुँचने के लिए, फ़ील्ड नाम के बाद एक डॉट का उपयोग करें, जैसे टेबल नाम से फ़ील्ड का चयन करना। उदाहरण के लिए, हमारे on_hand उदाहरण तालिका से कुछ उपक्षेत्रों का चयन करने के लिए, क्वेरी निम्नानुसार होगी -

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 - बिगिन की सीमा

• numrange - संख्यात्मक की सीमा

• tsrange - समय क्षेत्र के बिना टाइमस्टैम्प की सीमा

• tstzrange - समय क्षेत्र के साथ टाइमस्टैम्प की सीमा

• daterange - तारीख की सीमा

नए प्रकार की श्रेणियां उपलब्ध कराने के लिए कस्टम श्रेणी प्रकार बनाए जा सकते हैं, जैसे कि IP पता पर्वतमाला एक बेस के रूप में inet प्रकार का उपयोग करता है, या फ्लोट डेटा प्रकार का उपयोग आधार के रूप में फ़्लोट श्रेणी करता है।

रेंज प्रकार क्रमशः [] और () वर्णों का उपयोग करके समावेशी और अनन्य श्रेणी की सीमाओं का समर्थन करते हैं। उदाहरण के लिए '[4,9)' सभी पूर्णांकों को दर्शाता है जो 4 से शुरू होते हैं और 4 तक होते हैं लेकिन 9 को शामिल नहीं करते हैं।

वस्तु पहचानकर्ता प्रकार

ऑब्जेक्ट पहचानकर्ता (OID) को आंतरिक रूप से PostgreSQL द्वारा विभिन्न सिस्टम तालिकाओं के लिए प्राथमिक कुंजी के रूप में उपयोग किया जाता है। यदि OIDS निर्दिष्ट है या default_with_oids कॉन्फ़िगरेशन चर सक्षम है, तभी, ऐसे मामलों में उपयोगकर्ता-निर्मित तालिकाओं में OID जोड़े जाते हैं। निम्न तालिका कई अन्य प्रकार सूचीबद्ध करती है। विशेष इनपुट और आउटपुट रूटीन को छोड़कर OID उर्फ ​​प्रकारों का अपना कोई संचालन नहीं है।

नाम	संदर्भ	विवरण	मान उदाहरण
OID	कोई भी	संख्यात्मक वस्तु पहचानकर्ता	564,182
regproc	pg_proc	समारोह का नाम	योग
regprocedure	pg_proc	तर्क प्रकार के साथ कार्य करें	योग (int4)
regoper	pg_operator	ऑपरेटर का नाम	+
regoperator	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 इंगित करता है कि कोई फ़ंक्शन शून्य-टर्म सी स्ट्रिंग को स्वीकार या वापस करता है।
8	internal इंगित करता है कि एक फ़ंक्शन सर्वर-आंतरिक डेटा प्रकार को स्वीकार या वापस करता है।
9	language_handler एक प्रक्रियात्मक भाषा कॉल हैंडलर को भाषा_हैंडलर वापस करने के लिए घोषित किया जाता है।
10	fdw_handler एक विदेशी-डेटा रैपर हैंडलर को fdw_handler वापस करने के लिए घोषित किया जाता है।
1 1	record एक अनिर्दिष्ट पंक्ति प्रकार को लौटाने वाले फ़ंक्शन को पहचानता है।
12	trigger ट्रिगर वापस करने के लिए एक ट्रिगर फ़ंक्शन घोषित किया जाता है।
13	void इंगित करता है कि कोई फ़ंक्शन कोई मान नहीं देता है।

यह अध्याय आपके PostgreSQL में एक नया डेटाबेस बनाने के बारे में चर्चा करता है। PostgreSQL एक नया डेटाबेस बनाने के दो तरीके प्रदान करता है -

• एक डेटाबेस आदेश बनाएँ, का उपयोग कर।
• क्रिएटब का उपयोग कमांड-लाइन निष्पादन योग्य है।

क्रीएट डबबेस का उपयोग करना

यह कमांड PostgreSQL शेल प्रॉम्प्ट से एक डेटाबेस बनाएगा, लेकिन डेटाबेस बनाने के लिए आपके पास उचित विशेषाधिकार होना चाहिए। डिफ़ॉल्ट रूप से, मानक डेटाबेस डेटाबेस टेम्पलेट 1 को क्लोन करके नया डेटाबेस बनाया जाएगा ।

वाक्य - विन्यास

क्रिएट डेटा बेस का मूल सिंटैक्स इस प्रकार है -

CREATE DATABASE dbname;

जहाँ dbname बनाने के लिए एक डेटाबेस का नाम है।

उदाहरण

निम्नलिखित एक सरल उदाहरण है, जो बनाएगा testdb अपने PostgreSQL स्कीमा में

postgres=# CREATE DATABASE testdb;
postgres-#

Createb कमांड का उपयोग करना

PostgreSQL कमांड लाइन एक्जीक्यूटेबल क्रैब SQL कमांड CREAT DATABASE के चारों ओर एक आवरण है । इस कमांड और SQL कमांड क्रिएट डेटा के बीच एकमात्र अंतर यह है कि पूर्व को सीधे कमांड लाइन से चलाया जा सकता है और यह डेटाबेस में सभी में एक कमांड में एक टिप्पणी को जोड़ने की अनुमति देता है।

वाक्य - विन्यास

Createb के लिए सिंटैक्स निम्नानुसार है -

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

मापदंडों

नीचे दी गई तालिका उनके विवरण के साथ मापदंडों को सूचीबद्ध करती है।

एस।	पैरामीटर और विवरण
1	dbname बनाने के लिए एक डेटाबेस का नाम।
2	description नई बनाई गई डेटाबेस से संबद्ध होने के लिए एक टिप्पणी निर्दिष्ट करता है।
3	options कमांड-लाइन तर्क, जो क्रैब स्वीकार करता है।

विकल्प

निम्न तालिका कमांड लाइन तर्क क्रिएट स्वीकार करता है -

एस।	विकल्प और विवरण
1	-D tablespace डेटाबेस के लिए डिफ़ॉल्ट टेबलस्पेस निर्दिष्ट करता है।
2	-e Echo कमांड जो क्रिएट करता है वह जेनरेट करता है और सर्वर को भेजता है।
3	-E encoding इस डेटाबेस में उपयोग की जाने वाली वर्ण एन्कोडिंग योजना को निर्दिष्ट करता है।
4	-l locale इस डेटाबेस में उपयोग किए जाने वाले स्थान को निर्दिष्ट करता है।
5	-T template टेम्पलेट डेटाबेस निर्दिष्ट करता है जिसमें से इस डेटाबेस का निर्माण करना है।
6	--help निर्मित कमांड लाइन तर्क और निकास के बारे में मदद दिखाएं।
7	-h host उस मशीन का होस्ट नाम निर्दिष्ट करता है जिस पर सर्वर चल रहा है।
8	-p port टीसीपी पोर्ट या स्थानीय यूनिक्स डोमेन सॉकेट फ़ाइल एक्सटेंशन निर्दिष्ट करता है जिस पर सर्वर कनेक्शन के लिए सुन रहा है।
9	-U username उपयोगकर्ता नाम के रूप में कनेक्ट करने के लिए
10	-w पासवर्ड प्रॉम्प्ट कभी जारी न करें।
1 1	-W एक डेटाबेस से कनेक्ट करने से पहले पासवर्ड के लिए फोर्स क्रैब।

कमांड प्रॉम्प्ट खोलें और उस निर्देशिका पर जाएं जहां PostgreSQL स्थापित है। बिन निर्देशिका पर जाएं और डेटाबेस बनाने के लिए निम्न कमांड निष्पादित करें।

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

ऊपर दी गई कमांड आपको PostgreSQL व्यवस्थापक उपयोगकर्ता के पासवर्ड के लिए संकेत देगी, जो कि है postgres, डिफ़ॉल्ट रूप से। इसलिए, एक पासवर्ड प्रदान करें और अपना नया डेटाबेस बनाने के लिए आगे बढ़ें

एक बार उपर्युक्त विधियों का उपयोग करके एक डेटाबेस बनाया जाता है, आप इसका उपयोग करके डेटाबेस की सूची में देख सकते हैं \l, अर्थात्, बैकस्लैश एल कमांड निम्नानुसार है -

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, अर्थात्, बैकस्लैश एल कमांड निम्नानुसार है -

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 का उपयोग कर सकते हैं।

इस अध्याय में, हम चर्चा करेंगे कि पोस्टग्रेक्यूएल में डेटाबेस को कैसे हटाया जाए। डेटाबेस को हटाने के लिए दो विकल्प हैं -

• DROP DATABASE, SQL कमांड का उपयोग करना।
• एक कमांड-लाइन निष्पादन योग्य ड्रॉपडब का उपयोग करना ।

इस ऑपरेशन का उपयोग करने से पहले सावधान रहें क्योंकि मौजूदा डेटाबेस को हटाने से डेटाबेस में संग्रहीत पूरी जानकारी का नुकसान होगा।

DROP DATABASE का उपयोग करना

यह कमांड एक डेटाबेस को ड्रॉप करता है। यह डेटाबेस के लिए कैटलॉग प्रविष्टियों को हटा देता है और डेटा युक्त निर्देशिका को हटा देता है। यह केवल डेटाबेस के मालिक द्वारा निष्पादित किया जा सकता है। जब आप या कोई और लक्ष्य डेटाबेस से जुड़ा हो (इस आदेश को जारी करने के लिए पोस्टग्रेज या किसी अन्य डेटाबेस से कनेक्ट) तो इस कमांड को निष्पादित नहीं किया जा सकता है।

वाक्य - विन्यास

DROP DATABASE का सिंटैक्स नीचे दिया गया है -

DROP DATABASE [ IF EXISTS ] name

मापदंडों

तालिका उनके विवरण के साथ मापदंडों को सूचीबद्ध करती है।

एस।	पैरामीटर और विवरण
1	IF EXISTS यदि डेटाबेस मौजूद नहीं है, तो एक त्रुटि न डालें। इस मामले में एक नोटिस जारी किया जाता है।
2	name डेटाबेस को हटाने का नाम।

हम एक ऐसे डेटाबेस को नहीं छोड़ सकते, जिसमें कोई भी खुला कनेक्शन हो, जिसमें हमारा खुद का कनेक्शन psql या pgAdmin III शामिल है । यदि हम वर्तमान में जिस डेटाबेस से जुड़े हैं, उसे हटाना चाहते हैं तो हमें दूसरे डेटाबेस या टेम्पलेट 1 पर स्विच करना होगा । इस प्रकार, प्रोग्राम ड्रॉपडब का उपयोग करना अधिक सुविधाजनक हो सकता है , जो इस कमांड के चारों ओर एक आवरण है।

उदाहरण

निम्नलिखित एक सरल उदाहरण है, जो हटा देगा testdb अपने PostgreSQL स्कीमा से -

postgres=# DROP DATABASE testdb;
postgres-#

ड्रॉपडब कमांड का उपयोग करना

PostgresSQL कमांड लाइन निष्पादन योग्य dropdbSQL कमांड DROP DATABASE के चारों ओर एक कमांड-लाइन रैपर है । इस उपयोगिता के माध्यम से और सर्वर तक पहुंचने के लिए अन्य तरीकों के माध्यम से डेटाबेस को छोड़ने के बीच कोई प्रभावी अंतर नहीं है। dropdb एक मौजूदा PostgreSQL डेटाबेस को नष्ट कर देता है। उपयोगकर्ता, जो इस कमांड को निष्पादित करता है, एक डेटाबेस सुपर उपयोगकर्ता या डेटाबेस का मालिक होना चाहिए।

वाक्य - विन्यास

ड्रॉपडब के लिए सिंटैक्स नीचे दिखाया गया है -

dropdb  [option...] dbname

मापदंडों

निम्न तालिका उनके विवरण के साथ मापदंडों को सूचीबद्ध करती है

एस।	पैरामीटर और विवरण
1	dbname डिलीट किए जाने वाले डेटाबेस का नाम।
2	option कमांड-लाइन तर्क, जो ड्रॉपडब स्वीकार करता है।

विकल्प

निम्न तालिका कमांड-लाइन तर्कों को ड्रॉपडब स्वीकार करती है -

एस।	विकल्प और विवरण
1	-e सर्वर को भेजे जा रहे आदेशों को दिखाता है।
2	-i कुछ भी विनाशकारी करने से पहले एक सत्यापन संकेत जारी करता है।
3	-V ड्रॉपडब संस्करण प्रिंट करें और बाहर निकलें।
4	--if-exists यदि डेटाबेस मौजूद नहीं है, तो एक त्रुटि न डालें। इस मामले में एक नोटिस जारी किया जाता है।
5	--help ड्रॉपडब कमांड लाइन तर्क और निकास के बारे में मदद दिखाएं।
6	-h host उस मशीन का होस्ट नाम निर्दिष्ट करता है जिस पर सर्वर चल रहा है।
7	-p port टीसीपी पोर्ट या स्थानीय यूनिक्स डोमेन सॉकेट फ़ाइल एक्सटेंशन को निर्दिष्ट करता है जिस पर सर्वर कनेक्शन के लिए सुन रहा है।
8	-U username उपयोगकर्ता नाम के रूप में कनेक्ट करने के लिए
9	-w पासवर्ड प्रॉम्प्ट कभी जारी न करें।
10	-W किसी डेटाबेस से कनेक्ट होने से पहले पासवर्ड के लिए संकेत करने के लिए बल ड्रॉपडब।
1 1	--maintenance-db=dbname लक्ष्य डेटाबेस को छोड़ने के लिए कनेक्ट करने के लिए डेटाबेस का नाम निर्दिष्ट करता है।

उदाहरण

निम्न उदाहरण ओएस कमांड प्रॉम्प्ट से एक डेटाबेस को हटाने का प्रदर्शन करता है -

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

उपरोक्त कमांड डेटाबेस को गिरा देता है testdb। यहाँ, मैंने उपयोग किया हैpostgres (टेम्पलेट के pg_roles के तहत पाया गया) डेटाबेस को छोड़ने के लिए उपयोगकर्ता नाम।

PostgreSQL क्रिएट टेबल स्टेटमेंट का इस्तेमाल किसी भी दिए गए डेटाबेस में एक नई तालिका बनाने के लिए किया जाता है।

वाक्य - विन्यास

क्रिएट टेबल स्टेटमेंट का मूल सिंटैक्स इस प्रकार है -

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

क्रिएट टेबल एक कीवर्ड है, जो डेटाबेस सिस्टम को एक नया टेबल बनाने के लिए कह रहा है। तालिका के लिए अद्वितीय नाम या पहचानकर्ता क्रिएट टेबल स्टेटमेंट का अनुसरण करता है। प्रारंभ में, वर्तमान डेटाबेस में खाली तालिका कमांड जारी करने वाले उपयोगकर्ता के स्वामित्व में है।

फिर, कोष्ठक में, सूची आती है, तालिका में प्रत्येक स्तंभ को परिभाषित करती है और यह किस प्रकार का डेटा प्रकार है। नीचे दिए गए उदाहरण से वाक्य रचना स्पष्ट हो जाएगी।

उदाहरण

निम्नलिखित एक उदाहरण है, जो प्राथमिक कुंजी के रूप में आईडी के साथ एक कंपनी की तालिका बनाता है और नॉट नालियां यह दिखाती हैं कि इस तालिका में रिकॉर्ड बनाते समय ये क्षेत्र 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 टेबल स्टेटमेंट का उपयोग टेबल की परिभाषा और उस टेबल के सभी संबंधित डेटा, इंडेक्स, नियम, ट्रिगर और बाधाओं को दूर करने के लिए किया जाता है।

इस कमांड का उपयोग करते समय आपको सावधान रहना होगा क्योंकि एक बार टेबल डिलीट हो जाने के बाद टेबल में उपलब्ध सभी जानकारी भी हमेशा के लिए खो जाएगी।

वाक्य - विन्यास

DROP टेबल स्टेटमेंट का मूल सिंटैक्स इस प्रकार है -

DROP TABLE table_name;

उदाहरण

हमने पिछले अध्याय में सारणी विभाग और कंपनी बनाई थी। सबसे पहले, इन तालिकाओं को सत्यापित करें (उपयोग करें\d तालिकाओं की सूची के लिए) -

testdb-# \d

यह निम्नलिखित परिणाम का उत्पादन करेगा -

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

इसका मतलब है कि डिपार्टमेंट और कंपनी टेबल मौजूद हैं। तो आइए हम उन्हें निम्नानुसार छोड़ते हैं -

testdb=# drop table department, company;

यह निम्नलिखित परिणाम का उत्पादन करेगा -

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

DROP TABLE पर लौटाया गया संदेश बताता है कि ड्रॉप कमांड सफलतापूर्वक निष्पादित किया गया है।

ए schemaतालिकाओं का एक नामित संग्रह है। एक स्कीमा में दृश्य, अनुक्रमणिका, अनुक्रम, डेटा प्रकार, ऑपरेटर और फ़ंक्शन भी हो सकते हैं। स्कीमा ऑपरेटिंग सिस्टम स्तर पर निर्देशिकाओं के अनुरूप हैं, सिवाय इसके कि स्कीमा को नस्ट नहीं किया जा सकता है। PostgreSQL स्टेटमेंट क्रिएट स्कीमा एक स्कीमा बनाता है।

वाक्य - विन्यास

क्रिएट स्कीमा का मूल सिंटैक्स इस प्रकार है -

CREATE SCHEMA name;

जहां नाम स्कीमा का नाम है।

स्कीमा में तालिका बनाने के लिए सिंटैक्स

स्कीमा में तालिका बनाने का मूल सिंटैक्स इस प्रकार है -

CREATE TABLE myschema.mytable (
...
);

उदाहरण

स्कीमा बनाने के लिए एक उदाहरण देखते हैं। डेटाबेस testdb से कनेक्ट करें और निम्नानुसार एक स्कीमा myschema बनाएं -

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

स्कीमा का उपयोग करने के लाभ

• यह कई उपयोगकर्ताओं को एक दूसरे के साथ हस्तक्षेप किए बिना एक डेटाबेस का उपयोग करने की अनुमति देता है।

• यह डेटाबेस समूहों को तार्किक समूहों में व्यवस्थित करता है ताकि उन्हें अधिक प्रबंधनीय बनाया जा सके।

• तृतीय-पक्ष अनुप्रयोगों को अलग-अलग स्कीमा में रखा जा सकता है ताकि वे अन्य वस्तुओं के नाम से न टकराएं।

The PostgreSQL INSERT INTOकथन एक तालिका में नई पंक्तियाँ डालने की अनुमति देता है। क्वेरी के परिणामस्वरूप एक बार में एक पंक्ति या कई पंक्तियों को सम्मिलित किया जा सकता है।

वाक्य - विन्यास

INSERT INTO स्टेटमेंट का मूल वाक्य इस प्रकार है -

INSERT INTO TABLE_NAME (column1, column2, column3,...columnN)
VALUES (value1, value2, value3,...valueN);

• यहाँ, column1, column2, ... columnN उस तालिका के स्तंभ हैं, जिसमें आप डेटा सम्मिलित करना चाहते हैं।

• लक्ष्य कॉलम के नाम किसी भी क्रम में सूचीबद्ध किए जा सकते हैं। वैल्यू क्लॉज़ या क्वेरी द्वारा दिए गए मान स्पष्ट या अंतर्निहित कॉलम सूची से बाएं-दाएं जुड़े हुए हैं।

यदि आप तालिका के सभी स्तंभों के लिए मान जोड़ रहे हैं, तो आपको SQL क्वेरी में कॉलम (नामों) को निर्दिष्ट करने की आवश्यकता नहीं हो सकती है। हालाँकि, सुनिश्चित करें कि मानों का क्रम तालिका के स्तंभों के समान क्रम में है। SQL INSERT INTO सिंटैक्स निम्नानुसार होगा -

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

उत्पादन

निम्न तालिका आउटपुट संदेशों और उनके अर्थ को सारांशित करती है -

एस।	आउटपुट संदेश और विवरण
1	INSERT oid 1 यदि केवल एक पंक्ति डाली गई थी, तो संदेश वापस आ गया। oid सम्मिलित पंक्ति का संख्यात्मक OID है।
2	INSERT 0 # यदि एक से अधिक पंक्तियाँ डाली गईं, तो संदेश वापस आ गया। # पंक्तियों की संख्या सम्मिलित है।

उदाहरण

हमें कंपनी तालिका बनाएँ 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
);

निम्नलिखित उदाहरण कंपनी तालिका में एक पंक्ति सम्मिलित करता है -

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

निम्न उदाहरण मान निर्दिष्ट करने के बजाय JOIN_DATE कॉलम के लिए DEFAULT क्लॉज का उपयोग करता है -

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

निम्नलिखित उदाहरण मल्टीरो वैल्यू सिंटैक्स का उपयोग करके कई पंक्तियों को सम्मिलित करता है -

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

उपरोक्त सभी कथन कंपनी तालिका में निम्नलिखित रिकॉर्ड बनाएंगे। अगला अध्याय आपको सिखाएगा कि इन सभी अभिलेखों को एक तालिका से कैसे प्रदर्शित किया जाए।

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

PostgreSQL SELECTविवरण का उपयोग डेटा को डेटाबेस तालिका से लाने के लिए किया जाता है, जो परिणाम तालिका के रूप में डेटा लौटाता है। इन परिणाम तालिकाओं को परिणाम-सेट कहा जाता है।

वाक्य - विन्यास

चयन कथन का मूल सिंटैक्स इस प्रकार है -

SELECT column1, column2, columnN FROM table_name;

यहां, कॉलम 1, कॉलम 2 ... एक टेबल के क्षेत्र हैं, जिनके मूल्य आप प्राप्त करना चाहते हैं। यदि आप क्षेत्र में उपलब्ध सभी क्षेत्रों को लाना चाहते हैं तो आप निम्नलिखित वाक्यविन्यास का उपयोग कर सकते हैं -

SELECT * FROM table_name;

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

यदि आप ग्राहक तालिका के सभी क्षेत्रों को लाना चाहते हैं, तो निम्नलिखित प्रश्न का उपयोग करें -

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 में एक ऑपरेटर क्या है?

एक ऑपरेटर एक आरक्षित शब्द या एक चरित्र है जो मुख्य रूप से एक PostgreSQL स्टेटमेंट के WHERE क्लॉज में ऑपरेशन (एस), जैसे कि तुलना और अंकगणितीय संचालन करने के लिए उपयोग किया जाता है।

ऑपरेटर्स का उपयोग पोस्टग्रेसीक्यू स्टेटमेंट में शर्तों को निर्दिष्ट करने और एक स्टेटमेंट में कई स्थितियों के लिए कंजंक्शंस के रूप में काम करने के लिए किया जाता है।

• अंकगणितीय आपरेटर
• तुलना संचालक
• लॉजिकल ऑपरेटर्स
• बिटवाइज ऑपरेटर

PostgreSQL अंकगणितीय ऑपरेटर्स

चर मान लें a 2 और चर रखता है b 3 रखती है, तो -

उदाहरण

ऑपरेटर	विवरण	उदाहरण
+	परिवर्धन - ऑपरेटर के दोनों ओर मान जोड़ता है	a + b 5 देगा
-	घटाव - बाएं हाथ के ऑपरेंड से दाहिने हाथ के ऑपरेंड को घटाते हैं	ए - बी -1 देगा
*	गुणन - ऑपरेटर के दोनों ओर मूल्यों को गुणा करता है	ए * बी 6 देगा
/	डिवीजन - दाएं हाथ के ऑपरेंड द्वारा बाएं हाथ के ऑपरेशन को विभाजित किया जाता है	b / a एक देगा १
%	मापांक - दाएं हाथ से बाएं हाथ के ऑपरेशन को बांटा जाता है और शेष को वापस कर दिया जाता है	ब% ए क 1 दे खेंगे
^	घातांक - यह दाहिने हाथ के ऑपरेंड का घातांक मान देता है	क ^ ख 8 देगा
| /	वर्गमूल	| / 25.0 5 देंगे
|| /	घनमूल	|| / २ give.० ३ देंगे
!	कारख़ाने का	५! 120 देगा
!!	भाज्य (उपसर्ग ऑपरेटर)	!! 5 120 देगा

PostgreSQL तुलना ऑपरेटर

चर को 10 मानिए और चर b को 20 मानिए, तब -

उदाहरण दिखाएं

ऑपरेटर	विवरण	उदाहरण
=	जाँच करता है कि दो ऑपरेंड के मान समान हैं या नहीं, यदि हाँ तो स्थिति सच हो जाती है।	(a = b) सत्य नहीं है।
! =	जाँच करता है कि दो ऑपरेंड के मान समान हैं या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है।	(a! = b) सत्य है।
<>	जाँच करता है कि दो ऑपरेंड के मान समान हैं या नहीं, यदि मान बराबर नहीं हैं तो स्थिति सत्य हो जाती है।	(अ <> ख) सत्य है।
>	यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से अधिक है, यदि हाँ, तो स्थिति सत्य है।	(a> b) सत्य नहीं है।
<	यह जाँचता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम है, यदि हाँ, तो स्थिति सही है।	(a <b) सत्य है।
> =	जाँच करता है कि क्या बाएं ऑपरेंड का मूल्य सही ऑपरेंड के मूल्य से अधिक या उसके बराबर है, यदि हाँ तो स्थिति सच हो जाती है।	(a> = b) सत्य नहीं है।
<=	जाँच करता है कि क्या बाएं संकार्य का मान दाहिने संचालक के मान से कम या उसके बराबर है, यदि हाँ तो स्थिति सत्य हो जाती है।	(ए <= बी) सच है।

पोस्टग्रेसीक्यूएल लॉजिकल ऑपरेटर्स

यहाँ PostgresSQL में उपलब्ध सभी तार्किक ऑपरेटरों की एक सूची दी गई है।

उदाहरण दिखाएं

एस।	ऑपरेटर और विवरण
1	AND AND ऑपरेटर एक PostgresSQL स्टेटमेंट के WHERE क्लॉज में कई स्थितियों के अस्तित्व की अनुमति देता है।
2	NOT NOT ऑपरेटर उस तार्किक ऑपरेटर के अर्थ को उलट देता है जिसके साथ इसका उपयोग किया जाता है। उदाहरण के लिए। एक्जिट्स, नॉट बेटविन, नॉट इन आदि।This is negate operator।
3	OR OR ऑपरेटर का उपयोग PostgresSQL स्टेटमेंट के WHERE क्लॉज में कई स्थितियों को संयोजित करने के लिए किया जाता है।

PostgreSQL बिट स्ट्रिंग ऑपरेटर

बिटवाइज़ ऑपरेटर बिट पर काम करता है और बिट-बाय-बिट ऑपरेशन करता है। & | के लिए सत्य तालिका | इस प्रकार है -

पी	क्यू	पी क्यू	पी | क्यू
0	0	0	0
0	1	0	1
1	1	1	1
1	0	0	1

मान लें कि ए = 60; और बी = 13; अब द्विआधारी प्रारूप में वे निम्नानुसार होंगे -

ए = 0011 1100

B = 0000 1101

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

A & B = 0000 1100

ए | बी = ००११ ११०१

~ ए = ११०० ००११

उदाहरण दिखाएं

PostgreSQL द्वारा समर्थित बिटवाइज़ ऑपरेटरों को निम्न तालिका में सूचीबद्ध किया गया है -

ऑपरेटर	विवरण	उदाहरण
और	बाइनरी और ऑपरेटर परिणाम के लिए थोड़ा सा कॉपी करता है यदि यह दोनों ऑपरेंड में मौजूद है।	(A & B) 12 देगा जो 0000 1100 है
|	बाइनरी या ऑपरेटर थोड़ा सा कॉपी करता है अगर यह किसी भी ऑपरेंड में मौजूद है।	(ए | बी) 61 देगा जो 0011 1101 है
~	बाइनरी ओन्स कंप्लीट ऑपरेटर, एकात्मक है और इसमें 'फ्लिपिंग' बिट्स का प्रभाव होता है।	(~ ए) -61 देगा जो हस्ताक्षरित बाइनरी नंबर के कारण 2 के पूरक रूप में 1100 0011 है।
<<	बाइनरी लेफ्ट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से छोड़ दिया जाता है।	A << 2 240 देगा जो 1111 0000 है
>>	बाइनरी राइट शिफ्ट ऑपरेटर। बाएं ऑपरेंड वैल्यू को दाएं ऑपरेंड द्वारा निर्दिष्ट बिट्स की संख्या से दाएं स्थानांतरित किया जाता है।	A >> 2 15 देगा जो 0000 1111 है
#	बिटवार XOR।	A # B 49 देगा जो 0100 1001 है

एक अभिव्यक्ति एक या एक से अधिक मूल्यों, ऑपरेटरों और PostgresSQL फ़ंक्शन का एक संयोजन है जो एक मूल्य का मूल्यांकन करता है।

PostgreSQL EXPRESSIONS फॉर्मूले की तरह हैं और इन्हें क्वेरी भाषा में लिखा जाता है। आप डेटा के विशिष्ट सेट के लिए डेटाबेस को क्वेरी करने के लिए भी उपयोग कर सकते हैं।

वाक्य - विन्यास

निम्न कथन के मूल सिंटैक्स पर विचार करें -

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

विभिन्न प्रकार के PostgreSQL अभिव्यक्तियाँ हैं, जो नीचे उल्लिखित हैं -

PostgreSQL - बूलियन एक्सप्रेशन

PostgreSQL बूलियन एक्सप्रेशंस एकल मूल्य मिलान के आधार पर डेटा प्राप्त करते हैं। निम्नलिखित वाक्य रचना है -

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

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

यहाँ संख्यात्मक अभिव्यक्ति का उपयोग गणितीय अभिव्यक्ति या किसी भी सूत्र के लिए किया जाता है। एसक्यूएल न्यूमेरिक एक्सप्रेशंस के उपयोग का एक सरल उदाहरण निम्नलिखित है -

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 - दिनांक अभिव्यक्तियाँ

दिनांक अभिव्यक्तियाँ वर्तमान सिस्टम दिनांक और समय मान लौटाती हैं और इन अभिव्यक्तियों का उपयोग विभिन्न डेटा जोड़तोड़ में किया जाता है।

testdb=#  SELECT CURRENT_TIMESTAMP;

ऊपर दिया गया PostgreSQL स्टेटमेंट निम्न परिणाम देगा -

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

The PostgreSQL WHERE clause is used to specify a condition while fetching the data from single table or joining with multiple tables.

If the given condition is satisfied, only then it returns specific value from the table. You can filter out rows that you do not want included in the result-set by using the WHERE clause.

The WHERE clause not only is used in SELECT statement, but it is also used in UPDATE, DELETE statement, etc., which we would examine in subsequent chapters.

Syntax

The basic syntax of SELECT statement with WHERE clause is as follows −

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

You can specify a search_condition using comparison or logical operators. like >, <, =, LIKE, NOT, etc. The following examples would make this concept clear.

Example

Consider the table COMPANY having records as follows −

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

Here are simple examples showing usage of PostgreSQL Logical Operators. Following SELECT statement will list down all the records where AGE is greater than or equal to 25 AND salary is greater than or equal to 65000.00 −

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement lists down all the records where AGE is greater than or equal to 25 OR salary is greater than or equal to 65000.00 −

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement lists down all the records where AGE is not NULL which means all the records, because none of the record has AGE equal to NULL −

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement lists down all the records where NAME starts with 'Pa', does not matter what comes after 'Pa'.

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement lists down all the records where AGE value is either 25 or 27 −

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement lists down all the records where AGE value is neither 25 nor 27 −

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

The above given PostgreSQL statement will produce the following result −

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)

The following SELECT statement lists down all the records where AGE value is in BETWEEN 25 AND 27 −

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement makes use of SQL subquery where subquery finds all the records with AGE field having SALARY > 65000 and later WHERE clause is being used along with EXISTS operator to list down all the records where AGE from the outside query exists in the result returned by sub-query −

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

The above given PostgreSQL statement will produce the following result −

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

The following SELECT statement makes use of SQL subquery where subquery finds all the records with AGE field having SALARY > 65000 and later WHERE clause is being used along with > operator to list down all the records where AGE from outside query is greater than the age in the result returned by sub-query −

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

The above given PostgreSQL statement will produce the following result −

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

The PostgreSQL AND and OR operators are used to combine multiple conditions to narrow down selected data in a PostgreSQL statement. These two operators are called conjunctive operators.

These operators provide a means to make multiple comparisons with different operators in the same PostgreSQL statement.

The AND Operator

The AND operator allows the existence of multiple conditions in a PostgreSQL statement's WHERE clause. While using AND operator, complete condition will be assumed true when all the conditions are true. For example [condition1] AND [condition2] will be true only when both condition1 and condition2 are true.

Syntax

The basic syntax of AND operator with WHERE clause is as follows −

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

You can combine N number of conditions using AND operator. For an action to be taken by the PostgreSQL statement, whether it be a transaction or query, all conditions separated by the AND must be TRUE.

Example

Consider the table COMPANY having records as follows −

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

The following SELECT statement lists down all the records where AGE is greater than or equal to 25 AND salary is greater than or equal to 65000.00 −

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

The above given PostgreSQL statement will produce the following result −

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

The OR Operator

The OR operator is also used to combine multiple conditions in a PostgreSQL statement's WHERE clause. While using OR operator, complete condition will be assumed true when at least any of the conditions is true. For example [condition1] OR [condition2] will be true if either condition1 or condition2 is true.

Syntax

The basic syntax of OR operator with WHERE clause is as follows −

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

You can combine N number of conditions using OR operator. For an action to be taken by the PostgreSQL statement, whether it be a transaction or query, only any ONE of the conditions separated by the OR must be TRUE.

Example

Consider the COMPANY table, having the following records −

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

The following SELECT statement lists down all the records where AGE is greater than or equal to 25 OR salary is greater than or equal to 65000.00 −

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

The above given PostgreSQL statement will produce the following result −

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

The PostgreSQL UPDATE Query is used to modify the existing records in a table. You can use WHERE clause with UPDATE query to update the selected rows. Otherwise, all the rows would be updated.

Syntax

The basic syntax of UPDATE query with WHERE clause is as follows −

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

You can combine N number of conditions using AND or OR operators.

Example

Consider the table COMPANY, having records as follows −

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

निम्नलिखित एक उदाहरण है, जो एक ग्राहक के लिए ADDRESS को अपडेट करेगा, जिसकी आईडी 6 है -

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

अब, कंपनी तालिका में निम्नलिखित रिकॉर्ड होंगे -

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 स्तंभ मानों को संशोधित करना चाहते हैं, तो आपको WHERE क्लॉज़ और UPDATE क्वेरी का उपयोग करने की आवश्यकता नहीं है -

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

अब, कंपनी तालिका में निम्नलिखित रिकॉर्ड होंगे -

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)

The PostgreSQL DELETEक्वेरी का उपयोग किसी तालिका से मौजूदा रिकॉर्ड को हटाने के लिए किया जाता है। आप चयनित पंक्तियों को हटाने के लिए DELETE क्वेरी के साथ WHERE क्लॉज़ का उपयोग कर सकते हैं। अन्यथा, सभी रिकॉर्ड हटा दिए जाएंगे।

वाक्य - विन्यास

जहाँ खंड के साथ DELETE क्वेरी का मूल सिंटैक्स इस प्रकार है -

DELETE FROM table_name
WHERE [condition];

आप AND या ऑपरेटर्स का उपयोग करके N की संख्या को जोड़ सकते हैं।

उदाहरण

तालिका कंपनी पर विचार करें , रिकॉर्ड निम्नानुसार है -

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

अब, कंपनी तालिका में निम्नलिखित रिकॉर्ड होंगे -

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)

यदि आप कंपनी तालिका से सभी अभिलेखों को हटाना चाहते हैं, तो आपको DELETE प्रश्नों के साथ WHERE खंड का उपयोग करने की आवश्यकता नहीं है, जो निम्नानुसार होगा -

testdb=# DELETE FROM COMPANY;

अब, कंपनी तालिका में कोई रिकॉर्ड नहीं है क्योंकि सभी रिकॉर्ड DELETE विवरण द्वारा हटा दिए गए हैं।

The 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_'

आप AND या ऑपरेटर्स का उपयोग करके N की संख्या को जोड़ सकते हैं। यहां XXXX कोई भी संख्यात्मक या स्ट्रिंग मान हो सकता है।

उदाहरण

यहां कई उदाहरण दिखाए जा रहे हैं जिनमें '%' और '_' ऑपरेटरों के साथ अलग-अलग LIKE क्लॉज वाले भाग हैं -

एस।	विवरण और विवरण
1	WHERE SALARY::text LIKE '200%' 200 से शुरू होने वाले किसी भी मान को ढूँढता है
2	WHERE SALARY::text LIKE '%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 केवल String की तुलना है। इसलिए, हमें स्पष्ट रूप से पूर्णांक कॉलम को स्ट्रिंग में डालने की आवश्यकता है जैसा कि ऊपर दिए गए उदाहरणों में है।

आइए एक वास्तविक उदाहरण लेते हैं, तालिका कंपनी पर विचार करें , जिसके रिकॉर्ड निम्नानुसार हैं -

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

निम्नलिखित एक उदाहरण है, जो कंपनी तालिका से सभी रिकॉर्ड प्रदर्शित करेगा जहां 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)

निम्नलिखित एक उदाहरण है, जो कंपनी तालिका से सभी रिकॉर्ड प्रदर्शित करेगा जहां पाठ के अंदर 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)

The PostgreSQL LIMIT खंड का उपयोग SELECT स्टेटमेंट द्वारा दी गई डेटा राशि को सीमित करने के लिए किया जाता है।

वाक्य - विन्यास

सीमा खंड के साथ चयन कथन का मूल वाक्य इस प्रकार है -

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

जब यह OFFSET क्लॉज के साथ प्रयोग किया जाता है तो निम्नलिखित लिमिट खंड का सिंटैक्स है -

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

सीमा और ऑफसेट आपको उन पंक्तियों के एक हिस्से को पुनः प्राप्त करने की अनुमति देता है जो बाकी क्वेरी द्वारा उत्पन्न होते हैं।

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

The PostgreSQL ORDER BY एक या अधिक स्तंभों के आधार पर, डेटा को आरोही या अवरोही क्रम में सॉर्ट करने के लिए उपयोग किया जाता है।

वाक्य - विन्यास

ORDER BY क्लॉज का मूल सिंटैक्स इस प्रकार है -

SELECT column-list
FROM table_name
[WHERE condition]
[ORDER BY column1, column2, .. columnN] [ASC | DESC];

आप ORDER BY क्लॉज में एक से अधिक कॉलम का उपयोग कर सकते हैं। सुनिश्चित करें कि आप जो भी कॉलम सॉर्ट करने के लिए उपयोग कर रहे हैं, वह कॉलम कॉलम-लिस्ट में उपलब्ध होना चाहिए।

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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)

निम्नलिखित एक उदाहरण है, जो सैलरी द्वारा आरोही क्रम में परिणाम को क्रमबद्ध करेगा -

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)

The PostgreSQL GROUP BYखंड का उपयोग SELECT स्टेटमेंट के साथ मिलकर उन पंक्तियों को एक तालिका में समूह में करने के लिए किया जाता है जिनमें समान डेटा होता है। यह आउटपुट और / या इन समूहों पर लागू होने वाले समुच्चय की गणना में अतिरेक को खत्म करने के लिए किया जाता है।

ग्रुप BY क्लॉज एक सेलेक्ट स्टेटमेंट में WHERE क्लॉज का अनुसरण करता है और ORDER BY क्लॉज से पहले होता है।

वाक्य - विन्यास

ग्रुप बाय क्लॉज का मूल सिंटैक्स नीचे दिया गया है। ग्रुप बाय क्लॉज को WHERE क्लॉज की शर्तों का पालन करना चाहिए और यदि कोई प्रयोग किया जाता है तो उसे ORDER BY क्लॉज से पहले होना चाहिए।

SELECT column-list
FROM table_name
WHERE [ conditions ]
GROUP BY column1, column2....columnN
ORDER BY column1, column2....columnN

आप GROUP BY क्लॉज में एक से अधिक कॉलम का उपयोग कर सकते हैं। सुनिश्चित करें कि आप समूह में जो भी कॉलम उपयोग कर रहे हैं, वह कॉलम कॉलम-सूची में उपलब्ध होना चाहिए।

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

अब, निम्नलिखित 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 क्लॉज का उपयोग करें -

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 में, विथ क्वेरी एक बड़े क्वेरी में उपयोग के लिए सहायक कथन लिखने का एक तरीका प्रदान करता है। यह जटिल और बड़े प्रश्नों को सरल रूपों में तोड़ने में मदद करता है, जो आसानी से पठनीय हैं। इन बयानों को अक्सर कॉमन टेबल एक्सप्रेशन या सीटीई के रूप में संदर्भित किया जाता है, अस्थायी टेबल को परिभाषित करने के रूप में सोचा जा सकता है जो केवल एक क्वेरी के लिए मौजूद हैं।

CTE क्वेरी क्वेरी के साथ, विशेष रूप से उपयोगी है जब सबक्वेरी को कई बार निष्पादित किया जाता है। यह अस्थायी तालिकाओं के स्थान पर समान रूप से सहायक है। यह एक बार एकत्रीकरण की गणना करता है और हमें प्रश्नों में इसके नाम (कई बार हो सकता है) द्वारा इसे संदर्भित करने की अनुमति देता है।

क्‍लॉज में क्‍लॉज का उपयोग होने से पहले इसे परिभाषित किया जाना चाहिए।

वाक्य - विन्यास

क्वेरी के साथ मूल सिंटैक्स निम्नानुसार है -

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 विदाउट क्लॉज नाम दिया गया है। Name_for_summary_data मौजूदा तालिका नाम के समान हो सकता है और पूर्वता लेगा।

आप डेटा-संशोधित करने वाले कथनों (INSERT, UPDATE या DELETE) का उपयोग कर सकते हैं। यह आपको एक ही क्वेरी में कई अलग-अलग ऑपरेशन करने की अनुमति देता है।

के साथ पुनरावर्ती

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

अब, 20000 से कम सैलरी के योग को खोजने के लिए, क्लॉज़ के साथ RECRSIVE कीवर्ड का उपयोग करके एक क्वेरी लिखें, जो निम्नानुसार है -

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 के समान तालिका Company1 बनाएं। उदाहरण में क्वेरी प्रभावी रूप से कंपनी से कंपनी 1 तक पंक्तियों को स्थानांतरित करती है। DELETE कंपनी से निर्दिष्ट पंक्तियों को हटा देता है, अपनी सामग्री को उसके पुनरावर्ती खंड के माध्यम से वापस करता है; और फिर प्राथमिक क्वेरी उस आउटपुट को पढ़ती है और उसे Company1 टेबल में सम्मिलित करती है -

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

अब, तालिकाओं में रिकॉर्ड कंपनी और 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 क्लॉज चयनित कॉलम पर स्थितियां रखता है, जबकि HAVING क्लॉज GROUP BY क्लॉज द्वारा बनाए गए समूहों पर स्थितियां रखता है।

वाक्य - विन्यास

निम्नलिखित एक चयन क्वेरी में HAVING क्लॉज की स्थिति है -

SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY

HAVING क्लॉज को क्वेरी में GROUP BY क्लॉज़ का पालन करना चाहिए और यदि उपयोग किया जाता है तो ORDER BY क्लॉज़ से पहले भी होना चाहिए। निम्नलिखित चयन कथन का सिंटैक्स है, जिसमें HAVING खंड शामिल है -

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

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

अब, निम्नलिखित 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)

The PostgreSQL DISTINCT सभी डुप्लिकेट रिकॉर्ड को खत्म करने और केवल विशिष्ट रिकॉर्ड लाने के लिए कीवर्ड का चयन SELECT स्टेटमेंट के साथ किया जाता है।

ऐसी स्थिति हो सकती है जब आपके पास एक तालिका में कई डुप्लिकेट रिकॉर्ड हों। ऐसे रिकॉर्ड प्राप्त करते समय, डुप्लिकेट रिकॉर्ड प्राप्त करने के बजाय केवल अद्वितीय रिकॉर्ड लाने के लिए यह अधिक समझ में आता है।

वाक्य - विन्यास

डुप्लिकेट रिकॉर्ड को खत्म करने के लिए DISTINCT कीवर्ड का मूल सिंटैक्स इस प्रकार है -

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

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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

अब, कंपनी तालिका में रिकॉर्ड होंगे -

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)

सबसे पहले, देखते हैं कि निम्नलिखित चयन क्वेरी डुप्लिकेट वेतन रिकॉर्ड कैसे लौटाती है -

testdb=# SELECT name FROM COMPANY;

यह निम्नलिखित परिणाम का उत्पादन करेगा -

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

अब, हम उपयोग करते हैं DISTINCT उपरोक्त चयनित क्वेरी वाला कीवर्ड और परिणाम देखें -

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 को अब उस स्तंभ के लिए अनुमति नहीं है। A 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 बाधा दो रिकॉर्ड को एक विशेष कॉलम में समान मान रखने से रोकती है। उदाहरण के लिए, कंपनी तालिका में, आप दो या अधिक लोगों को समान आयु के होने से रोकना चाह सकते हैं।

उदाहरण

उदाहरण के लिए, निम्न 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
);

प्राथमिक कुंजी बाधा

प्राथमिक कुंजी बाधा विशिष्ट रूप से डेटाबेस तालिका में प्रत्येक रिकॉर्ड की पहचान करती है। अधिक अद्वितीय स्तंभ हो सकते हैं, लेकिन तालिका में केवल एक प्राथमिक कुंजी है। डेटाबेस टेबल को डिजाइन करते समय प्राथमिक कुंजी महत्वपूर्ण होती है। प्राथमिक कुंजी अद्वितीय आईडी हैं।

हम उन्हें तालिका पंक्तियों को संदर्भित करने के लिए उपयोग करते हैं। प्राथमिक कुंजी अन्य तालिकाओं में विदेशी कुंजी बन जाती है, जब तालिकाओं के बीच संबंध बनाते हैं। एक 'लंबे समय तक कोडिंग ओवरसाइट' के कारण, प्राथमिक कुंजी SQLite में NULL हो सकती है। अन्य डेटाबेस के साथ ऐसा नहीं है

एक प्राथमिक कुंजी एक तालिका में एक फ़ील्ड है, जो डेटाबेस तालिका में प्रत्येक पंक्ति / रिकॉर्ड को विशिष्ट रूप से पहचानती है। प्राथमिक कुंजी में अनन्य मान होना चाहिए। प्राथमिक कुंजी कॉलम में NULL मान नहीं हो सकते।

एक तालिका में केवल एक प्राथमिक कुंजी हो सकती है, जिसमें एकल या एकाधिक फ़ील्ड शामिल हो सकते हैं। जब कई क्षेत्रों को प्राथमिक कुंजी के रूप में उपयोग किया जाता है, तो उन्हें ए कहा जाता हैcomposite key।

यदि किसी तालिका में किसी भी फ़ील्ड पर कोई प्राथमिक कुंजी निर्धारित है, तो आपके पास उस फ़ील्ड (ओं) के समान मूल्य वाले दो रिकॉर्ड नहीं हो सकते हैं।

उदाहरण

आपने पहले ही ऊपर विभिन्न उदाहरण देखे हैं जहां हमने प्राथमिक कुंजी के रूप में ID के साथ COMAPNY4 तालिका बनाई है -

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 विदेशी कुंजी है और तालिका Company6 के ID फ़ील्ड को संदर्भित करता है।

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

चेक बाधा

चेक कॉन्सट्रेंट एक रिकॉर्ड में दर्ज किए जा रहे मूल्य की जांच करने के लिए एक शर्त को सक्षम करता है। यदि स्थिति झूठी का मूल्यांकन करती है, तो रिकॉर्ड बाधा का उल्लंघन करता है और तालिका में दर्ज नहीं किया जाता है।

उदाहरण

उदाहरण के लिए, निम्नलिखित PostgreSQL स्टेटमेंट, Company5 नामक एक नई तालिका बनाता है और पांच कॉलम जोड़ता है। यहां, हम SALARY कॉलम के साथ एक CHECK जोड़ते हैं, ताकि आप किसी भी SALARY को Zero के रूप में न ले सकें।

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

बहिष्कार की बाधा

बहिष्करण अवरोध यह सुनिश्चित करते हैं कि यदि निर्दिष्ट संचालकों का उपयोग करके निर्दिष्ट कॉलम या अभिव्यक्तियों पर किसी भी दो पंक्तियों की तुलना की जाती है, तो इनमें से कम से कम एक ऑपरेटर तुलना झूठी या अशक्त हो जाएगी।

उदाहरण

उदाहरण के लिए, निम्नलिखित 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 <>)
);

यहां, प्रवर्तन के लिए निर्माण और उपयोग करने के लिए इंडिंग गिस्ट इंडेक्स का प्रकार है।

आपको एक बार डेटाबेस के अनुसार कमांड क्रिएट एक्सटेंस 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 कमांड \ d तालिका का नाम यहाँ मददगार हो सकता है। सामान्य वाक्य रचना है -

ALTER TABLE table_name DROP CONSTRAINT some_name;

The PostgreSQL Joinsक्लॉज का उपयोग डेटाबेस में दो या अधिक टेबल से रिकॉर्ड को संयोजित करने के लिए किया जाता है। एक JOIN प्रत्येक के लिए सामान्य मानों का उपयोग करके दो तालिकाओं से फ़ील्ड के संयोजन के लिए एक साधन है।

PostgreSQL में शामिल प्रकार हैं -

• क्रॉस जॉइन
• INNER JOIN करें
• बाईं ओर शामिल हैं
• द राइट ऑप्टर जॉइन
• फुल ऑवर जॉइन

आगे बढ़ने से पहले, हम दो तालिकाओं, कंपनी और विभाग पर विचार करें। हमने पहले से ही कंपनी तालिका को आबाद करने के लिए INSERT बयान देखे हैं। तो बस हमें कंपनी तालिका में उपलब्ध अभिलेखों की सूची माननी चाहिए -

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

एक अन्य तालिका विभाग है, जिसकी निम्नलिखित परिभाषा है -

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

यहाँ प्रस्तुत सारणी को भरने के लिए INSERT कथनों की सूची दी गई है -

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

अंत में, हमारे पास निम्नलिखित तालिका में उपलब्ध रिकॉर्ड की सूची है -

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

क्रॉस जॉइन

एक CROSS जॉइन पहली तालिका की हर पंक्ति को दूसरी तालिका की प्रत्येक पंक्ति के साथ मिलाता है। यदि इनपुट टेबल में क्रमशः x और y कॉलम हैं, तो परिणामी तालिका में x + y कॉलम होंगे। क्योंकि CROSS JOINs में बहुत बड़ी तालिकाओं को उत्पन्न करने की क्षमता होती है, उचित होने पर ही उनका उपयोग करने के लिए ध्यान रखा जाना चाहिए।

निम्नलिखित क्रोस जॉइन का सिंटैक्स है -

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

उपरोक्त सारणियों के आधार पर, हम एक क्रोस जॉइन निम्नानुसार लिख सकते हैं -

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 करें

जॉइनर-पेडिनेट पर आधारित दो टेबल (टेबल 1 और टेबल 2) के कॉलम वैल्यू को मिलाकर एक इनर जॉयइन एक नया परिणाम तालिका बनाता है। क्वेरी तालिका 2 की प्रत्येक पंक्ति के साथ तालिका 1 की प्रत्येक पंक्ति की तुलना सभी पंक्तियों के जोड़े को खोजने के लिए करती है, जो जॉइन-प्रेडिकेट को संतुष्ट करती है। जब ज्वाइन-प्रेडिकेटेट संतुष्ट हो जाता है, टेबल 1 और टेबल 2 की पंक्तियों की प्रत्येक मिलान जोड़ी के लिए कॉलम वैल्यू को एक परिणाम पंक्ति में जोड़ दिया जाता है।

एक INNER JOIN, सबसे सामान्य प्रकार का जुड़ना है और जुड़ने का डिफ़ॉल्ट प्रकार है। आप वैकल्पिक रूप से INNER कीवर्ड का उपयोग कर सकते हैं।

निम्नलिखित ININ 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 मानक तीन प्रकार के OUTER JOINs को परिभाषित करता है: LEFT, RIGHT, और FULL और PostgreSQL इन सभी का समर्थन करता है।

LEFT OUTER JOIN के मामले में, सबसे पहले एक आंतरिक जुड़ाव किया जाता है। फिर, तालिका T1 में प्रत्येक पंक्ति के लिए जो तालिका T2 में किसी पंक्ति के साथ जुड़ने की स्थिति को संतुष्ट नहीं करती है, एक सम्मिलित पंक्ति को T2 के स्तंभों में शून्य मानों के साथ जोड़ा जाता है। इस प्रकार, शामिल तालिका में हमेशा टी 1 में प्रत्येक पंक्ति के लिए कम से कम एक पंक्ति होती है।

निम्नलिखित 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 में किसी भी पंक्ति के साथ जुड़ने की स्थिति को संतुष्ट नहीं करती है, एक सम्मिलित पंक्ति को T1 के कॉलम में शून्य मानों के साथ जोड़ा जाता है। यह लेफ्ट जॉइन का कायल है; परिणाम तालिका में हमेशा T2 में प्रत्येक पंक्ति के लिए एक पंक्ति होगी।

निम्नलिखित राइट जूमिन का वाक्य विन्यास है -

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 में किसी पंक्ति के साथ जुड़ने की स्थिति को संतुष्ट नहीं करती है, एक सम्मिलित पंक्ति को T2 के स्तंभों में शून्य मानों के साथ जोड़ा जाता है। इसके अलावा, टी 2 की प्रत्येक पंक्ति के लिए जो टी 1 में किसी भी पंक्ति के साथ जुड़ने की स्थिति को संतुष्ट नहीं करती है, टी 1 के कॉलम में अशक्त मानों के साथ एक सम्मिलित पंक्ति को जोड़ा जाता है।

निम्नलिखित पूर्ण जूम का वाक्य विन्यास है -

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 |

The PostgreSQL UNION किसी भी डुप्लिकेट पंक्तियों को वापस किए बिना दो या अधिक सेलेक्ट स्टेटमेंट के परिणामों को संयोजित करने के लिए क्लॉज / ऑपरेटर का उपयोग किया जाता है।

UNION का उपयोग करने के लिए, प्रत्येक SELECT में समान स्तंभों की संख्या, स्तंभों की समान संख्या, समान डेटा प्रकार और उन्हें उसी क्रम में होना चाहिए, लेकिन उनकी लंबाई समान नहीं होनी चाहिए।

वाक्य - विन्यास

का मूल सिंटैक्स UNION इस प्रकार है -

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

UNION

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

यहां, दी गई शर्त आपकी आवश्यकता के आधार पर दी गई कोई भी अभिव्यक्ति हो सकती है।

उदाहरण

निम्नलिखित दो तालिकाओं पर विचार करें, (ए) कंपनी तालिका निम्नानुसार है -

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)

(ख) एक और टेबल है विभाग इस प्रकार है -

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)

अब हम इन दो तालिकाओं को निम्न कथन के साथ चयन कथन के साथ जोड़ते हैं जो निम्नानुसार है -

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 ऑपरेटर का उपयोग डुप्लिकेट पंक्तियों सहित दो SELECT स्टेटमेंट्स के परिणामों को संयोजित करने के लिए किया जाता है। समान नियम जो UNION पर लागू होते हैं, UNION सब ऑपरेटर के लिए भी लागू होते हैं।

वाक्य - विन्यास

का मूल सिंटैक्स UNION ALL इस प्रकार है -

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

UNION ALL

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

यहां, दी गई शर्त आपकी आवश्यकता के आधार पर दी गई कोई भी अभिव्यक्ति हो सकती है।

उदाहरण

अब, हमारे चयनित कथन में उपरोक्त दो तालिकाएँ शामिल करें: -

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)

The PostgreSQL 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 मान वाला फ़ील्ड वह है जिसे रिकॉर्ड निर्माण के दौरान खाली छोड़ दिया गया है।

उदाहरण

डेटा का चयन करते समय NULL मान समस्या पैदा कर सकता है, क्योंकि जब किसी अज्ञात मूल्य की किसी अन्य मूल्य से तुलना की जाती है, तो परिणाम हमेशा अज्ञात होता है और अंतिम परिणामों में शामिल नहीं होता है। निम्नलिखित तालिका पर विचार करें, कंपनी के पास निम्नलिखित रिकॉर्ड हैं -

ID          NAME        AGE         ADDRESS     SALARY
----------  ----------  ----------  ----------  ----------
1           Paul        32          California  20000.0
2           Allen       25          Texas       15000.0
3           Teddy       23          Norway      20000.0
4           Mark        25          Rich-Mond   65000.0
5           David       27          Texas       85000.0
6           Kim         22          South-Hall  45000.0
7           James       24          Houston     10000.0

आइए हम विवरण को निम्न के रूप में कुछ अशक्त मान सेट करने के लिए अद्यतन का उपयोग करें -

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

अब, कंपनी तालिका में निम्नलिखित रिकॉर्ड होना चाहिए -

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 ऑपरेटर उन सभी रिकॉर्डों को सूचीबद्ध करने के लिए जहां सैलरी शून्य नहीं है -

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

उदाहरण

निम्नलिखित दो तालिकाओं पर विचार करें, (ए) कंपनी तालिका निम्नानुसार है -

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)

(ख) एक और टेबल है विभाग इस प्रकार है -

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 जहां हम सी और डी का उपयोग क्रमशः कंपनी और डिप्रेशन टेबल के लिए उपनाम के रूप में करते हैं, -

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, अद्यतन या DELETE का प्रयास किया जाता है)

  • ऑपरेशन पूरा होने के बाद (बाधाओं की जाँच होने के बाद और INSERT, UPDATE, या DELETE पूरा हो गया है)

  • ऑपरेशन के बजाय (आवेषण के मामले में, अपडेट या देखने पर हटाता है)

• एक ट्रिगर जिसे EACH ROW के लिए चिह्नित किया जाता है, ऑपरेशन को संशोधित करने वाली प्रत्येक पंक्ति के लिए एक बार कहा जाता है। इसके विपरीत, एक ट्रिगर जिसे EACH STATEMENT के लिए चिह्नित किया गया है, वह किसी भी दिए गए ऑपरेशन के लिए केवल एक बार निष्पादित करता है, फिर चाहे वह कितनी भी पंक्तियों को संशोधित करता हो।

• दोनों, जब क्लॉज और ट्रिगर क्रिया, पंक्ति के तत्वों को सम्मिलित किया जा सकता है, प्रपत्र के संदर्भों का उपयोग करके हटाया या अद्यतन किया जा सकता है NEW.column-name तथा OLD.column-name, जहां स्तंभ-नाम उस तालिका का एक स्तंभ का नाम है जिससे ट्रिगर जुड़ा हुआ है।

• यदि WHEN क्लॉज की आपूर्ति की जाती है, तो निर्दिष्ट PostgreSQL बयान केवल उन पंक्तियों के लिए निष्पादित किए जाते हैं जिनके लिए WHEN क्लॉज सत्य है। यदि कोई WHEN क्लॉज नहीं दिया गया है, तो PostgreSQL स्टेटमेंट्स को सभी पंक्तियों के लिए निष्पादित किया जाता है।

• यदि एक ही तरह के कई ट्रिगर एक ही घटना के लिए परिभाषित किए जाते हैं, तो उन्हें नाम से वर्णानुक्रम में निकाल दिया जाएगा।

• कीवर्ड के पहले, पहले या इंसटैड का निर्धारण तब होता है जब ट्रिगर क्रिया को संबंधित पंक्ति के सम्मिलन, संशोधन या हटाने के सापेक्ष निष्पादित किया जाएगा।

• ट्रिगर स्वचालित रूप से गिरा दिया जाता है जब वह जिस तालिका से जुड़ा होता है उसे गिरा दिया जाता है।

• संशोधित की जाने वाली तालिका उसी डेटाबेस में मौजूद होनी चाहिए जिस तालिका या दृश्य में ट्रिगर जुड़ा हुआ है और किसी को बस उपयोग करना होगा tablename, नहीं database.tablename।

• एक निर्दिष्ट विकल्प जब एक बाधा ट्रिगर बनाता है । यह एक नियमित ट्रिगर के समान है सिवाय इसके कि ट्रिगर फायरिंग के समय को SET CONSTRAINTS का उपयोग करके समायोजित किया जा सकता है। बाधा ट्रिगर से एक अपवाद को बढ़ाने की उम्मीद की जाती है जब वे लागू होने वाली बाधाओं का उल्लंघन किया जाता है।

वाक्य - विन्यास

एक बनाने का मूल वाक्यविन्यास 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....
];

उदाहरण

आइए एक ऐसे मामले पर विचार करें जहां हम कंपनी के टेबल में डाले जा रहे हर रिकॉर्ड के लिए ऑडिट ट्रायल रखना चाहते हैं, जिसे हम इस प्रकार से बनाएंगे (ड्रॉप कंपनी टेबल यदि आपके पास पहले से है)।

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

ऑडिट ट्रायल रखने के लिए, हम AUDIT नामक एक नई तालिका बनाएंगे जहाँ लॉग संदेश डाले जाएँगे जब भी किसी नए रिकॉर्ड के लिए कंपनी तालिका में प्रविष्टि हो -

testdb=# CREATE TABLE AUDIT(
   EMP_ID INT NOT NULL,
   ENTRY_DATE TEXT NOT NULL
);

यहां, आईडी AUDIT रिकॉर्ड आईडी है, और EMP_ID आईडी है, जो कंपनी तालिका से आएगी, और DATE टाइमस्टैम्प रखेगा जब रिकॉर्ड कंपनी तालिका में बनाया जाएगा। तो अब, हम निम्नानुसार कंपनी की मेज पर एक ट्रिगर बनाते हैं -

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

जहां Audloglogfunc () एक 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;

अब, हम वास्तविक काम शुरू करेंगे। आइए हम कंपनी तालिका में रिकॉर्ड सम्मिलित करना शुरू करें, जिसके परिणामस्वरूप AUDIT तालिका में ऑडिट लॉग रिकॉर्ड बनाना चाहिए। तो आइए हम कंपनी तालिका में एक रिकॉर्ड बनाते हैं -

testdb=# INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)
VALUES (1, 'Paul', 32, 'California', 20000.00 );

यह कंपनी तालिका में एक रिकॉर्ड बनाएगी, जो इस प्रकार है -

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

उसी समय, एक रिकॉर्ड AUDIT तालिका में बनाया जाएगा। यह रिकॉर्ड एक ट्रिगर का परिणाम है, जिसे हमने कंपनी टेबल पर INSERT ऑपरेशन पर बनाया है। इसी तरह, आप अपनी आवश्यकताओं के आधार पर अपने ट्रिगर को अपडेट और डिलीट कर सकते हैं।

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

सूचीबद्ध ट्रिगर्स

आप वर्तमान डेटाबेस से सभी ट्रिगर को नीचे सूचीबद्ध कर सकते हैं pg_trigger तालिका निम्नानुसार है -

testdb=# SELECT * FROM pg_trigger;

ऊपर दिया गया PostgreSQL स्टेटमेंट सभी ट्रिगर को नीचे सूचीबद्ध करेगा।

यदि आप किसी विशेष टेबल पर ट्रिगर्स को सूचीबद्ध करना चाहते हैं, तो निम्नानुसार तालिका नाम के साथ और क्लाज का उपयोग करें -

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;

अनुक्रमित विशेष लुकअप टेबल हैं जो डेटाबेस खोज इंजन डेटा पुनर्प्राप्ति को गति देने के लिए उपयोग कर सकते हैं। सीधे शब्दों में कहें, एक सूचकांक एक तालिका में डेटा के लिए एक संकेतक है। एक डेटाबेस में एक सूचकांक एक पुस्तक के पीछे एक सूचकांक के समान है।

उदाहरण के लिए, यदि आप किसी विषय पर चर्चा करने वाली पुस्तक के सभी पृष्ठों को संदर्भित करना चाहते हैं, तो आपको पहले सूचकांक का उल्लेख करना होगा, जो सभी विषयों को वर्णानुक्रम में सूचीबद्ध करता है और फिर एक या अधिक विशिष्ट पृष्ठ संख्याओं को संदर्भित करता है।

एक इंडेक्स सेलेक्टेड क्वेश्चन को गति देने में मदद करता है और जहां क्लॉस होता है; हालाँकि, यह डेटा इनपुट को धीमा करता है, UPDATE और INSERT कथनों के साथ। इंडेक्स डेटा पर कोई प्रभाव नहीं बनाया या गिराया जा सकता है।

एक इंडेक्स बनाने में क्रिएट इंडेक्स स्टेटमेंट शामिल होता है, जो आपको इंडेक्स नाम देने की अनुमति देता है, तालिका को निर्दिष्ट करने के लिए और कौन सा कॉलम या कॉलम इंडेक्स करने के लिए, और यह इंगित करने के लिए कि इंडेक्स आरोही या अवरोही क्रम में है या नहीं।

सूचकांक अद्वितीय भी हो सकता है, UNIQUE बाधा के समान, इसमें सूचकांक कॉलम में डुप्लिकेट प्रविष्टियों या स्तंभों के संयोजन को रोकता है, जिस पर एक सूचकांक है।

क्रिएट इंडेक्स कमांड

का मूल सिंटैक्स CREATE INDEX इस प्रकार है -

CREATE INDEX index_name ON table_name;

सूचकांक प्रकार

PostgreSQL कई सूचकांक प्रकार प्रदान करता है: बी-ट्री, हैश, जीएसटी, एसपी-जीएसटी और जीआईएन। प्रत्येक सूचकांक प्रकार एक अलग एल्गोरिथ्म का उपयोग करता है जो विभिन्न प्रकार के प्रश्नों के लिए सबसे उपयुक्त है। डिफ़ॉल्ट रूप से, क्रिएट इंडेक्स कमांड बी-ट्री इंडेक्स बनाता है, जो सबसे आम स्थितियों में फिट होता है।

सिंगल-कॉलम इंडेक्स

एकल-स्तंभ अनुक्रमणिका वह है जो केवल एक तालिका स्तंभ के आधार पर बनाई गई है। मूल वाक्य रचना इस प्रकार है -

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

निहित सूचकांक

इंप्लिकेट इंडेक्स इंडेक्स होते हैं जो किसी ऑब्जेक्ट के बनने पर डेटाबेस सर्वर द्वारा स्वचालित रूप से बनाए जाते हैं। प्राथमिक कुंजी बाधाओं और अद्वितीय बाधाओं के लिए अनुक्रमणिका स्वचालित रूप से बनाई जाती हैं।

उदाहरण

निम्नलिखित एक उदाहरण है जहां हम वेतन स्तंभ के लिए कंपनी तालिका पर एक सूचकांक बनाएंगे -

# CREATE INDEX salary_index ON COMPANY (salary);

अब, कंपनी तालिका पर उपलब्ध सभी सूचकांकों का उपयोग करते हुए सूचीबद्ध करते हैं \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 मान हैं।

• जिन कॉलमों में अक्सर हेरफेर किया जाता है, उन्हें अनुक्रमित नहीं किया जाना चाहिए।

The PostgreSQL ALTER TABLE मौजूदा तालिका में कॉलम जोड़ने, हटाने या संशोधित करने के लिए कमांड का उपयोग किया जाता है।

आप मौजूदा तालिका में विभिन्न बाधाओं को जोड़ने और छोड़ने के लिए ALTER TABLE कमांड का भी उपयोग करेंगे।

वाक्य - विन्यास

का मूल सिंटैक्स ALTER TABLE मौजूदा तालिका में एक नया कॉलम जोड़ने के लिए इस प्रकार है -

ALTER TABLE table_name ADD column_name datatype;

के लिए बुनियादी तालिका के बुनियादी वाक्यविन्यास 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;

के लिए बुनियादी तालिका के बुनियादी वाक्यविन्यास ADD UNIQUE CONSTRAINT एक तालिका इस प्रकार है -

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

के लिए बुनियादी तालिका के बुनियादी वाक्यविन्यास ADD CHECK CONSTRAINT एक तालिका इस प्रकार है -

ALTER TABLE table_name
ADD CONSTRAINT MyUniqueConstraint CHECK (CONDITION);

के लिए बुनियादी तालिका के बुनियादी वाक्यविन्यास ADD PRIMARY KEY एक तालिका के लिए बाधा इस प्रकार है -

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

के लिए बुनियादी तालिका के बुनियादी वाक्यविन्यास DROP CONSTRAINT एक तालिका इस प्रकार है -

ALTER TABLE table_name
DROP CONSTRAINT MyUniqueConstraint;

यदि आप MySQL का उपयोग कर रहे हैं, तो कोड इस प्रकार है -

ALTER TABLE table_name
DROP INDEX MyUniqueConstraint;

के लिए बुनियादी तालिका के बुनियादी वाक्यविन्यास DROP PRIMARY KEY एक तालिका से बाधा इस प्रकार है -

ALTER TABLE table_name
DROP CONSTRAINT MyPrimaryKey;

यदि आप MySQL का उपयोग कर रहे हैं, तो कोड इस प्रकार है -

ALTER TABLE table_name
DROP PRIMARY KEY;

उदाहरण

हमारी कंपनी की तालिका पर विचार करें निम्नलिखित रिकॉर्ड हैं -

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

अब, कंपनी तालिका बदली गई है और निम्नलिखित का चयन सेलेक्ट स्टेटमेंट से किया जाएगा -

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 लिंग स्तंभ का उदाहरण निम्नलिखित है -

testdb=# ALTER TABLE COMPANY DROP GENDER;

अब, कंपनी तालिका बदली गई है और निम्नलिखित का चयन सेलेक्ट स्टेटमेंट से किया जाएगा -

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

The PostgreSQL TRUNCATE TABLEमौजूदा तालिका से पूरा डेटा हटाने के लिए कमांड का उपयोग किया जाता है। आप संपूर्ण तालिका को हटाने के लिए DROP TABLE कमांड का भी उपयोग कर सकते हैं, लेकिन यह डेटाबेस से पूर्ण तालिका संरचना को हटा देगा और यदि आप कुछ डेटा संग्रहीत करना चाहते हैं तो आपको इस तालिका को एक बार फिर से बनाना होगा।

इसका प्रत्येक टेबल पर DELETE के समान प्रभाव है, लेकिन चूंकि यह वास्तव में तालिकाओं को स्कैन नहीं करता है, इसलिए यह तेज है। इसके अलावा, यह डिस्क स्थान को तुरंत बाद में ले लेता है, बजाय इसके बाद के VACUUM ऑपरेशन की आवश्यकता होती है। यह बड़े तालिकाओं पर सबसे उपयोगी है।

वाक्य - विन्यास

का मूल सिंटैक्स TRUNCATE TABLE इस प्रकार है -

TRUNCATE TABLE  table_name;

उदाहरण

कंपनी तालिका पर विचार करें निम्नलिखित रिकॉर्ड हैं -

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;

अब, कंपनी की तालिका को काट दिया जाता है और निम्नलिखित का चयन होगा -

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

दृश्य छद्म टेबल हैं। यही है, वे असली टेबल नहीं हैं; फिर भी चयन करने के लिए सामान्य तालिकाओं के रूप में दिखाई देते हैं। एक दृश्य एक वास्तविक तालिका के सबसेट का प्रतिनिधित्व कर सकता है, एक साधारण तालिका से कुछ कॉलम या कुछ पंक्तियों का चयन कर सकता है। एक दृश्य भी शामिल तालिकाओं का प्रतिनिधित्व कर सकता है। क्योंकि विचारों को अलग-अलग अनुमतियाँ दी गई हैं, आप उनका उपयोग तालिका पहुंच को प्रतिबंधित करने के लिए कर सकते हैं ताकि उपयोगकर्ता केवल किसी तालिका की विशिष्ट पंक्तियों या स्तंभों को देख सकें।

एक दृश्य में एक या अधिक तालिकाओं से तालिका या चयनित पंक्तियों की सभी पंक्तियाँ हो सकती हैं। एक दृश्य एक या कई तालिकाओं से बनाया जा सकता है, जो एक दृश्य बनाने के लिए लिखित पोस्टग्रेक्यूएल क्वेरी पर निर्भर करता है।

दृश्य, जो वर्चुअल टेबल की तरह हैं, उपयोगकर्ताओं को निम्नलिखित करने की अनुमति देते हैं -

• संरचना डेटा एक तरह से जो उपयोगकर्ताओं या उपयोगकर्ताओं के वर्ग को प्राकृतिक या सहज ज्ञान युक्त लगता है।

• डेटा तक पहुंच को प्रतिबंधित करें जैसे कि उपयोगकर्ता पूर्ण तालिका के बजाय केवल सीमित डेटा देख सकता है।

• विभिन्न तालिकाओं से डेटा संक्षेप करें, जिनका उपयोग रिपोर्ट बनाने के लिए किया जा सकता है।

चूंकि दृश्य सामान्य टेबल नहीं हैं, आप किसी दृश्य पर DELETE, INSERT, या अद्यतन विवरण निष्पादित करने में सक्षम नहीं हो सकते हैं। हालाँकि, आप किसी दृश्य पर DELETE, INSERT या UPDATE का उपयोग करने की इस समस्या को ठीक करने के लिए एक RULE बना सकते हैं।

दृश्य बनाना

PostgreSQL दृश्य का उपयोग कर बनाया जाता है CREATE VIEWबयान। PostgreSQL के दृश्य एक ही तालिका, कई तालिकाओं या किसी अन्य दृश्य से बनाए जा सकते हैं।

मूल क्रिएट व्यू सिंटैक्स इस प्रकार है -

CREATE [TEMP | TEMPORARY] VIEW view_name AS
SELECT column1, column2.....
FROM table_name
WHERE [condition];

आप अपने SELECT स्टेटमेंट में कई टेबल्स को उसी तरह से शामिल कर सकते हैं जैसे आप उन्हें सामान्य PostgreSQL SELECT क्वेरी में उपयोग करते हैं। यदि वैकल्पिक TEMP या TEMPORARY कीवर्ड मौजूद है, तो दृश्य अस्थायी स्थान में बनाया जाएगा। वर्तमान सत्र के अंत में अस्थायी विचारों को स्वचालित रूप से हटा दिया जाता है।

उदाहरण

विचार करें, कंपनी तालिका में निम्नलिखित रिकॉर्ड हैं -

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=# 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_name। मूल ड्रॉप व्यू सिंटैक्स इस प्रकार है -

testdb=# DROP VIEW view_name;

निम्नलिखित आदेश Company_VIEW दृश्य को हटा देगा, जिसे हमने पिछले अनुभाग में बनाया था -

testdb=# DROP VIEW COMPANY_VIEW;

लेनदेन एक कार्य की एक इकाई है जो एक डेटाबेस के खिलाफ किया जाता है। लेन-देन एक तार्किक क्रम में पूरी की जाने वाली इकाइयाँ या अनुक्रम हैं, चाहे वह किसी उपयोगकर्ता द्वारा मैन्युअल रूप से या किसी प्रकार के डेटाबेस प्रोग्राम द्वारा स्वचालित रूप से हो।

लेन-देन डेटाबेस में एक या एक से अधिक परिवर्तनों का प्रसार है। उदाहरण के लिए, यदि आप एक रिकॉर्ड बना रहे हैं, रिकॉर्ड अपडेट कर रहे हैं, या टेबल से रिकॉर्ड हटा रहे हैं, तो आप टेबल पर लेनदेन कर रहे हैं। डेटा अखंडता सुनिश्चित करने और डेटाबेस त्रुटियों को संभालने के लिए लेनदेन को नियंत्रित करना महत्वपूर्ण है।

व्यावहारिक रूप से, आप एक समूह में कई PostgreSQL प्रश्नों को क्लब करेंगे और आप एक लेनदेन के एक हिस्से के रूप में उन सभी को एक साथ निष्पादित करेंगे।

लेन-देन के गुण

लेन-देन में निम्नलिखित चार मानक गुण होते हैं, जिन्हें आमतौर पर संक्षिप्त ACID द्वारा संदर्भित किया जाता है -

• Atomicity- यह सुनिश्चित करता है कि कार्य इकाई के भीतर सभी संचालन सफलतापूर्वक पूरा हो गए हैं; अन्यथा, विफलता के बिंदु पर लेन-देन निरस्त कर दिया जाता है और पिछले ऑपरेशनों को उनके पूर्व राज्य में वापस ले जाया जाता है।

• Consistency - सुनिश्चित करता है कि डेटाबेस सफलतापूर्वक परिवर्तित किए गए लेनदेन पर सही ढंग से परिवर्तन करता है।

• Isolation - स्वतंत्र रूप से और एक दूसरे के लिए पारदर्शी संचालित करने के लिए लेनदेन को सक्षम करता है।

• Durability - सुनिश्चित करता है कि प्रतिबद्ध लेनदेन का परिणाम या प्रभाव एक सिस्टम विफलता के मामले में बना रहता है।

लेन-देन नियंत्रण

लेनदेन को नियंत्रित करने के लिए निम्नलिखित कमांड का उपयोग किया जाता है -

• BEGIN TRANSACTION - लेन-देन शुरू करना।

• COMMIT - परिवर्तनों को सहेजने के लिए, वैकल्पिक रूप से आप उपयोग कर सकते हैं END TRANSACTION आदेश।

• ROLLBACK - परिवर्तनों को रोलबैक करने के लिए।

लेन-देन नियंत्रण आदेश केवल डीएमएल कमांड INSERT, UPDATE और DELETE के साथ ही उपयोग किए जाते हैं। इनका उपयोग तालिकाओं को बनाने या उन्हें गिराने के दौरान नहीं किया जा सकता क्योंकि ये ऑपरेशन डेटाबेस में स्वचालित रूप से प्रतिबद्ध होते हैं।

BEGIN परिवहन कमांड

लेन-देन BEGIN परिवहन या बस BEGIN आदेश का उपयोग करके शुरू किया जा सकता है। इस तरह के लेनदेन आमतौर पर तब तक बने रहते हैं जब तक कि अगले COMMIT या ROLLBACK कमांड का सामना नहीं हो जाता। लेकिन डेटाबेस बंद होने पर या यदि कोई त्रुटि होती है, तो एक लेन-देन भी रोलबैक होगा।

लेनदेन शुरू करने के लिए सरल वाक्यविन्यास निम्नलिखित है -

BEGIN;

or

BEGIN TRANSACTION;

COMMIT कमांड

COMMIT कमांड एक ट्रांसेक्शनल कमांड है जिसका उपयोग डेटाबेस में ट्रांजेक्शन के लिए किए गए परिवर्तनों को सहेजने के लिए किया जाता है।

COMMIT कमांड अंतिम COMMIT या ROLLBACK कमांड के बाद से डेटाबेस के लिए सभी लेनदेन बचाता है।

COMMIT कमांड का सिंटैक्स इस प्रकार है -

COMMIT;

or

END TRANSACTION;

रोलबैक कमांड

रोलबैक कमांड लेनदेन को पूर्ववत करने के लिए उपयोग किया जाने वाला ट्रांसेक्शनल कमांड है जिसे पहले से डेटाबेस में सहेजा नहीं गया है।

ROLLBACK कमांड का उपयोग केवल पिछले COMMIT या ROLLBACK कमांड जारी होने के बाद लेनदेन को पूर्ववत करने के लिए किया जा सकता है।

रोलबैक कमांड का सिंटैक्स इस प्रकार है -

ROLLBACK;

उदाहरण

कंपनी की तालिका पर गौर करें कि निम्नलिखित रिकॉर्ड हैं -

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

अब, एक लेनदेन शुरू करते हैं और उम्र = 25 होने वाली तालिका से रिकॉर्ड हटाते हैं और अंत में हम सभी परिवर्तनों को पूर्ववत् करने के लिए रोलबैक कमांड का उपयोग करते हैं।

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

यदि आप जाँचेंगे कि कंपनी की तालिका में अभी भी निम्नलिखित रिकॉर्ड हैं -

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

अब, आइए हम एक और लेन-देन शुरू करते हैं और उम्र = 25 वाली तालिका से रिकॉर्ड हटाते हैं और अंत में हम सभी परिवर्तनों को करने के लिए COMMIT कमांड का उपयोग करते हैं।

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

यदि आप कंपनी तालिका की जाँच करेंगे, तो यह अभी भी निम्नलिखित रिकॉर्ड है -

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)

ताले या विशेष ताले या लिखें ताले उपयोगकर्ताओं को एक पंक्ति या संपूर्ण तालिका को संशोधित करने से रोकते हैं। UPDATE और DELETE द्वारा संशोधित पंक्तियों को फिर लेनदेन की अवधि के लिए स्वचालित रूप से बंद कर दिया जाता है। यह अन्य उपयोगकर्ताओं को तब तक पंक्ति को बदलने से रोकता है जब तक कि लेनदेन या तो प्रतिबद्ध नहीं होता है या वापस रोल नहीं किया जाता है।

केवल उसी समय जब उपयोगकर्ताओं को अन्य उपयोगकर्ताओं की प्रतीक्षा करनी चाहिए, जब वे उसी पंक्ति को संशोधित करने का प्रयास कर रहे हों। यदि वे विभिन्न पंक्तियों को संशोधित करते हैं, तो कोई प्रतीक्षा आवश्यक नहीं है। चयनित प्रश्नों का कभी इंतजार नहीं करना पड़ता।

डेटाबेस स्वचालित रूप से लॉकिंग करता है। हालांकि, कुछ मामलों में, लॉकिंग को मैन्युअल रूप से नियंत्रित किया जाना चाहिए। LOCK कमांड का उपयोग करके मैनुअल लॉकिंग की जा सकती है। यह लेनदेन के लॉक प्रकार और दायरे के विनिर्देशन की अनुमति देता है।

लॉक कमांड के लिए सिंटैक्स

LOCK कमांड के लिए मूल सिंटैक्स इस प्रकार है -

LOCK [ TABLE ]
name
 IN
lock_mode

• name- एक मौजूदा तालिका का नाम (वैकल्पिक स्कीमा-योग्य) लॉक करने के लिए। यदि केवल तालिका नाम से पहले निर्दिष्ट किया गया है, तो केवल उस तालिका को लॉक किया गया है। यदि केवल निर्दिष्ट नहीं है, तो तालिका और उसके सभी वंशज तालिकाओं (यदि कोई हो) बंद हैं।

• lock_mode- लॉक मोड निर्दिष्ट करता है जो इस लॉक को लॉक करता है जिसके साथ टकराव होता है। यदि कोई लॉक मोड निर्दिष्ट नहीं है, तो सबसे अधिक प्रतिबंधात्मक मोड, ACCESS EXCLUSIVE का उपयोग किया जाता है। संभावित मान हैं: ACCESS SHARE, ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE, EXCLUSIVE, ACCESS EXCLUSIVE।

एक बार प्राप्त करने के बाद, ताला वर्तमान लेनदेन के शेष के लिए आयोजित किया जाता है। कोई UNLOCK टेबल कमांड नहीं है; लेन-देन के अंत में ताले हमेशा जारी होते हैं।

गतिरोध

गतिरोध तब हो सकता है जब दो लेनदेन एक-दूसरे का इंतजार कर रहे हैं ताकि उनके संचालन समाप्त हो सकें। जबकि PostgreSQL उन्हें पहचान सकता है और उन्हें एक रोलबैक के साथ समाप्त कर सकता है, गतिरोध अभी भी असुविधाजनक हो सकता है। अपने अनुप्रयोगों को इस समस्या में चलने से रोकने के लिए, उन्हें इस तरह से डिज़ाइन करना सुनिश्चित करें कि वे उसी क्रम में वस्तुओं को लॉक करेंगे।

सलाहकार ताले

PostgreSQL उन ताले बनाने के लिए साधन प्रदान करता है जिनमें अनुप्रयोग-परिभाषित अर्थ होते हैं। इन्हें एडवाइजरी लॉक कहा जाता है । जैसा कि सिस्टम उनके उपयोग को लागू नहीं करता है, यह उन्हें सही ढंग से उपयोग करने के लिए आवेदन पर निर्भर है। सलाहकार ताले लॉकिंग रणनीतियों के लिए उपयोगी हो सकते हैं जो MVCC मॉडल के लिए एक अजीब फिट हैं।

उदाहरण के लिए, सलाहकार ताले का एक सामान्य उपयोग तथाकथित "फ्लैट फाइल" डेटा प्रबंधन प्रणालियों के विशिष्ट निराशावादी लॉकिंग रणनीतियों का अनुकरण करना है। हालांकि एक तालिका में संग्रहीत ध्वज का उपयोग उसी उद्देश्य के लिए किया जा सकता है, सलाहकार ताले तेज हैं, टेबल ब्लोट से बचें, और सत्र के अंत में सर्वर द्वारा स्वचालित रूप से साफ किया जाता है।

उदाहरण

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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)

निम्नलिखित उदाहरण ACCESS EXCLUSIVE मोड में testdb डेटाबेस के भीतर कंपनी तालिका को लॉक करता है। LOCK स्टेटमेंट केवल एक लेनदेन मोड में काम करता है -

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

ऊपर दिया गया PostgreSQL स्टेटमेंट निम्न परिणाम देगा -

LOCK TABLE

उपरोक्त संदेश इंगित करता है कि लेन-देन समाप्त होने तक तालिका लॉक है और लेनदेन समाप्त करने के लिए आपको या तो रोलबैक करना होगा या लेनदेन करना होगा।

एक सबक्वेरी या इनर क्वेरी या नेस्टेड क्वेरी एक अन्य पोस्टग्रेक्यूक्यू क्वेरी के भीतर एक क्वेरी है और जिसे WHERE क्लॉज के भीतर एम्बेड किया गया है।

एक सबक्वेरी का उपयोग डेटा को वापस करने के लिए किया जाता है जिसका उपयोग मुख्य क्वेरी में डेटा को पुनः प्राप्त करने के लिए प्रतिबंधित करने के लिए एक शर्त के रूप में किया जाएगा।

उप-प्रकार का उपयोग SELECT, INSERT, UPDATE और DELETE कथनों के साथ किया जा सकता है जैसे कि =, <,>,> = =, <=, IN आदि।

कुछ नियम हैं जिनका पालन करना होगा -

• कोष्ठक के भीतर उप-विषयों को संलग्न किया जाना चाहिए।

• सबक्लेरी का चयन खंड में केवल एक कॉलम हो सकता है, जब तक कि इसके चयनित कॉलम की तुलना करने के लिए सबक्वेरी में कई कॉलम मुख्य क्वेरी में न हों।

• एक ORDER BY का उपयोग एक सबक्वेरी में नहीं किया जा सकता है, हालांकि मुख्य क्वेरी ORDER BY का उपयोग कर सकती है। ग्रुप BY का उपयोग एक उप-समारोह में ORDER BY के समान कार्य करने के लिए किया जा सकता है।

• उप-पंक्ति जो एक से अधिक पंक्ति में लौटती हैं, उनका उपयोग केवल कई मान ऑपरेटरों, जैसे IN, EXISTS, NOT IN, किसी / SOME, सभी ऑपरेटर के साथ किया जा सकता है।

• BETWEEN ऑपरेटर का उपयोग एक सबक्वेरी के साथ नहीं किया जा सकता है; हालाँकि, BETWEEN का उपयोग उपकुंजी के भीतर किया जा सकता है।

चयन कथन के साथ उपश्रेणियाँ

सबक्वेरी का उपयोग अक्सर सेलेक्ट स्टेटमेंट के साथ किया जाता है। मूल वाक्य रचना इस प्रकार है -

SELECT column_name [, column_name ]
FROM   table1 [, table2 ]
WHERE  column_name OPERATOR
      (SELECT column_name [, column_name ]
      FROM table1 [, table2 ]
      [WHERE])

उदाहरण

निम्नलिखित रिकॉर्ड वाले कंपनी तालिका पर विचार करें -

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_BKP का उपयोग करके एक ही सृजन तालिका का उपयोग करके बनाया जा सकता है। अब, कंपनी टेबल को पूरा करने के लिए Company_BKP में, निम्नलिखित सिंटैक्स है -

testdb=# INSERT INTO COMPANY_BKP
   SELECT * FROM COMPANY
   WHERE ID IN (SELECT ID
      FROM COMPANY) ;

अद्यतन विवरण के साथ उपश्रेणियाँ

उपखंड का उपयोग अद्यतन कथन के साथ किया जा सकता है। अद्यतन के साथ एक तालिका में एकल या एकाधिक स्तंभ अद्यतन किया जा सकता है जब अद्यतन कथन के साथ।

मूल वाक्य रचना इस प्रकार है -

UPDATE table
SET column_name = new_value
[ WHERE OPERATOR [ VALUE ]
   (SELECT COLUMN_NAME
   FROM TABLE_NAME)
   [ WHERE) ]

उदाहरण

मान लें, हमारे पास Company_BKP तालिका उपलब्ध है, जो कंपनी तालिका का बैकअप है।

निम्नलिखित उदाहरण सभी ग्राहकों के लिए कंपनी तालिका में सैलरी को 0.50 गुना अपडेट करता है, जिसका AGE 27 से अधिक या उससे अधिक है -

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

यह दो पंक्तियों को प्रभावित करेगा और अंत में कंपनी तालिका में निम्नलिखित रिकॉर्ड होंगे -

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 तालिका उपलब्ध है, जो कंपनी तालिका का एक बैकअप है।

निम्नलिखित उदाहरण उन सभी ग्राहकों के लिए कंपनी तालिका से रिकॉर्ड हटा देता है, जिनका AGE 27 से अधिक या उसके बराबर है -

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

यह दो पंक्तियों को प्रभावित करेगा और अंत में कंपनी तालिका में निम्नलिखित रिकॉर्ड होंगे -

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 में डेटा प्रकार छोटे , सीरियल और बिगसेरियल हैं ; ये सत्य प्रकार नहीं हैं, लेकिन विशिष्ट पहचानकर्ता कॉलम बनाने के लिए केवल एक उल्लेखनीय सुविधा है। ये कुछ अन्य डेटाबेस द्वारा समर्थित AUTO_INCREMENT संपत्ति के समान हैं।

यदि आप एक सीरियल कॉलम की इच्छा रखते हैं एक अद्वितीय बाधा या एक प्राथमिक कुंजी हो, तो इसे अब किसी भी अन्य डेटा प्रकार की तरह निर्दिष्ट किया जाना चाहिए।

टाइप नाम सीरियल एक पूर्णांक कॉलम बनाता है । प्रकार नाम bigserial एक bigint स्तंभ बनाता है । यदि आप तालिका के जीवनकाल में 2 से अधिक ³¹ पहचानकर्ताओं के उपयोग का अनुमान लगाते हैं तो बिगसरियल का उपयोग किया जाना चाहिए । प्रकार का नाम smallserial एक बनाता है SMALLINT स्तंभ।

वाक्य - विन्यास

का मूल उपयोग SERIAL डेटेप इस प्रकार है -

CREATE TABLE tablename (
   colname SERIAL
);

उदाहरण

निम्नानुसार बनाई गई कंपनी तालिका पर विचार करें -

testdb=# CREATE TABLE COMPANY(
   ID  SERIAL PRIMARY KEY,
   NAME           TEXT      NOT NULL,
   AGE            INT       NOT NULL,
   ADDRESS        CHAR(50),
   SALARY         REAL
);

अब, निम्न अभिलेखों को तालिका कंपनी में डालें -

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

यह तालिका में सात टुपल्स सम्मिलित करेगा। कंपनी और कंपनी के पास निम्नलिखित रिकॉर्ड होंगे -

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

यह संदेश क्रिएट रोल इंगित करता है कि USER "मनीषा" बनाया गया है।

तालिका पर विचार करें कंपनी के रिकॉर्ड निम्नानुसार हैं -

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)

इसके बाद, उपयोगकर्ता को "मनीषा" की एक तालिका कंपनी के सभी विशेषाधिकार प्रदान करें: -

testdb=# GRANT ALL ON COMPANY TO manisha;
GRANT

संदेश GRANT बताता है कि सभी विशेषाधिकार USER को दिए गए हैं।

इसके बाद, हम USER "मनीषा" से विशेषाधिकारों को निरस्त करते हैं -

testdb=# REVOKE ALL ON COMPANY FROM manisha;
REVOKE

संदेश REVOKE इंगित करता है कि सभी विशेषाधिकार USER से निरस्त कर दिए गए हैं।

आप उपयोगकर्ता को इस प्रकार हटा सकते हैं -

testdb=# DROP USER manisha;
DROP ROLE

DROP ROLE संदेश USER 'मनीषा' को डेटाबेस से हटा दिया गया है।

हम अध्याय में दिनांक / समय डेटा प्रकारों के बारे चर्चा की थी डेटा प्रकार । अब, हम दिनांक / समय ऑपरेटरों और कार्यों को देखते हैं।

निम्न तालिका बुनियादी अंकगणितीय ऑपरेटरों के व्यवहार को सूचीबद्ध करती है -

ऑपरेटर	उदाहरण	परिणाम
+	दिनांक '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	औचित्य साबित अंतराल समायोजित करें

AGE (टाइमस्टैम्प, टाइमस्टैम्प), AGE (टाइमस्टैम्प)

एस।	समारोह विवरण
1	AGE(timestamp, timestamp) दूसरे तर्क के TIMESTAMP फॉर्म के साथ आह्वान किए जाने पर, AGE () तर्कों को घटाते हैं, एक "प्रतीकात्मक" परिणाम का निर्माण करते हैं जो वर्षों और महीनों का उपयोग करता है और प्रकार का होता है।
2	AGE(timestamp) जब केवल TIMESTAMP को तर्क के रूप में आमंत्रित किया जाता है, तो AGE () करंट_डेट (आधी रात को) से घटता है।

समारोह का उदाहरण AGE (टाइमस्टैम्प, टाइमस्टैम्प) है -

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) इन कार्यों को उपक्षेत्र मिलते हैं। क्षेत्र पैरामीटर एक स्ट्रिंग मान, एक नाम नहीं होने की जरूरत है। मान्य क्षेत्र के नाम हैं: सदी, दिन, दशक, डो, डू, युग, घंटा, आइसोडो, आइसोयर, माइक्रोसेकंड, सहस्त्राब्दी, मिलीसेकंड, मिनट, महीना, तिमाही, दूसरा, समय-क्षेत्र, timezone_hour, timezone_minute, वर्ष।
2	DATE_TRUNC('field', source) यह फ़ंक्शन वैचारिक रूप से संख्याओं के लिए ट्रंक फ़ंक्शन के समान है । स्रोत प्रकार टाइमस्टैम्प या अंतराल का एक मूल्य अभिव्यक्ति है। फ़ील्ड का चयन करता है कि इनपुट मान को कम करने के लिए कौन सी सटीकता है। वापसी मूल्य टाइमस्टैम्प या अंतराल का है । क्षेत्र के लिए मान्य मूल्य हैं: माइक्रोसेकंड, मिलीसेकंड, दूसरा, मिनट, घंटा, दिन, सप्ताह, महीना, तिमाही, वर्ष, दशक, शताब्दी, सहस्राब्दी

DATE_PART ( 'फ़ील्ड' , स्रोत) फ़ंक्शन के लिए निम्न उदाहरण हैं -

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 ( 'फ़ील्ड' , स्रोत) फ़ंक्शन के लिए निम्न उदाहरण हैं -

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)फ़ंक्शन दिनांक / समय मानों से वर्ष या घंटे जैसे सबफ़िल्ड को पुनर्प्राप्त करता है। स्रोत के प्रकार के एक मूल्य अभिव्यक्ति होना चाहिए टाइमस्टैम्प, समय, या अंतराल । क्षेत्र एक पहचानकर्ता या स्ट्रिंग है कि चयन स्रोत मान से निकालने के लिए क्या क्षेत्र। EXTRACT फ़ंक्शन टाइप डबल परिशुद्धता के मान लौटाता है ।

निम्नलिखित मान्य फ़ील्ड नाम हैं (DATE_PART फ़ंक्शन फ़ील्ड नामों के समान): शताब्दी, दिन, दशक, डॉव, doy, युग, घंटा, isodow, isoyear, microseconds, मिलेनियम, मिलीसेकंड, मिनट, महीना, तिमाही, दूसरा, timezone, timezone_hour , timezone_minute, सप्ताह, वर्ष।

निम्नलिखित EXTRACT ( 'फ़ील्ड' , स्रोत) फ़ंक्शन के उदाहरण हैं -

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, जिसे संग्रहीत कार्यविधियों के रूप में भी जाना जाता है, आपको उन कार्यों को करने की अनुमति देता है जो सामान्य रूप से डेटाबेस में एक ही फ़ंक्शन में कई प्रश्न और गोल यात्राएं करेंगे। फ़ंक्शंस डेटाबेस के पुन: उपयोग की अनुमति देते हैं क्योंकि अन्य अनुप्रयोग मध्य-स्तरीय या डुप्लिकेट कोड के बजाय सीधे आपके संग्रहीत प्रक्रियाओं के साथ बातचीत कर सकते हैं।

अपनी पसंद की भाषा जैसे 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, आंतरिक या उपयोगकर्ता द्वारा परिभाषित प्रक्रियात्मक भाषा का नाम हो सकता है। पश्चगामी संगतता के लिए, नाम एकल उद्धरण द्वारा संलग्न किया जा सकता है।

उदाहरण

निम्न उदाहरण स्टैंडअलोन फ़ंक्शन बनाने और कॉल करने का चित्रण करता है। यह फ़ंक्शन कंपनी तालिका में रिकॉर्ड की कुल संख्या देता है। हम कंपनी तालिका का उपयोग करेंगे , जिसमें निम्नलिखित रिकॉर्ड हैं -

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)

फंक्शन कुल रिकॉर्ड () इस प्रकार है -

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

अब, इस फ़ंक्शन को कॉल निष्पादित करते हैं और कंपनी तालिका में रिकॉर्ड की जांच करते हैं

testdb=# select totalRecords();

जब उपरोक्त क्वेरी निष्पादित की जाती है, तो परिणाम होगा -

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

PostgreSQL बिल्ट-इन फ़ंक्शंस, जिसे एग्रीगेट फ़ंक्शंस भी कहा जाता है, स्ट्रिंग या न्यूमेरिक डेटा पर प्रोसेसिंग करने के लिए उपयोग किया जाता है।

निम्नलिखित सभी सामान्य-उद्देश्य पोस्टग्रेक्सेल की अंतर्निहित कार्य सूची है -

• PostgreSQL COUNT फ़ंक्शन - PostgreSQL COUNT समग्र फ़ंक्शन का उपयोग डेटाबेस तालिका में पंक्तियों की संख्या की गणना करने के लिए किया जाता है।

• PostgreSQL MAX फ़ंक्शन - PostgreSQL मैक्स एग्रीगेट फ़ंक्शन हमें एक निश्चित कॉलम के लिए उच्चतम (अधिकतम) मान का चयन करने की अनुमति देता है।

• PostgreSQL MIN फंक्शन - PostgreSQL MIN एग्रीगेट फ़ंक्शन हमें एक निश्चित कॉलम के लिए न्यूनतम (न्यूनतम) मान का चयन करने की अनुमति देता है।

• PostgreSQL AVG फ़ंक्शन - PostgreSQL AVG कुल फ़ंक्शन कुछ तालिका स्तंभ के लिए औसत मान का चयन करता है।

• PostgreSQL SUM फ़ंक्शन - PostgreSQL SUM कुल फ़ंक्शन एक संख्यात्मक स्तंभ के लिए कुल का चयन करने की अनुमति देता है।

• PostgreSQL ARRAY फ़ंक्शंस - PostgreSQL ARRAY एग्रीगेट फ़ंक्शन इनपुट मानों को शामिल करता है, जिसमें नल, एक सरणी में संक्षिप्त होता है।

• PostgreSQL न्यूमेरिक फ़ंक्शंस - SQL में संख्याओं में हेरफेर करने के लिए आवश्यक PostgreSQL कार्यों की पूरी सूची।

• PostgreSQL स्ट्रिंग फ़ंक्शंस - PostgreSQL में स्ट्रिंग्स में हेरफेर करने के लिए आवश्यक पोस्टग्रेएसक्यूएल फ़ंक्शन की पूरी सूची।

यह ट्यूटोरियल उपयोग करने जा रहा है libpqxxलाइब्रेरी, जो कि पोस्टग्रेएसक्यूएल के लिए आधिकारिक सी ++ क्लाइंट एपीआई है। 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

यदि आप निम्नलिखित कमांड का उपयोग करके नहीं चल रहे हैं, तो आप सर्वर को फिर से शुरू / पुनः आरंभ कर सकते हैं -

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

C / C ++ इंटरफ़ेस APIs

निम्नलिखित महत्वपूर्ण इंटरफ़ेस रूटीन हैं जो आपके C / C ++ प्रोग्राम से PostgreSQL डेटाबेस के साथ काम करने के लिए आपकी आवश्यकता को पूरा कर सकते हैं। यदि आप एक अधिक परिष्कृत आवेदन की तलाश कर रहे हैं तो आप libpqxx आधिकारिक दस्तावेज में देख सकते हैं, या आप व्यावसायिक रूप से उपलब्ध एपीआई का उपयोग कर सकते हैं।

एस।	एपीआई और विवरण
1	pqxx::connection C( const std::string & dbstring ) यह एक टंकण है जो डेटाबेस से जुड़ने के लिए उपयोग किया जाएगा। यहां, उदाहरण के लिए, dbstring डेटाबेस से कनेक्ट करने के लिए आवश्यक पैरामीटर प्रदान करता हैdbname = testdb user = postgres password=pass123 hostaddr=127.0.0.1 port=5432। यदि कनेक्शन सफलतापूर्वक सेटअप है तो यह कनेक्शन ऑब्जेक्ट के साथ सी बनाता है जो विभिन्न उपयोगी फ़ंक्शन सार्वजनिक फ़ंक्शन प्रदान करता है।
2	C.is_open() विधि is_open () कनेक्शन ऑब्जेक्ट का एक सार्वजनिक तरीका है और बूलियन मान लौटाता है। यदि कनेक्शन सक्रिय है, तो यह तरीका सही है अन्यथा यह गलत है।
3	C.disconnect() इस पद्धति का उपयोग किसी खोले हुए डेटाबेस कनेक्शन को डिस्कनेक्ट करने के लिए किया जाता है।
4	pqxx::work W( C ) यह एक टाइपसेफ है जिसका उपयोग कनेक्शन सी का उपयोग करके एक ट्रांजेक्शनल ऑब्जेक्ट बनाने के लिए किया जाएगा, जो अंततः एसक्यूएल स्टेटमेंट को ट्रांजेक्शनल मोड में निष्पादित करने के लिए उपयोग किया जाएगा। यदि लेन-देन ऑब्जेक्ट सफलतापूर्वक बनाया जाता है, तो इसे चर डब्ल्यू को सौंपा जाता है, जिसका उपयोग ट्रांजेक्शनल ऑब्जेक्ट से संबंधित सार्वजनिक तरीकों तक पहुंचने के लिए किया जाएगा।
5	W.exec(const std::string & sql) Transactional ऑब्जेक्ट से इस सार्वजनिक विधि का उपयोग SQL स्टेटमेंट को निष्पादित करने के लिए किया जाएगा।
6	W.commit() लेन-देन करने के लिए ट्रांजेक्शनल ऑब्जेक्ट से इस सार्वजनिक विधि का उपयोग किया जाएगा।
7	W.abort() लेन-देन को रोलबैक करने के लिए ट्रांजेक्शनल ऑब्जेक्ट से इस सार्वजनिक विधि का उपयोग किया जाएगा।
8	pqxx::nontransaction N( C ) यह एक टाइपसेफ है जिसका उपयोग कनेक्शन सी का उपयोग करके एक गैर-ट्रांजेक्शनल ऑब्जेक्ट बनाने के लिए किया जाएगा, जिसका उपयोग अंततः गैर-लेन-देन मोड में SQL स्टेटमेंट्स को निष्पादित करने के लिए किया जाएगा। यदि लेनदेन ऑब्जेक्ट सफलतापूर्वक बनाया जाता है, तो इसे वेरिएबल एन को सौंपा जाता है जिसका उपयोग गैर-लेन-देन ऑब्जेक्ट से संबंधित सार्वजनिक तरीकों तक पहुंचने के लिए किया जाएगा।
9	N.exec(const std::string & sql) गैर-ट्रांजेक्शनल ऑब्जेक्ट से इस सार्वजनिक विधि का उपयोग SQL स्टेटमेंट को निष्पादित करने के लिए किया जाएगा और एक परिणाम ऑब्जेक्ट लौटाएगा जो वास्तव में सभी लौटाए गए रिकॉर्डों को पकड़े हुए एक इंटरएटर है।

डेटाबेस से जुड़ना

निम्नलिखित सी कोड खंड दिखाता है कि कैसे स्थानीय मशीन पर 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, जो पहले से ही आपके स्कीमा में उपलब्ध है और उपयोगकर्ता पोस्टग्रेज और पासवर्ड पास 123 का उपयोग करके पहुँचा जा सकता है ।

आप अपने डेटाबेस सेटिंग के आधार पर यूजर आईडी और पासवर्ड का उपयोग कर सकते हैं। दिए गए क्रम में -lpqxx और -lpq रखना याद रखें! अन्यथा, लिंकर "पीक्यू" के साथ शुरू होने वाले नामों के लापता कार्यों के बारे में कड़वा शिकायत करेगा।

$g++ test.cpp -lpqxx -lpq $./a.out
Opened database successfully: testdb

एक तालिका बनाएँ

निम्नलिखित सी कोड सेगमेंट का उपयोग पूर्व निर्मित डेटाबेस में एक तालिका बनाने के लिए किया जाएगा -

#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;
}

जब ऊपर दिए गए प्रोग्राम को संकलित और निष्पादित किया जाता है, तो यह आपके testdb डेटाबेस में कंपनी तालिका बनाएगा और निम्नलिखित कथनों को प्रदर्शित करेगा -

Opened database successfully: testdb
Table created successfully

INSERT ऑपरेशन

निम्नलिखित सी कोड खंड दिखाता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका में रिकॉर्ड कैसे बना सकते हैं -

#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;
}

जब ऊपर दिए गए कार्यक्रम को संकलित और निष्पादित किया जाता है, तो यह कंपनी तालिका में दिए गए रिकॉर्ड बनाएगा और निम्नलिखित दो लाइनें प्रदर्शित करेगा -

Opened database successfully: testdb
Records created successfully

ऑपरेशन का चयन करें

निम्नलिखित सी कोड खंड दिखाता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका से रिकॉर्ड कैसे प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं -

#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 स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर कंपनी तालिका 1 से अपडेट रिकॉर्ड प्राप्त और प्रदर्शित कर सकते हैं।

#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

DELETE ऑपरेशन

निम्नलिखित C कोड खंड दिखाता है कि हम किसी भी रिकॉर्ड को हटाने के लिए DELETE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर कंपनी टेबल से शेष रिकॉर्ड प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं -

#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 का उपयोग शुरू करें, हमें यह सुनिश्चित करने की आवश्यकता है कि हमारे पास PostgreSQL JDBC और जावा मशीन पर सेट है। आप अपने मशीन पर जावा इंस्टॉलेशन के लिए जावा ट्यूटोरियल देख सकते हैं। अब हम जाँचते हैं कि PostgreSQL JDBC ड्राइवर कैसे सेट करें।

• का नवीनतम संस्करण डाउनलोड postgresql- (संस्करण) .jdbc.jar से PostgreSQL-JDBC भंडार।

• अपने वर्ग पथ में डाउनलोड की गई जार फ़ाइल पोस्टग्रैक्स्ल- (VERSION) .jdbc.jar जोड़ें या आप उदाहरणों में नीचे बताए अनुसार -क्लासपैथ विकल्प के साथ इसका उपयोग कर सकते हैं।

निम्न अनुभाग मानता है कि आपको जावा JDBC अवधारणाओं के बारे में कम जानकारी है। यदि आपके पास नहीं है, तो नीचे दिए गए अवधारणाओं के साथ सहज होने के लिए JDBC ट्यूटोरियल के साथ आधे घंटे और घंटे बिताने का सुझाव दिया गया है ।

डेटाबेस से जुड़ना

निम्न जावा कोड दिखाता है कि मौजूदा डेटाबेस से कैसे जुड़ा जाए। यदि डेटाबेस मौजूद नहीं है, तो इसे बनाया जाएगा और अंत में एक डेटाबेस ऑब्जेक्ट वापस कर दिया जाएगा।

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

यदि आप निम्नलिखित आदेश का उपयोग करके नहीं चल रहे हैं, तो आप पोस्टग्रेज सर्वर को शुरू / पुनः आरंभ कर सकते हैं -

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

अब, हम testdb से जुड़ने के लिए उपरोक्त प्रोग्राम को संकलित करें और चलाएं। यहां, हम उपयोग कर रहे हैंpostgres उपयोगकर्ता आईडी के रूप में और 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

एक तालिका बनाएँ

पूर्व में खोले गए डेटाबेस में तालिका बनाने के लिए निम्न जावा प्रोग्राम का उपयोग किया जाएगा। सुनिश्चित करें कि आपके लक्ष्य डेटाबेस में पहले से ही यह तालिका नहीं है।

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

जब किसी प्रोग्राम को संकलित और निष्पादित किया जाता है, तो वह कंपनी तालिका बनाएगा testdb डेटाबेस और निम्नलिखित दो लाइनें प्रदर्शित करेगा -

Opened database successfully
Table created successfully

INSERT ऑपरेशन

निम्न जावा प्रोग्राम दिखाता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका में रिकॉर्ड कैसे बना सकते हैं -

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

जब उपरोक्त कार्यक्रम संकलित और निष्पादित किया जाता है, तो यह कंपनी तालिका में दिए गए रिकॉर्ड बनाएगा और निम्नलिखित दो लाइनें प्रदर्शित करेगा -

Opened database successfully
Records created successfully

ऑपरेशन का चयन करें

निम्नलिखित जावा कार्यक्रम दिखाता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका से रिकॉर्ड कैसे प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं -

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

अद्यतन ऑपरेशन

निम्नलिखित जावा कोड दिखाता है कि हम किसी भी रिकॉर्ड को अपडेट करने के लिए UPDATE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर हमारी कंपनी की टेबल से अपडेट किए गए रिकॉर्ड प्राप्त और प्रदर्शित कर सकते हैं -

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

DELETE ऑपरेशन

निम्नलिखित जावा कोड दिखाता है कि हम किसी भी रिकॉर्ड को हटाने के लिए DELETE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर हमारी कंपनी की तालिका से शेष रिकॉर्ड प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं -

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संकलन के समय। फिर भी आप PHP -PostgreSQL इंटरफ़ेस स्थापित करने के लिए yum कमांड का उपयोग कर सकते हैं -

yum install php-pgsql

इससे पहले कि आप PHP PostgreSQL इंटरफ़ेस का उपयोग शुरू करें, खोजें pg_hba.conf अपने PostgreSQL इंस्टॉलेशन डायरेक्टरी में फाइल करें और निम्न लाइन जोड़ें -

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

यदि आप निम्न आदेश का उपयोग करते हुए नहीं चल रहे हैं, तो आप पोस्टग्रेज सर्वर को शुरू / पुनः आरंभ कर सकते हैं -

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

विंडोज उपयोगकर्ताओं को इस एक्सटेंशन का उपयोग करने के लिए php_pgsql.dll सक्षम करना होगा। यह DLL PHP 5.3.x की नवीनतम रिलीज़ में विंडोज वितरण के साथ शामिल है

विस्तृत स्थापना निर्देशों के लिए, कृपया हमारे PHP ट्यूटोरियल और इसकी आधिकारिक वेबसाइट देखें।

PHP इंटरफ़ेस एपीआई

निम्नलिखित महत्वपूर्ण PHP रूटीन हैं, जो आपके PHP प्रोग्राम से PostgreSQL डेटाबेस के साथ काम करने की आपकी आवश्यकता को पूरा कर सकते हैं। यदि आप एक अधिक परिष्कृत आवेदन की तलाश कर रहे हैं, तो आप PHP आधिकारिक दस्तावेज में देख सकते हैं।

एस।	एपीआई और विवरण
1	resource pg_connect ( string $connection_string [, int $connect_type ] ) यह कनेक्शन के द्वारा निर्दिष्ट PostgreSQL डेटाबेस के लिए एक कनेक्शन खोलता है। यदि PGSQL_CONNECT_FORCE_NEW को connect_type के रूप में पास किया जाता है, तो pg_connect () के लिए दूसरी कॉल के मामले में एक नया कनेक्शन बनाया जाता है, भले ही कनेक्शन_string किसी मौजूदा कनेक्शन के समान हो।
2	bool pg_connection_reset ( resource $connection ) यह दिनचर्या कनेक्शन को रीसेट करती है। यह त्रुटि सुधार के लिए उपयोगी है। सफलता पर सही या असफलता पर गलत रिटर्न करता है।
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 क्वेरी से प्रभावित पंक्तियों की संख्या लौटाता है।
1 1	int pg_num_rows ( resource $result ) यह दिनचर्या पोस्टग्रेसीक्यूएल परिणाम संसाधन में पंक्तियों की संख्या का चयन करती है, उदाहरण के लिए सेलेक्ट स्टेटमेंट द्वारा दी गई पंक्तियों की संख्या।
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);
?>

जब ऊपर दिए गए प्रोग्राम को निष्पादित किया जाता है, तो यह आपके में कंपनी तालिका बनाएगा testdb और यह निम्नलिखित संदेश प्रदर्शित करेगा -

Opened database successfully
Table created successfully

INSERT ऑपरेशन

निम्नलिखित 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
      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);
?>

जब ऊपर दिए गए प्रोग्राम को निष्पादित किया जाता है, तो यह कंपनी तालिका में दिए गए रिकॉर्ड बनाएगा और निम्नलिखित दो लाइनें प्रदर्शित करेगा -

Opened database successfully
Records created 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 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 स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर हमारी कंपनी की टेबल से अपडेट किए गए रिकॉर्ड को ला सकते हैं और प्रदर्शित कर सकते हैं -

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

DELETE ऑपरेशन

निम्नलिखित PHP कोड दिखाता है कि हम किसी भी रिकॉर्ड को हटाने के लिए DELETE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर कंपनी के नंबर 1 से शेष रिकॉर्ड प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं

<?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 को पर्ल डीबीआई मॉड्यूल का उपयोग करके पर्ल के साथ एकीकृत किया जा सकता है, जो पर्ल प्रोग्रामिंग भाषा के लिए डेटाबेस एक्सेस मॉड्यूल है। यह कई तरीकों, चर और सम्मेलनों को परिभाषित करता है जो एक मानक डेटाबेस इंटरफ़ेस प्रदान करते हैं।

यहां आपके लिनक्स / यूनिक्स मशीन पर डीबीआई मॉड्यूल स्थापित करने के सरल उपाय दिए गए हैं -

$ 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

यदि आपको DBI के लिए SQLite ड्राइवर स्थापित करने की आवश्यकता है, तो इसे निम्नानुसार स्थापित किया जा सकता है -

$ 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

इससे पहले कि आप पर्ल PostgreSQL इंटरफ़ेस का उपयोग शुरू करें, खोजें pg_hba.conf अपने PostgreSQL इंस्टॉलेशन डायरेक्टरी में फाइल करें और निम्न लाइन जोड़ें -

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

यदि आप निम्न आदेश का उपयोग करते हुए नहीं चल रहे हैं, तो आप पोस्टग्रेज सर्वर को शुरू / पुनः आरंभ कर सकते हैं -

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

DBI इंटरफ़ेस APIs

निम्नलिखित महत्वपूर्ण डीबीआई रूटीन हैं, जो आपके पर्ल प्रोग्राम से SQLite डेटाबेस के साथ काम करने की आवश्यकता को पूरा कर सकते हैं। यदि आप अधिक परिष्कृत आवेदन की तलाश में हैं, तो आप पर्ल डीबीआई के आधिकारिक दस्तावेज देख सकते हैं।

एस।	एपीआई और विवरण
1	DBI→connect($data_source, "userid", "password", \%attr) अनुरोधित $ data_source पर एक डेटाबेस कनेक्शन या सत्र स्थापित करता है। यदि कनेक्शन सफल होता है तो डेटाबेस हैंडल ऑब्जेक्ट लौटाता है। डेटास्रोत के रूप हैं: DBI:Pg:dbname=$database;host=127.0.0.1;port=5432 Pg PostgreSQL ड्राइवर का नाम है और testdb डेटाबेस का नाम है।
2	$dbh→do($sql) यह रूटीन एक एकल एसक्यूएल स्टेटमेंट को तैयार और कार्यान्वित करता है। त्रुटि पर प्रभावित या अपरिभाषित पंक्तियों की संख्या लौटाता है। -1 के रिटर्न मान का मतलब है कि पंक्तियों की संख्या ज्ञात नहीं है, लागू नहीं है, या उपलब्ध नहीं है। यहाँ $ dbh DBI → Connect () कॉल द्वारा लौटाया गया एक हैंडल है।
3	$dbh→prepare($sql) यह रूटीन बाद में डेटाबेस इंजन द्वारा निष्पादन के लिए एक स्टेटमेंट तैयार करता है और एक स्टेटमेंट हैंडल ऑब्जेक्ट का संदर्भ देता है।
4	$sth→execute() यह दिनचर्या तैयार विवरण को निष्पादित करने के लिए जो भी प्रसंस्करण आवश्यक है, करती है। यदि कोई त्रुटि होती है तो एक अपरिभाषित लौटा दिया जाता है। एक सफल निष्पादन हमेशा प्रभावित पंक्तियों की संख्या की परवाह किए बिना सही रिटर्न देता है। यहाँ$sth is a statement handle returned by $dbh → तैयार ($ sql) कॉल।
5	$sth→fetchrow_array() यह दिनचर्या डेटा की अगली पंक्ति लाती है और इसे फ़ील्ड मानों की सूची के रूप में लौटाती है। सूची में अशक्त मानों के रूप में अशक्त फ़ील्ड वापस कर दिए जाते हैं।
6	$DBI::err यह $ h → इरेट के बराबर है, जहां $h is any of the handle types like $DBH, $sth, or $मानव संसाधन निदेशक। यह कहा जाता है पिछले ड्राइवर विधि से मूल डेटाबेस इंजन त्रुटि कोड देता है।
7	$DBI::errstr यह $ ज के समान है → असतत, जहाँ $h is any of the handle types like $DBH, $sth, or $मानव संसाधन निदेशक। यह मूल डेटाबेस इंजन त्रुटि संदेश को अंतिम DBI विधि से लौटाता है जिसे कहा जाता है।
8	$dbh->disconnect() यह रूटीन DBI → कनेक्ट () से कॉल द्वारा खोले गए डेटाबेस कनेक्शन को बंद कर देता है।

डेटाबेस से जुड़ना

निम्न पर्ल कोड दिखाता है कि मौजूदा डेटाबेस से कैसे जुड़ा जाए। यदि डेटाबेस मौजूद नहीं है, तो इसे बनाया जाएगा और अंत में एक डेटाबेस ऑब्जेक्ट वापस कर दिया जाएगा।

#!/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

एक तालिका बनाएँ

पहले बनाए गए डेटाबेस में एक तालिका बनाने के लिए निम्नलिखित पर्ल प्रोग्राम का उपयोग किया जाएगा -

#!/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();

जब ऊपर दिए गए प्रोग्राम को निष्पादित किया जाता है, तो यह आपके में कंपनी तालिका बनाएगा testdb और यह निम्नलिखित संदेश प्रदर्शित करेगा -

Opened database successfully
Table created successfully

INSERT ऑपरेशन

निम्नलिखित पर्ल कार्यक्रम से पता चलता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका में रिकॉर्ड कैसे बना सकते हैं -

#!/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();

जब ऊपर दिए गए प्रोग्राम को निष्पादित किया जाता है, तो यह कंपनी तालिका में दिए गए रिकॉर्ड बनाएगा और निम्नलिखित दो लाइनें प्रदर्शित करेगा -

Opened database successfully
Records created successfully

ऑपरेशन का चयन करें

निम्नलिखित पर्ल कार्यक्रम दिखाता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका से रिकॉर्ड कैसे प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं -

#!/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

अद्यतन ऑपरेशन

निम्नलिखित पर्ल कोड दिखाता है कि हम किसी भी रिकॉर्ड को अपडेट करने के लिए UPDATE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर कंपनी के नंबर 1 से अपडेट रिकॉर्ड प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं।

#!/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

DELETE ऑपरेशन

निम्न पर्ल कोड दिखाता है कि हम किसी भी रिकॉर्ड को हटाने के लिए DELETE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर किसी कंपनी कंपनी से शेष रिकॉर्ड प्राप्त और प्रदर्शित कर सकते हैं -

#!/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 psycopg2 मॉड्यूल का उपयोग करके पायथन के साथ एकीकृत किया जा सकता है। sycopg2 पायथन प्रोग्रामिंग भाषा के लिए एक PostgreSQL डेटाबेस एडाप्टर है। psycopg2 को बहुत छोटा और तेज, और चट्टान के रूप में स्थिर होने के उद्देश्य से लिखा गया था। आपको इस मॉड्यूल को अलग से स्थापित करने की आवश्यकता नहीं है, क्योंकि यह डिफ़ॉल्ट रूप से, अजगर संस्करण 2.5.x के साथ भेज दिया गया है।

यदि आपके पास यह आपके मशीन पर स्थापित नहीं है तो आप इसे निम्नानुसार स्थापित करने के लिए yum कमांड का उपयोग कर सकते हैं -

$yum install python-psycopg2

Psycopg2 मॉड्यूल का उपयोग करने के लिए, आपको पहले एक कनेक्शन ऑब्जेक्ट बनाना होगा जो डेटाबेस का प्रतिनिधित्व करता है और फिर वैकल्पिक रूप से आप कर्सर ऑब्जेक्ट बना सकते हैं जो आपको सभी एसक्यूएल स्टेटमेंट को निष्पादित करने में मदद करेगा।

पायथन psycopg2 मॉड्यूल एपीआई

निम्नलिखित महत्वपूर्ण psycopg2 मॉड्यूल रूटीन हैं, जो आपके Pyonon प्रोग्राम से PostgreSQL डेटाबेस के साथ काम करने की आवश्यकता को पूरा कर सकते हैं। यदि आप एक अधिक परिष्कृत अनुप्रयोग की तलाश कर रहे हैं, तो आप पायथन psycopg2 मॉड्यूल के आधिकारिक दस्तावेज में देख सकते हैं।

एस।	एपीआई और विवरण
1	psycopg2.connect(database="testdb", user="postgres", password="cohondob", host="127.0.0.1", port="5432") यह API PostgreSQL डेटाबेस के लिए एक कनेक्शन खोलता है। यदि डेटाबेस सफलतापूर्वक खोला गया है, तो यह कनेक्शन ऑब्जेक्ट लौटाता है।
2	connection.cursor() यह रूटीन बनाता है cursor जिसका उपयोग आपके पूरे डेटाबेस प्रोग्रामिंग में पायथन के साथ किया जाएगा।
3	cursor.execute(sql [, optional parameters]) यह रूटीन SQL कथन निष्पादित करता है। SQL स्टेटमेंट को पैरामीटरेट किया जा सकता है (यानी, एसक्यूएल शाब्दिक के बजाय प्लेसहोल्डर)। Psycopg2 मॉड्यूल% s साइन का उपयोग करके प्लेसहोल्डर का समर्थन करता है उदाहरण के लिए: RPG.execute ("लोगों के मानों में डालें (% s,% s)", (जो, आयु)
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() यह विधि एक क्वेरी अनुक्रम सेट की अगली पंक्ति लाती है, एक एकल अनुक्रम लौटाती है, या जब कोई अधिक डेटा उपलब्ध नहीं होता है।
1 1	cursor.fetchmany([size=cursor.arraysize]) यह दिनचर्या एक प्रश्न परिणाम की पंक्तियों के अगले सेट को लाती है, एक सूची लौटाती है। कोई और पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है। विधि आकार पैरामीटर द्वारा इंगित के रूप में कई पंक्तियों को लाने की कोशिश करती है।
12	cursor.fetchall() यह रूटीन एक सूची में, किसी क्वेरी परिणाम की सभी (शेष) पंक्तियों को लाती है। कोई पंक्तियाँ उपलब्ध नहीं होने पर एक खाली सूची दी जाती है।

डेटाबेस से जुड़ना

निम्नलिखित पायथन कोड दिखाता है कि मौजूदा डेटाबेस से कैसे जुड़ा जाए। यदि डेटाबेस मौजूद नहीं है, तो इसे बनाया जाएगा और अंत में एक डेटाबेस ऑब्जेक्ट वापस कर दिया जाएगा।

#!/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

एक तालिका बनाएँ

निम्नलिखित पायथन कार्यक्रम का उपयोग पहले से निर्मित डेटाबेस में एक तालिका बनाने के लिए किया जाएगा -

#!/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()

जब ऊपर दिए गए प्रोग्राम को निष्पादित किया जाता है, तो यह आपके में कंपनी तालिका बनाएगा test.db और यह निम्नलिखित संदेश प्रदर्शित करेगा -

Opened database successfully
Table created successfully

INSERT ऑपरेशन

निम्नलिखित पायथन कार्यक्रम दिखाता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका में रिकॉर्ड कैसे बना सकते हैं -

#!/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()

जब ऊपर दिए गए प्रोग्राम को निष्पादित किया जाता है, तो यह कंपनी तालिका में दिए गए रिकॉर्ड बनाएगा और निम्नलिखित दो लाइनें प्रदर्शित करेगा -

Opened database successfully
Records created successfully

ऑपरेशन का चयन करें

निम्नलिखित पायथन कार्यक्रम से पता चलता है कि हम उपरोक्त उदाहरण में बनाई गई हमारी कंपनी तालिका से रिकॉर्ड कैसे प्राप्त और प्रदर्शित कर सकते हैं -

#!/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

अद्यतन ऑपरेशन

निम्नलिखित पायथन कोड से पता चलता है कि हम किसी भी रिकॉर्ड को अपडेट करने के लिए UPDATE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर किसी कंपनी कंपनी से अपडेट रिकॉर्ड प्राप्त और प्रदर्शित कर सकते हैं -

#!/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

DELETE ऑपरेशन

निम्नलिखित पायथन कोड दिखाता है कि हम किसी भी रिकॉर्ड को हटाने के लिए DELETE स्टेटमेंट का उपयोग कैसे कर सकते हैं और फिर अपनी कंपनी तालिका से शेष रिकॉर्ड प्राप्त कर सकते हैं और प्रदर्शित कर सकते हैं -

#!/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