दो संभावित तालिकाओं में से एक के लिए MySQL विदेशी कुंजी करना संभव है?

180

यहाँ मेरी समस्या है, मेरे पास तीन टेबल हैं; क्षेत्र, देश, राज्य। देश क्षेत्रों के अंदर हो सकते हैं, राज्य क्षेत्रों के अंदर हो सकते हैं। क्षेत्र खाद्य श्रृंखला में सबसे ऊपर हैं।

अब मैं दो कॉलम के साथ एक popular_areas टेबल जोड़ रहा हूं; Region_id और popular_place_id। क्या popular_place_id को या तो देशों या राज्यों के लिए एक विदेशी कुंजी बनाना संभव है। मैं शायद यह बताने के लिए एक लोकप्रिय_प्ले_टाइप कॉलम जोड़ने जा रहा हूं कि आईडी किसी देश या राज्य का वर्णन कर रही है या नहीं।

mysql polymorphic-associations

— एंड्रयू जी जॉनसन
स्रोत

282

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

CREATE TABLE popular_places (
  user_id INT NOT NULL,
  place_id INT NOT NULL,
  place_type VARCHAR(10) -- either 'states' or 'countries'
  -- foreign key is not possible
);

SQL बाधाओं का उपयोग करके पॉलीमॉर्फिक एसोसिएशन को मॉडल करने का कोई तरीका नहीं है। एक विदेशी कुंजी बाधा हमेशा एक लक्ष्य तालिका का संदर्भ देती है ।

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

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

यहां कुछ वैकल्पिक समाधान दिए गए हैं जो डेटाबेस-लागू संदर्भात्मक अखंडता का लाभ उठाते हैं:

प्रति लक्ष्य एक अतिरिक्त तालिका बनाएं। उदाहरण के लिए popular_statesऔर popular_countries, जो संदर्भ statesऔर countriesक्रमशः। इन "लोकप्रिय" तालिकाओं में से प्रत्येक उपयोगकर्ता की प्रोफ़ाइल को भी संदर्भित करता है।

CREATE TABLE popular_states (
  state_id INT NOT NULL,
  user_id  INT NOT NULL,
  PRIMARY KEY(state_id, user_id),
  FOREIGN KEY (state_id) REFERENCES states(state_id),
  FOREIGN KEY (user_id) REFERENCES users(user_id),
);

CREATE TABLE popular_countries (
  country_id INT NOT NULL,
  user_id    INT NOT NULL,
  PRIMARY KEY(country_id, user_id),
  FOREIGN KEY (country_id) REFERENCES countries(country_id),
  FOREIGN KEY (user_id) REFERENCES users(user_id),
);

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

placesसुपरटेबल के रूप में एक टेबल बनाएं । जैसा कि अबी का उल्लेख है, एक दूसरा विकल्प यह है कि आपके लोकप्रिय स्थान एक तालिका का संदर्भ देते हैं places, जो दोनों के लिए एक माता-पिता है statesऔर countries। यही है, दोनों राज्यों और देशों के पास एक विदेशी कुंजी भी है places(आप इस विदेशी कुंजी को प्राथमिक कुंजी भी बना सकते हैं statesऔर countries)।

CREATE TABLE popular_areas (
  user_id INT NOT NULL,
  place_id INT NOT NULL,
  PRIMARY KEY (user_id, place_id),
  FOREIGN KEY (place_id) REFERENCES places(place_id)
);

CREATE TABLE states (
  state_id INT NOT NULL PRIMARY KEY,
  FOREIGN KEY (state_id) REFERENCES places(place_id)
);

CREATE TABLE countries (
  country_id INT NOT NULL PRIMARY KEY,
  FOREIGN KEY (country_id) REFERENCES places(place_id)
);

दो कॉलम का उपयोग करें। एक स्तंभ के बजाय जो दो लक्ष्य तालिकाओं का संदर्भ दे सकता है, दो स्तंभों का उपयोग करें। ये दो स्तंभ हो सकते हैं NULL; वास्तव में उनमें से केवल एक गैर होना चाहिए NULL।

