उम्मीदवार कुंजी: Difference between revisions

Revision as of 14:41, 22 February 2023

एक संबंध स्कीमा की उम्मीदवार कुंजी, या बस एक कुंजी, एक न्यूनतम key है।^[1] दूसरे शब्दों में, यह स्तंभों का कोई भी सेट है जिसमें प्रत्येक पंक्ति में मानों का एक अनूठा संयोजन होता है (जो इसे एक सुपरकी बनाता है), अतिरिक्त बाधा के साथ कि किसी भी कॉलम को हटाने से मानों के डुप्लिकेट संयोजन उत्पन्न हो सकते हैं (जो इसे न्यूनतम सुपरकी बनाता है) .

विशिष्ट उम्मीदवार कुंजियों को कभी-कभी प्राथमिक कुंजी, द्वितीयक कुंजी या वैकल्पिक कुंजी कहा जाता है।

कैंडिडेट की में कॉलम को प्राइम एट्रिब्यूट कहा जाता है,^[2] और एक कॉलम जो किसी उम्मीदवार कुंजी में नहीं होता है उसे गैर-प्रमुख विशेषता कहा जाता है।

NULL मानों के बिना प्रत्येक संबंध में कम से कम एक उम्मीदवार कुंजी होगी: चूँकि डुप्लिकेट पंक्तियाँ नहीं हो सकती हैं, सभी स्तंभों का सेट एक सुपरकी है, और यदि वह न्यूनतम नहीं है, तो उसका कुछ सबसेट न्यूनतम होगा।

संबंध में सभी विशेषताओं के लिए उम्मीदवार कुंजी से एक कार्यात्मक निर्भरता है।

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

उदाहरण

उम्मीदवार कुंजियों की परिभाषा को निम्नलिखित (सार) उदाहरण के साथ चित्रित किया जा सकता है। विशेषताओं (ए, बी, सी, डी) के साथ एक रिलेशन वेरिएबल (रिलेवर) आर पर विचार करें जिसमें केवल निम्नलिखित दो कानूनी मूल्य आर 1 और आर 2 हैं:

r1
A	B	C	D
a1	b1	c1	d1
a1	b2	c2	d1
a2	b1	c2	d1

r2
A	B	C	D
a1	b1	c1	d1
a1	b2	c2	d1
a1	b1	c2	d2

यहाँ r2 केवल अंतिम tuple के 'A' और 'D' मानों में r1 से भिन्न है।

r1 के लिए निम्नलिखित सेटों में विशिष्टता गुण है, अर्थात, सेट में समान विशेषता मानों के साथ उदाहरण में दो अलग-अलग टुपल्स नहीं हैं:

{A,B}, {A,C}, {B,C}, {A,B,C}, {A,B,D}, {A,C,D}, {B,C,D}, {A,B,C,D}

r2 के लिए अद्वितीयता संपत्ति निम्नलिखित सेटों के लिए है;

{B,C}, {B,D}, {C,D}, {A,B,C}, {A,B,D}, {A,C,D}, {B,C,D}, {A,B,C,D}

चूंकि एक रिल्वर की सुपरकीज़ उन विशेषताओं के सेट हैं जिनके पास उस रिल्वर के सभी कानूनी मूल्यों के लिए विशिष्टता संपत्ति है और क्योंकि हम मानते हैं कि आर 1 और आर 2 सभी कानूनी मूल्य हैं जो आर ले सकते हैं, हम आर के सुपरकीज़ के सेट को निर्धारित कर सकते हैं दो सूचियों का प्रतिच्छेदन लेना:

{B,C}, {A,B,C}, {A,B,D}, {A,C,D}, {B,C,D}, {A,B,C,D}

अंत में हमें उन सेटों का चयन करने की आवश्यकता है जिनके लिए सूची में कोई उपसमुच्चय#उचित उपसमुच्चय नहीं है, जो इस मामले में हैं:

{B,C}, {A,B,D}, {A,C,D}

ये वास्तव में रिल्वर आर की उम्मीदवार कुंजी हैं।