CREATE TABLE popular_areas (
  place_id SERIAL PRIMARY KEY,
  user_id INT NOT NULL,
  state_id INT,
  country_id INT,
  CONSTRAINT UNIQUE (user_id, state_id, country_id), -- UNIQUE permits NULLs
  CONSTRAINT CHECK (state_id IS NOT NULL OR country_id IS NOT NULL),
  FOREIGN KEY (state_id) REFERENCES places(place_id),
  FOREIGN KEY (country_id) REFERENCES places(place_id)
);

संबंधपरक सिद्धांत के संदर्भ में, पॉलीमॉर्फिक एसोसिएशन फर्स्ट नॉर्मल फॉर्म का उल्लंघन करता है , क्योंकि popular_place_idयह दो अर्थों के साथ एक कॉलम है: यह या तो एक राज्य या एक देश है। आप एक व्यक्ति की दुकान नहीं होगा ageऔर उनके phone_numberएक एकल स्तंभ में, और एक ही कारण के लिए आप दोनों की दुकान नहीं करना चाहिए state_idऔर country_idएक एकल स्तंभ में। तथ्य यह है कि इन दो विशेषताओं में संगत डेटा प्रकार हैं संयोग; वे अभी भी विभिन्न तार्किक संस्थाओं का संकेत देते हैं।

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

@SavasVedova से पुनः टिप्पणी करें:

मुझे यकीन नहीं है कि मैं टेबल की परिभाषा या एक उदाहरण के प्रश्न को देखे बिना आपके विवरण का अनुसरण करता हूं, लेकिन ऐसा लगता है कि आपके पास बस एक से अधिक Filtersटेबल हैं, प्रत्येक में एक विदेशी कुंजी है जो एक केंद्रीय Productsतालिका का संदर्भ देती है ।

CREATE TABLE Products (
  product_id INT PRIMARY KEY
);

CREATE TABLE FiltersType1 (
  filter_id INT PRIMARY KEY,
  product_id INT NOT NULL,
  FOREIGN KEY (product_id) REFERENCES Products(product_id)
);

CREATE TABLE FiltersType2 (
  filter_id INT  PRIMARY KEY,
  product_id INT NOT NULL,
  FOREIGN KEY (product_id) REFERENCES Products(product_id)
);

...and other filter tables...

उत्पादों को एक विशेष प्रकार के फ़िल्टर में शामिल करना आसान है यदि आप जानते हैं कि आप किस प्रकार से जुड़ना चाहते हैं:

SELECT * FROM Products
INNER JOIN FiltersType2 USING (product_id)

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

केवल अन्य विकल्प बाहरी जोड़ का उपयोग करके सभी फ़िल्टर टेबल में शामिल होना है। जिनके पास कोई मेल नहीं है product_id बस नल की एक पंक्ति के रूप में वापस आ जाएगी। लेकिन आपको अभी भी सभी सम्मिलित तालिकाओं को हार्डकोड करना होगा, और यदि आप नए फ़िल्टर टेबल जोड़ते हैं, तो आपको अपना कोड अपडेट करना होगा।

SELECT * FROM Products
LEFT OUTER JOIN FiltersType1 USING (product_id)
LEFT OUTER JOIN FiltersType2 USING (product_id)
LEFT OUTER JOIN FiltersType3 USING (product_id)
...

सभी फ़िल्टर टेबल से जुड़ने का एक और तरीका यह है कि इसे क्रमबद्ध तरीके से करें:

SELECT * FROM Product
INNER JOIN FiltersType1 USING (product_id)
UNION ALL
SELECT * FROM Products
INNER JOIN FiltersType2 USING (product_id)
UNION ALL
SELECT * FROM Products
INNER JOIN FiltersType3 USING (product_id)
...

लेकिन इस प्रारूप में अभी भी आपको सभी तालिकाओं के संदर्भ लिखने की आवश्यकता है। आसपास कोई नहीं मिल रहा है।

— बिल कार्विन
स्रोत

आप बिल में से किसे सुझाव देंगे? मैं एक डेटाबेस डिजाइन करने के बीच में हूं लेकिन मैं हार गया हूं। मुझे मूल रूप से एक उत्पाद के लिए फिल्टर को जोड़ने की जरूरत है और विभिन्न तालिकाओं के बीच फिल्टर के मूल्यों को आबाद किया जाएगा। लेकिन समस्या यह है कि फ़िल्टर के आधार पर फ़िल्टर उत्पन्न होंगे ताकि फ़िल्टर प्रकार के आधार पर डेटा भिन्न हो सकते हैं और इसलिए joinलक्ष्य भी बदल जाएगा ...... क्या मैं बहुत अधिक या क्या कर रहा हूं? मदद!

— सावास वेदोवा

+1 भयानक समाधान के लिए धन्यवाद। पहला / दूसरा समाधान मेरे पास एक प्रश्न है: क्या इस तथ्य के साथ कोई सामान्यीकरण उल्लंघन है कि कई तालिकाएं उस मेटा-टेबल में एक ही प्राथमिक कुंजी का उल्लेख कर सकती हैं? मुझे पता है कि आप इसे तर्क के साथ हल कर सकते हैं, लेकिन मुझे डेटाबेस के लिए इसे लागू करने का कोई रास्ता नहीं दिखता है, जब तक कि मुझे कुछ याद नहीं है।

— रोब

5

मुझे वास्तव में "CONSTRAINT CHECK" के साथ दृष्टिकोण पसंद है। लेकिन इसे बेहतर किया जा सकता है अगर हम "OR" को "XOR" में बदल दें। इस तरह हम यह निर्धारित करते हैं कि सेट से केवल एक कॉलम नहीं है NULL

— alex_b

1

@alex_b, हां, यह अच्छा है, लेकिन तार्किक XOR मानक SQL नहीं है और सभी SQL ब्रांडों द्वारा समर्थित नहीं है। MySQL में यह है, लेकिन PostgreSQL नहीं है। ओरेकल के पास है, लेकिन माइक्रोसॉफ्ट 2016 तक नहीं है। और इसी तरह।

— बिल कारविन

1

"ये दो कॉलम शून्य हो सकता है, वास्तव में उन्हें गैर-शून्य होना चाहिए का केवल एक ही" - यह होगा 1NF का उल्लंघन!

— onedaywhen

10

यह दुनिया में सबसे सुरुचिपूर्ण समाधान नहीं है, लेकिन आप इस काम को करने के लिए ठोस तालिका विरासत का उपयोग कर सकते हैं ।

वैचारिक रूप से आप "उन चीजों की एक श्रेणी की धारणा का प्रस्ताव कर रहे हैं जो लोकप्रिय क्षेत्र हो सकते हैं" जिनसे आपके तीन प्रकार के स्थान विरासत में मिलते हैं। आप इसे एक तालिका के रूप में प्रतिनिधित्व कर सकते हैं, उदाहरण के लिए, placesजहां प्रत्येक पंक्ति में एक पंक्ति में , या regions, के साथ एक-से-एक संबंध है । (उन क्षेत्रों, देशों या राज्यों के बीच साझा किए जाने वाले गुण, यदि कोई हो, तो उन्हें इस स्थान तालिका में धकेला जा सकता है।) तब आप स्थानों की तालिका में एक पंक्ति के लिए एक विदेशी प्रमुख संदर्भ होंगे जो तब आपको एक क्षेत्र, देश में ले जाएगा। , या राज्य।countriesstatespopular_place_id

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

— Abie
स्रोत

1

उर्फ "

— सुपरटाइप

इसके अलावा यह लेख अच्छी तरह से अवधारणा duhallowgreygeek.com/polymorphic-association-bad-sql-smell

— Marco Staffoli

5

( place_type, place_id )कथित सामान्य रूप के उल्लंघनों को हल करने के लिए एक यौगिक कुंजी का उपयोग करके बिल करविन के "सुपरटेबल" दृष्टिकोण में सुधार किया गया है :

CREATE TABLE places (
  place_id INT NOT NULL UNIQUE,
  place_type VARCHAR(10) NOT NULL
     CHECK ( place_type = 'state', 'country' ),
  UNIQUE ( place_type, place_id )
);