हमें उन सभी संबंधों पर विचार करना होगा जो यह निर्धारित करने के लिए एक रिलेवर को सौंपे जा सकते हैं कि क्या विशेषताओं का एक निश्चित सेट एक उम्मीदवार कुंजी है। उदाहरण के लिए, यदि हमने केवल r1 पर विचार किया होता तो हम यह निष्कर्ष निकालते कि {A,B} एक उम्मीदवार कुंजी है, जो गलत है। हालाँकि, हम इस तरह के संबंध से यह निष्कर्ष निकालने में सक्षम हो सकते हैं कि एक निश्चित सेट एक उम्मीदवार कुंजी नहीं है, क्योंकि उस सेट में अद्वितीयता गुण नहीं है (उदाहरण के लिए {A,D} r1 के लिए)। ध्यान दें कि एक सेट के उचित उपसमुच्चय का अस्तित्व जिसमें अद्वितीयता संपत्ति है, को सामान्य तौर पर सबूत के रूप में इस्तेमाल नहीं किया जा सकता है कि सुपरसेट एक उम्मीदवार कुंजी नहीं है। विशेष रूप से, ध्यान दें कि एक खाली संबंध के मामले में, शीर्षक के प्रत्येक उपसमुच्चय में खाली सेट सहित अद्वितीयता गुण होता है।

उम्मीदवार कुंजियों का निर्धारण

सभी उम्मीदवार कुंजियों के सेट की गणना की जा सकती है उदा. कार्यात्मक निर्भरता के सेट से। इसके लिए हमें एट्रिब्यूट क्लोजर को परिभाषित करने की आवश्यकता है $\alpha +$ एक विशेषता सेट के लिए $\alpha$ . सेट $\alpha ^{+}$ इसमें वे सभी विशेषताएँ शामिल हैं जो कार्यात्मक रूप से निहित हैं $\alpha$ .

एकल उम्मीदवार कुंजी खोजना काफी सरल है।

हम एक सेट से शुरू करते हैं $\alpha$ विशेषताओं का और क्रमिक रूप से प्रत्येक विशेषता को निकालने का प्रयास करें।

यदि किसी एट्रिब्यूट को हटाने के बाद एट्रिब्यूट क्लोजर समान रहता है,

तब यह विशेषता आवश्यक नहीं है और हम इसे स्थायी रूप से हटा सकते हैं। हम परिणाम कहते हैं ${\text{minimize}}(\alpha )$ .

अगर $\alpha$ सभी गुणों का समुच्चय है,

तब ${\text{minimize}}(\alpha )$ उम्मीदवार कुंजी है।

वास्तव में हम इस प्रक्रिया से प्रत्येक उम्मीदवार कुंजी का पता लगा सकते हैं

विशेषताओं को हटाने के हर संभव क्रम का प्रयास करके।

हालाँकि विशेषताओं के कई और क्रमपरिवर्तन हैं ( $n!$ ) सत्ता स्थापित से ( $2^{n}$ ).

यही है, कई विशेषता आदेश एक ही उम्मीदवार कुंजी की ओर ले जाएंगे।

उम्मीदवार कुंजी संगणना के लिए कुशल एल्गोरिदम के लिए मूलभूत कठिनाई है: कार्यात्मक निर्भरताओं के कुछ सेट तेजी से कई उम्मीदवार कुंजी की ओर ले जाते हैं।

इसपर विचार करें $2\cdot n$ कार्यात्मक निर्भरता

$\{A_{i}\rightarrow B_{i}:i\in \{1,\dots ,n\}\}\cup \{B_{i}\rightarrow A_{i}:i\in \{1,\dots ,n\}\}$

कौन सी पैदावार $2^{n}$ उम्मीदवार कुंजी:

$\{A_{1},B_{1}\}\times \dots \times \{A_{n},B_{n}\}$ .

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

निम्नलिखित एल्गोरिदम वास्तव में उम्मीदवार कुंजी और कार्यात्मक निर्भरताओं की संख्या में बहुपद समय में चलता है:^[3]

समारोह find_candidate_keys (ए, एफ)