CREATE TABLE states (
  place_id INT NOT NULL UNIQUE,
  place_type VARCHAR(10) DEFAULT 'state' NOT NULL
     CHECK ( place_type = 'state' ),
  FOREIGN KEY ( place_type, place_id ) 
     REFERENCES places ( place_type, place_id )
  -- attributes specific to states go here
);

CREATE TABLE countries (
  place_id INT NOT NULL UNIQUE,
  place_type VARCHAR(10) DEFAULT 'country' NOT NULL
     CHECK ( place_type = 'country' ),
  FOREIGN KEY ( place_type, place_id ) 
     REFERENCES places ( place_type, place_id )
  -- attributes specific to country go here
);

CREATE TABLE popular_areas (
  user_id INT NOT NULL,
  place_id INT NOT NULL,
  UNIQUE ( user_id, place_id ),
  FOREIGN KEY ( place_type, place_id ) 
     REFERENCES places ( place_type, place_id )
);

क्या यह डिजाइन यह सुनिश्चित नहीं कर सकता है कि हर पंक्ति के लिए ( या दोनों में) placesएक पंक्ति मौजूद है । यह SQL में विदेशी कुंजियों की एक सीमा है। एक पूर्ण SQL-92 मानकों के अनुरूप DBMS में आप डिफरेंबल इंटर-टेबल बाधाओं को परिभाषित कर सकते हैं जो आपको समान हासिल करने की अनुमति देगा, लेकिन यह क्लंकी है, इसमें लेनदेन शामिल है और इस तरह के डीबीएमएस को अभी तक बाजार में लाना नहीं है।statescountries

— onedaywhen
स्रोत

0

मुझे एहसास हुआ कि यह धागा पुराना है, लेकिन मैंने यह देखा और एक समाधान दिमाग में आया और मैंने सोचा कि मैं इसे वहां फेंक दूंगा।

क्षेत्र, देश और राज्य भौगोलिक स्थान हैं जो एक पदानुक्रम में रहते हैं।

आप भौगोलिक रूप से एक डोमेन तालिका बनाकर अपनी समस्या से पूरी तरह से बच सकते हैं, जिसे जियोग्राफिकल_लोकेशन_टाइप कहा जाता है, जिसे आप तीन पंक्तियों (क्षेत्र, देश, राज्य) के साथ आबाद करेंगे।

इसके बाद, तीन स्थान तालिकाओं के बजाय, एक एकल भौगोलिक_लोकेशन तालिका बनाएँ जिसमें भौगोलिक_लोकेशन_टाइप_id की एक विदेशी कुंजी है (इसलिए यदि आप जानते हैं कि उदाहरण एक क्षेत्र, देश या राज्य है)।

इस तालिका को स्वयं-संदर्भ बनाकर पदानुक्रम को मॉडल करें ताकि राज्य उदाहरण अपने मूल देश उदाहरण के लिए fKey को रखे जो बदले में fKey को उसके मूल क्षेत्र उदाहरण में रखता है। क्षेत्र उदाहरण उस FKey में NULL को पकड़ेंगे। यह इस बात से अलग नहीं है कि आपने तीन तालिकाओं के साथ क्या किया होगा (आपके पास 1 होगा - क्षेत्र और देश के बीच और देश और राज्य के बीच के कई रिश्ते) सिवाय इसके कि यह सब एक ही तालिका में है।

लोकप्रिय_सुपर_लोकेशन तालिका उपयोगकर्ता और जियोऑर्गेनिक_लोकेशन के बीच एक गुंजाइश रिज़ॉल्यूशन तालिका होगी (इसलिए कई उपयोगकर्ता कई स्थानों को पसंद कर सकते हैं)।

सू…

CREATE TABLE [geographical_location_type] (
    [geographical_location_type_id] INTEGER NOT NULL,
    [name] VARCHAR(25) NOT NULL,
    CONSTRAINT [PK_geographical_location_type] PRIMARY KEY ([geographical_location_type_id])
)

-- Add 'Region', 'Country' and 'State' instances to the above table


CREATE TABLE [geographical_location] (
   [geographical_location_id] BIGINT IDENTITY(0,1) NOT NULL,
    [name] VARCHAR(1024) NOT NULL,
    [geographical_location_type_id] INTEGER NOT NULL,
    [geographical_location_parent] BIGINT,  -- self referencing; can be null for top-level instances
    CONSTRAINT [PK_geographical_location] PRIMARY KEY ([geographical_location_id])
)

CREATE TABLE [user] (
    [user_id] BIGINT NOT NULL,
    [login_id] VARCHAR(30) NOT NULL,
    [password] VARCHAR(512) NOT NULL,
    CONSTRAINT [PK_user] PRIMARY KEY ([user_id])
)


CREATE TABLE [popular_user_location] (
    [popular_user_location_id] BIGINT NOT NULL,
    [user_id] BIGINT NOT NULL,
    [geographical_location_id] BIGINT NOT NULL,
    CONSTRAINT [PK_popular_user_location] PRIMARY KEY ([popular_user_location_id])
)

ALTER TABLE [geographical_location] ADD CONSTRAINT [geographical_location_type_geographical_location] 
    FOREIGN KEY ([geographical_location_type_id]) REFERENCES [geographical_location_type] ([geographical_location_type_id])



ALTER TABLE [geographical_location] ADD CONSTRAINT [geographical_location_geographical_location] 
    FOREIGN KEY ([geographical_location_parent]) REFERENCES [geographical_location] ([geographical_location_id])



ALTER TABLE [popular_user_location] ADD CONSTRAINT [user_popular_user_location] 
    FOREIGN KEY ([user_id]) REFERENCES [user] ([user_id])



ALTER TABLE [popular_user_location] ADD CONSTRAINT [geographical_location_popular_user_location] 
    FOREIGN KEY ([geographical_location_id]) REFERENCES [geographical_location] ([geographical_location_id])

निश्चित नहीं था कि लक्ष्य DB क्या था; ऊपर MS SQL Server है।

— Toolsmythe
स्रोत

0

ठीक है, मेरे पास दो टेबल हैं:

गीत

a) सॉन्ग नंबर b) सॉन्ग टाइटल…।

प्लेलिस्ट ए) प्लेलिस्ट संख्या बी) प्लेलिस्ट शीर्षक ...

और मेरे पास एक तीसरा है

songs_to_playlist_relation

समस्या यह है कि कुछ प्रकार की प्लेलिस्ट का अन्य प्लेलिस्ट से लिंक होता है। लेकिन mysql में हमारे पास विदेशी कुंजी नहीं है जो दो तालिकाओं से संबद्ध है।

मेरा समाधान: मैं गीतों में एक तीसरा कॉलम___सूची_सूची में रखूंगा। वह कॉलम बूलियन होगा। यदि 1 गाना, तो और प्लेलिस्ट तालिका से लिंक होगा।

इसलिए:

songs_to_playlist_relation