function find_candidate_keys(A, F)
    /* A is the set of all attributes and F is the set of functional dependencies */
    K[0] := minimize(A);
    n := 1; /* Number of Keys known so far */
    i := 0; /* Currently processed key */
    while i < n do
        for each α → β ∈ F do
            /* Build a new potential key from the previous known key and the current FD */
            S := α ∪ (K[i] − β);
            /* Search whether the new potential key is part of the already known keys */ 
            found := false;
            for j := 0 to n-1 do
                if K[j] ⊆ S then found := true;
            /* If not, add if 
            if not found then
                K[n] := minimize(S);
                n := n + 1;
        i := i + 1
    return K

    /* A is the set of all attributes and F is the set of functional dependencies */
    K[0] := minimize(A);
    n := 1; /* Number of Keys known so far */
    i := 0; /* Currently processed key */
    while i < n do
        for each α → β ∈ F do
            /* Build a new potential key from the previous known key and the current FD */
            S := α ∪ (K[i] − β);
            /* Search whether the new potential key is part of the already known keys */ 
            found := false;
            for j := 0 to n-1 do
                if K[j] ⊆ S then found := true;
            /* If not, add if 
            if not found then
                K[n] := minimize(S);
                n := n + 1;
        i := i + 1
    return K

एल्गोरिदम के पीछे विचार यह है कि एक उम्मीदवार कुंजी दी गई है $K_{i}$ और एक कार्यात्मक निर्भरता $\alpha \rightarrow \beta$ , कार्यात्मक निर्भरता पैदावार का उल्टा अनुप्रयोग सेट $\alpha \cup (K_{i}\setminus \beta )$ , जो एक कुंजी भी है। हालाँकि यह अन्य पहले से ज्ञात उम्मीदवार कुंजियों द्वारा कवर किया जा सकता है। (एल्गोरिदम 'पाया' चर का उपयोग करके इस मामले की जांच करता है।) यदि नहीं, तो नई कुंजी को न्यूनतम करने से एक नई उम्मीदवार कुंजी प्राप्त होती है। मुख्य अंतर्दृष्टि यह है कि सभी उम्मीदवार कुंजी इस तरह से बनाई जा सकती हैं।

यह भी देखें

वैकल्पिक कुंजी
यौगिक कुंजी
डेटाबेस सामान्यीकरण
प्राथमिक कुंजी
संबंध का डेटाबेस
सुपरकी
प्रधान शामिल है बूलियन तर्क में कैंडिडेट की की संबंधित धारणा है

संदर्भ

↑ Date, Christopher (2015). "Codd's First Relational Papers: A Critical Analysis" (PDF). warwick.ac.uk. Retrieved 2020-01-04. Note that the extract allows a "relation" to have any number of primary keys, and moreover that such keys are allowed to be "redundant" (better: reducible). In other words, what the paper calls a primary key is what later (and better) became known as a superkey, and what the paper calls a nonredundant (better: irreducible) primary key is what later became known as a candidate key or (better) just a key.
↑ Saiedian, H. (1996-02-01). "An Efficient Algorithm to Compute the Candidate Keys of a Relational Database Schema". The Computer Journal (in English). 39 (2): 124–132. doi:10.1093/comjnl/39.2.124. ISSN 0010-4620.
↑ L. Lucchesi, Cláudio; Osborn, Sylvia L. (October 1978). "Candidate keys for relations". Journal of Computer and System Sciences. 17 (2): 270–279. doi:10.1016/0022-0000(78)90009-0.

Date, Christopher (2003). "5: Integrity". An Introduction to Database Systems. Addison-Wesley. pp. 268–276. ISBN 978-0-321-18956-1.

बाहरी संबंध

Relational Database Management Systems - Database Design - Terms of Reference - Keys: An overview of the different types of keys in the RDBMS (Relational Database Management System).

[1] Date, Christopher (2015). "Codd's First Relational Papers: A Critical Analysis" (PDF). warwick.ac.uk. Retrieved 2020-01-04. Note that the extract allows a "relation" to have any number of primary keys, and moreover that such keys are allowed to be "redundant" (better: reducible). In other words, what the paper calls a primary key is what later (and better) became known as a superkey, and what the paper calls a nonredundant (better: irreducible) primary key is what later became known as a candidate key or (better) just a key.

[2] Saiedian, H. (1996-02-01). "An Efficient Algorithm to Compute the Candidate Keys of a Relational Database Schema". The Computer Journal (in English). 39 (2): 124–132. doi:10.1093/comjnl/39.2.124. ISSN 0010-4620.

[3] L. Lucchesi, Cláudio; Osborn, Sylvia L. (October 1978). "Candidate keys for relations". Journal of Computer and System Sciences. 17 (2): 270–279. doi:10.1016/0022-0000(78)90009-0.

[1]

[2]

[3]

@@ Line 63: / Line 63: @@
 यहाँ r2 केवल अंतिम tuple के 'A' और 'D' मानों में r1 से भिन्न है।
-R1 के लिए निम्नलिखित सेटों में विशिष्टता गुण है, अर्थात, सेट में समान विशेषता मानों के साथ उदाहरण में दो अलग-अलग टुपल्स नहीं हैं:
+''r1'' के लिए निम्नलिखित सेटों में विशिष्टता गुण है, अर्थात, सेट में समान विशेषता मानों के साथ उदाहरण में दो अलग-अलग टुपल्स नहीं हैं:
-: {ए, बी}, {ए, सी}, {बी, सी}, {ए, बी, सी}, {ए, बी, डी}, {ए, सी, डी}, {बी, सी, डी} , {ए बी सी डी}
+: {A,B}, {A,C}, {B,C}, {A,B,C}, {A,B,D}, {A,C,D}, {B,C,D}, {A,B,C,D}
-R2 के लिए अद्वितीयता संपत्ति निम्नलिखित सेटों के लिए है;
+''r2'' के लिए अद्वितीयता संपत्ति निम्नलिखित सेटों के लिए है;
-: {बी, सी}, {बी, डी}, {सी, डी}, {ए, बी, सी}, {ए, बी, डी}, {ए, सी, डी}, {बी, सी, डी} , {ए बी सी डी}
+: {B,C}, {B,D}, {C,D}, {A,B,C}, {A,B,D}, {A,C,D}, {B,C,D}, {A,B,C,D}
 चूंकि एक रिल्वर की सुपरकीज़ उन विशेषताओं के सेट हैं जिनके पास उस रिल्वर के सभी कानूनी मूल्यों के लिए विशिष्टता संपत्ति है और क्योंकि हम मानते हैं कि आर 1 और आर 2 सभी कानूनी मूल्य हैं जो आर ले सकते हैं, हम आर के सुपरकीज़ के सेट को निर्धारित कर सकते हैं दो सूचियों का प्रतिच्छेदन लेना:
-: {बी, सी}, {ए, बी, सी}, {ए, बी, डी}, {ए, सी, डी}, {बी, सी, डी}, {ए, बी, सी, डी}
+: {B,C}, {A,B,C}, {A,B,D}, {A,C,D}, {B,C,D}, {A,B,C,D}
 अंत में हमें उन सेटों का चयन करने की आवश्यकता है जिनके लिए सूची में कोई उपसमुच्चय#उचित उपसमुच्चय नहीं है, जो इस मामले में हैं:
-: {बी, सी}, {ए, बी, डी}, {ए, सी, डी}
+: {B,C}, {A,B,D}, {A,C,D}
 ये वास्तव में रिल्वर आर की उम्मीदवार कुंजी हैं।
@@ Line 83: / Line 83: @@
 एकल उम्मीदवार कुंजी खोजना काफी सरल है।
 हम एक सेट से शुरू करते हैं <math>\alpha</math> विशेषताओं का और क्रमिक रूप से प्रत्येक विशेषता को निकालने का प्रयास करें।
 यदि किसी एट्रिब्यूट को हटाने के बाद एट्रिब्यूट क्लोजर समान रहता है,
 तब यह विशेषता आवश्यक नहीं है और हम इसे स्थायी रूप से हटा सकते हैं।
 हम परिणाम कहते हैं <math>\text{minimize}(\alpha)</math>.
 अगर <math>\alpha</math> सभी गुणों का समुच्चय है,
 तब <math>\text{minimize}(\alpha)</math> उम्मीदवार कुंजी है।
 वास्तव में हम इस प्रक्रिया से प्रत्येक उम्मीदवार कुंजी का पता लगा सकते हैं
 विशेषताओं को हटाने के हर संभव क्रम का प्रयास करके।
 हालाँकि विशेषताओं के कई और क्रम[[परिवर्तन]] हैं (<math>n!</math>)
 [[सत्ता स्थापित]] से (<math>2^n</math>).
 यही है, कई विशेषता आदेश एक ही उम्मीदवार कुंजी की ओर ले जाएंगे।
 उम्मीदवार कुंजी संगणना के लिए कुशल एल्गोरिदम के लिए मूलभूत कठिनाई है:
 कार्यात्मक निर्भरताओं के कुछ सेट तेजी से कई उम्मीदवार कुंजी की ओर ले जाते हैं।
 इसपर विचार करें <math>2\cdot n</math> कार्यात्मक निर्भरता
 <math>\{A_i \rightarrow B_i : i\in\{1,\dots,n\}\} \cup \{B_i \rightarrow A_i : i\in\{1,\dots,n\}\}</math>
 कौन सी पैदावार <math>2^n</math> उम्मीदवार कुंजी:
 <math>\{A_1, B_1\} \times \dots \times \{A_n, B_n\}</math>.
 यही है, हम सबसे अच्छी उम्मीद कर सकते हैं कि एक एल्गोरिदम है जो उम्मीदवार कुंजी की संख्या के संबंध में कुशल है।
@@ Line 120: / Line 133: @@
   }}
 </ref>
-समारोह find_candidate_keys (ए, एफ)
-      /* A सभी विशेषताओं का सेट है और F कार्यात्मक निर्भरताओं का सेट है */
+समारोह find_candidate_keys (ए, एफ)<syntaxhighlight>
-      के [0]: = कम से कम (ए);
+function find_candidate_keys(A, F)
-      एन: = 1; /* अब तक ज्ञात चाबियों की संख्या */
+    /* A is the set of all attributes and F is the set of functional dependencies */
-      मैं: = 0; / * वर्तमान में संसाधित कुंजी * /
+    K[0] := minimize(A);
-      जबकि मैं <n करते हैं
+    n := 1; /* Number of Keys known so far */
-          प्रत्येक के लिए α → β ∈ F करते हैं
+    i := 0; /* Currently processed key */
-              /* पिछली ज्ञात कुंजी और वर्तमान FD से एक नई संभावित कुंजी बनाएँ */
+    while i < n do
-              एस: = α ∪ (के [i] - β);
+        for each α → β ∈ F do
-              /* खोजें कि क्या नई संभावित कुंजी पहले से ज्ञात कुंजियों का हिस्सा है */
+            /* Build a new potential key from the previous known key and the current FD */
-              मिला : = असत्य;
+            S := α ∪ (K[i] − β);
-              j के लिए := 0 से n-1 करते हैं
+            /* Search whether the new potential key is part of the already known keys */
-                  अगर के [जे] ⊆ एस तो पाया गया: = सच;
+            found := false;
-              /* यदि नहीं, तो जोड़ें
+            for j := 0 to n-1 do
-              अगर नहीं मिला तो
+                if K[j] ⊆ S then found := true;
-                  के [एन] : = कम से कम (एस);
+            /* If not, add if
-                  एन := एन + 1;
+            if not found then
-          मैं: = मैं + 1
+                K[n] := minimize(S);
-      वापसी के
+                n := n + 1;
+        i := i + 1
+    return K
+</syntaxhighlight>
+      /* A is the set of all attributes and F is the set of functional dependencies */
+      K[0] := minimize(A);
+      n := 1; /* Number of Keys known so far */
+      i := 0; /* Currently processed key */
+      '''while''' i < n '''do'''
+          '''for each''' α → β ∈ F '''do'''
+              /* Build a new potential key from the previous known key and the current FD */
+              S := α ∪ (K[i] − β);
+              /* Search whether the new potential key is part of the already known keys */
+              found := false;
+              '''for''' j := 0 to n-1 '''do'''
+                  '''if''' K[j] ⊆ S '''then''' found := true;
+              /* If not, add if
+              '''if''' '''not''' found '''then'''
+                  K[n] := minimize(S);
+                  n := n + 1;
+          i := i + 1
+      '''return''' K
 एल्गोरिदम के पीछे विचार यह है कि एक उम्मीदवार कुंजी दी गई है <math>K_i</math>

v t e Database management systems
Types	Object-oriented comparison Relational list comparison Key–value Column-oriented list Document-oriented Wide-column store Graph NoSQL NewSQL In-memory list Multi-model comparison Cloud Blockchain-based database
Concepts	Database ACID Armstrong's axioms Codd's 12 rules CAP theorem CRUD Null Candidate key Foreign key Superkey Surrogate key Unique key
Objects	Relation table column row View Transaction Transaction log Trigger Index Stored procedure Cursor Partition
Components	Concurrency control Data dictionary JDBC XQJ ODBC Query language Query optimizer Query rewriting system Query plan
Functions	Administration Query optimization Replication Sharding
Related topics	Database models Database normalization Database storage Distributed database Federated database system Referential integrity Relational algebra Relational calculus Relational model Object–relational database Transaction processing
Category Outline WikiProject

Anonymous

Search

उम्मीदवार कुंजी: Difference between revisions

Namespaces

More

Page actions

Revision as of 14:41, 22 February 2023

Contents

उदाहरण

उम्मीदवार कुंजियों का निर्धारण

यह भी देखें

संदर्भ

बाहरी संबंध

Navigation

Navigation

Wiki tools

Wiki tools

Anonymous

Search

उम्मीदवार कुंजी: Difference between revisions

Revision as of 14:41, 22 February 2023

उदाहरण

उम्मीदवार कुंजियों का निर्धारण

यह भी देखें

संदर्भ

बाहरी संबंध

Navigation

Wiki tools

Page tools

Other projects

Categories