a) Playlist_number (int) b) गीत (बुलियन) c है) सापेक्ष संख्या (गीत संख्या या प्लेलिस्ट संख्या) (int) ( किसी तालिका में विदेशी कुंजी नहीं )

 # टेबल गाने बनाएं 
    प्रश्नों । परिशिष्ट ( "SET SQL_MODE = NO_AUTO_VALUE_ON_ZERO?" ) 
    क्वेरीज़ । परिशिष्ट ( "सृजित टेबल songs( NUMBERइंट) SONG POSITION(11) नॉट नॉट , इंट (11) नॉट नॉल, स्मॉलिंटन PLAY SONG(1) SONG TITLEनॉट डीएलएफएफआईटीईएल '1', वर्चर (255) चार्टर सेट यूटीएफ COLL8 utf8_general_ci नॉट नाल, वर्चर DESCRIPTION(1000) CHARACTER SET utf8 मुक़ाबला utf8_general_ci नहीं NULL, ARTISTvarchar (255) वर्ण सेट UTF8 मुक़ाबला utf8_general_ci नहीं NULL डिफ़ॉल्ट 'Άγνωστος καλλιτέχνης', AUTHORvarchar (255) वर्ण सेट UTF8 मुक़ाबला utf8_general_ci नहीं NULL डिफ़ॉल्ट 'Άγνωστος στιχουργός', COMPOSERvarchar (255) वर्ण सेट UTF8 मुक़ाबला utf8_general_ci नहीं NULL DEFAULT 'ωστνωστος ULTν,',ALBUMvarchar (255) CHARACTER SET utf8 COLLATE utf8_general_ci नहीं NULL DEFAULT 'FAνωστο से πλμπουμ' तक, YEARint (11) NOT NULL DEULTULT ' 33', RATINGint (11) NOT NULL DEFAULT '5', IMAGEvarchar (600) CHARACRE CHARACTER SAR। , SONG PATHvarchar (500) वर्ण सेट UTF8 मुक़ाबला utf8_general_ci नहीं NULL, SONG REPEATपूर्णांक (11) नहीं NULL डिफ़ॉल्ट '0', VOLUMEनहीं शून्य डिफ़ॉल्ट '1' फ्लोट, SPEEDनहीं शून्य डिफ़ॉल्ट '1') इंजन = InnoDB डिफ़ॉल्ट charset = UTF8 तैरने लगते हैं, " ) 
    प्रश्न । परिशिष्ट ( "अतिरिक्त तालिका songsप्राथमिक कुंजी ( NUMBER), जोड़ें UNIQUE कुंजी POSITION( SONG POSITION), ADD UNIQUE कुंजी TITLE( SONG TITLE), ADD UNIQUE कुंजी PATH( SONG PATH);") 
    प्रश्न। परिशिष्ट ( "अतिरिक्त songsमोडल NUMBERइंट इंट (11) नॉट नॉट ऑटोलिंक"; )


#create table playlists
queries.append("CREATE TABLE `playlists` (`NUMBER` int(11) NOT NULL,`PLAYLIST POSITION` int(11) NOT NULL,`PLAYLIST TITLE` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,`PLAYLIST PATH` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8;")
queries.append("ALTER TABLE `playlists` ADD PRIMARY KEY (`NUMBER`),ADD UNIQUE KEY `POSITION` (`PLAYLIST POSITION`),ADD UNIQUE KEY `TITLE` (`PLAYLIST TITLE`),ADD UNIQUE KEY `PATH` (`PLAYLIST PATH`);")
queries.append("ALTER TABLE `playlists` MODIFY `NUMBER` int(11) NOT NULL AUTO_INCREMENT;")

#create table for songs to playlist relation
queries.append("CREATE TABLE `songs of playlist` (`PLAYLIST NUMBER` int(11) NOT NULL,`SONG OR PLAYLIST` tinyint(1) NOT NULL DEFAULT '1',`RELATIVE NUMBER` int(11) NOT NULL) ENGINE=InnoDB DEFAULT CHARSET=utf8;")
queries.append("ALTER TABLE `songs of playlist` ADD KEY `PLAYLIST NUMBER` (`PLAYLIST NUMBER`) USING BTREE;")
queries.append("ALTER TABLE `songs of playlist` ADD CONSTRAINT `playlist of playlist_ibfk_1` FOREIGN KEY (`PLAYLIST NUMBER`) REFERENCES `playlists` (`NUMBER`) ON DELETE RESTRICT ON UPDATE RESTRICT")

बस इतना ही!

playlists_query = "s1 का चयन करें। *, s3। *, s4। * F1 से गीतों के रूप में s1 INNER JOIN` के रूप में प्लेलिस्ट के गाने `s2 ON s1.`NUMBER` = s2.`ELATIVE NUMBER` INNER JOIN` playlists` s3 पर s3 पर। .NNUMBER` = s2.`PLAYLIST NUMBER` INNER JOIN `प्लेलिस्ट को s4 पर s4.`NUMBER` = s2.`RELATIVE NUMBER` ORDER BY s3.`PLLLIST POSITION`,` s1`.`SONG POSITION` के रूप में शामिल करें।

— क्रिस पी
स्रोत