एक कॉलम में एकाधिक मानों के साथ एसक्यूएल क्वेरी

Question

मैं इस पर नजर रखने की कोशिश कर डेस्क पर अपना सिर मार रहा हूं। मेरे पास एक सारणी है जो नौकरी की जानकारी संग्रहीत करती है, और नौकरी के कारणों को पूरा नहीं किया जा रहा है। कारण संख्यात्मक हैं, 01,02,03, आदि। लंबित नौकरी के लिए आपके पास दो कारण हो सकते हैं। यदि आप दो कारणों का चयन करते हैं, तो वे एक ही कॉलम में संग्रहीत होते हैं, जो अल्पविराम से अलग होते हैं।

Job_Number  User_Assigned  PendingInfo 

1    user1    01,02 

विचाराधीन नामक एक अन्य टेबल, संग्रहीत करता है कि क्या वास्तव में उन मूल्यों का प्रतिनिधित्व नहीं है: यह JOBID मेज से एक उदाहरण है। 01 = पर्याप्त जानकारी नहीं, 02 = पर्याप्त समय नहीं, 03 = प्रतीक्षा की समीक्षा। उदाहरण:

Pending_Num PendingWord 

01    Not Enough Info 
02    Not Enough Time 

मुझे क्या करना कोशिश कर रहा हूँ डेटाबेस क्वेरी मुझे सब काम संख्या, उपयोगकर्ताओं, pendinginfo, और लंबित कारण दे रहा है। मैं पहला मान तोड़ सकता हूं, लेकिन यह पता नहीं लगा सकता कि दूसरा कैसे करें। क्या अपने सीमित कौशल अब तक है:

select Job_number,user_assigned,SUBSTRING(pendinginfo,0,3),pendingword 
from jobid,pending 
where 
    SUBSTRING(pendinginfo,0,3)=pending.pending_num and 
    pendinginfo!='00,00' and 
    pendinginfo!='NULL' 

मैं इस उदाहरण के लिए देखने के लिए होगा चाहते हैं क्या:

Job_Number User_Assigned PendingInfo PendingWord  PendingInfo PendingWord 

1   User1   01   Not Enough Info 02   Not Enough Time 

अग्रिम

Answer 1

धन्यवाद तो स्कीमा बदलते एक विकल्प है (जो शायद यह होना चाहिए) क्या आप यहां कई से अधिक रिश्तों को लागू नहीं करना चाहिए ताकि आपके पास दो वस्तुओं के बीच एक ब्रिजिंग टेबल हो? इस तरह, आप ब्रिजिंग टेबल में नंबर और उसके शब्द को एक टेबल में, अन्य में नौकरियों और "नौकरियों के लिए विफलता कारण" स्टोर करेंगे ...

Answer 2

आप वास्तव में एक कॉलम में एकाधिक आइटम स्टोर नहीं करना चाहिए यदि आपका एसक्यूएल कभी भी उन्हें व्यक्तिगत रूप से संसाधित करना चाहता है। "एसक्यूएल जिमनास्टिक" आपको उन मामलों में प्रदर्शन करना है बदसूरत हैक और प्रदर्शन degraders दोनों हैं।

आदर्श समाधान अलग-अलग कॉलम और 3NF के लिए, में अलग-अलग आइटम विभाजित करने के लिए, पंक्तियों के रूप में एक अलग तालिका करने के लिए उन स्तंभों को अगर आप वास्तव में इसे ठीक से करना चाहते हैं (लेकिन बच्चे चरणों शायद ठीक है अगर तुम 'हो रहा है सुनिश्चित करें कि अल्पकालिक अवधि में दो से अधिक कारण कभी नहीं होंगे)।

फिर आपके प्रश्न सरल और तेज़ दोनों होंगे।

---

हालांकि, अगर वह एक विकल्प नहीं है, आप आगे उल्लिखित एसक्यूएल जिमनास्टिक की तरह कुछ करने के लिए उपयोग कर सकते हैं: अपने एसक्यूएल बोली संभालने

where find (',' |fld| ',', ',02,') > 0 

एक स्ट्रिंग खोज समारोह (find इस मामले में है , लेकिन मुझे लगता है कि SQLServer के लिए charindex)।

यह सुनिश्चित करेगा कि सभी सब-कॉलम शुरू हो जाएंगे और कॉमा (कॉमा प्लस फ़ील्ड प्लस कॉमा) से शुरू हो जाएंगे और एक विशिष्ट वांछित मूल्य (किसी भी तरफ कॉमा के साथ यह सुनिश्चित करने के लिए कि यह एक पूर्ण उप-कॉलम मैच है) के साथ शुरू करें।

---

आप नहीं नियंत्रण क्या आवेदन उस कॉलम में डालता है, मैं डीबीए समाधान के लिए चुनते हैं कर सकते हैं - डीबीए समाधान उन एक डीबीए करना है उनके प्रयोक्ताओं की अपर्याप्तता के आसपास काम करने के लिए के रूप में परिभाषित कर रहे हैं :-)।

उस तालिका में दो नए कॉलम बनाएं और एक डालने/अपडेट ट्रिगर बनाएं जो उन्हें दो कारणों से पॉप्युलेट करेगा जो उपयोगकर्ता मूल कॉलम में डालता है।

फिर पुराने कॉलम को अलग करने की कोशिश करने के बजाय उन दो नए कॉलम विशिष्ट मानों के लिए कॉलम से पूछें।

इसका मतलब है कि विभाजन की लागत केवल पंक्ति सम्मिलित/अद्यतन पर है, न कि प्रत्येक एकल चयन पर, जो उस लागत को कुशलता से बढ़ाती है।

---

फिर भी, मेरा जवाब स्कीमा को फिर से करना है। गति, पठनीय प्रश्नों और रखरखाव के मामले में दीर्घ अवधि में यह सबसे अच्छा तरीका होगा।

Answer 3

मुझे आशा है कि आप केवल कोड बनाए रखेंगे और यह एक नया नया कार्यान्वयन नहीं है।
इस तरह एक समर्थन तालिका का उपयोग कर एक अलग दृष्टिकोण का उपयोग करने पर विचार करें:

JOBS TABLE 
jobID | userID 
-------------- 
1  | user13 
2  | user32 
3  | user44 
-------------- 

PENDING TABLE 
pendingID | pendingText 
--------------------------- 
01  | Not Enough Info 
02  | Not Enough Time 
--------------------------- 

JOB_PENDING TABLE 
jobID | pendingID 
----------------- 
1  | 01 
1  | 02 
2  | 01 
3  | 03 
3  | 01 
----------------- 

आप आसानी से शामिल हों या सबक्वेरी का उपयोग कर इस टेबल क्वेरी कर सकते हैं।
यदि आपको अपने सॉफ़्टवेयर पर रेट्रो-संगतता की आवश्यकता है तो आप इस लक्ष्य तक पहुंचने के लिए एक दृश्य जोड़ सकते हैं।

Answer 4

एक समान प्रश्न पर एक नज़र मैंने जवाब here

;WITH Numbers AS 
( 
    SELECT ROW_NUMBER() OVER(ORDER BY (SELECT 0)) AS N 
    FROM JobId 
), 
Split AS 
( 
    SELECT JOB_NUMBER, USER_ASSIGNED, SUBSTRING(PENDING_INFO, Numbers.N, CHARINDEX(',', PENDING_INFO + ',', Numbers.N) - Numbers.N) AS PENDING_NUM 
    FROM JobId 
    JOIN Numbers ON Numbers.N <= DATALENGTH(PENDING_INFO) + 1 
    AND SUBSTRING(',' + PENDING_INFO, Numbers.N, 1) = ',' 
) 
SELECT * 
FROM Split JOIN Pending ON Split.PENDING_NUM = Pending.PENDING_NUM 

मूल विचार आप प्रत्येक पंक्ति के रूप में कई बार गुणा करने के लिए के रूप में देखते हैं PENDING_NUM रों है है है। फिर, स्ट्रिंग

Answer 5

के उचित भाग निकालने मैं की तरह एक टेबल है:

Events 
--------- 
eventId int 
eventTypeIds nvarchar(50) 
... 

EventTypes 
-------------- 
eventTypeId 
Description 
... 

प्रत्येक इवेंट निर्दिष्ट कई eventtypes हो सकता है।

सभी मुझे क्या मेरी साइट कोड में 2 प्रक्रियाओं लिखते हैं, नहीं SQL कोड एक ViewState सरणी में

1. एक प्रक्रिया (eventTypeIds) मूल्य "3,4,15,6" की तरह तालिका फ़ील्ड परिवर्तित करता है , इसलिए मैं कोड में कहीं भी इसका उपयोग कर सकता हूं।

2. यह प्रक्रिया विपरीत यह किसी भी विकल्प आपके जाँच की जमा करता है और

Answer 6

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

मान लें कि आपके पास 10000 उपयोगकर्ता समूह हैं, प्रत्येक में औसत 1000 सदस्य हैं। आप समूह आईडी और समूह आईडी जैसे कॉलम वाले उपयोगकर्ता_ग्रुप रखना चाहते हैं। आपके सदस्य आईडी कॉलम इस तरह पॉप्युलेट किए जा सकते हैं: (', 10,2001,20003,333,4520,') प्रत्येक नंबर सदस्य आईडी है, सभी को अल्पविराम से अलग किया जाता है। डेटा की शुरुआत और अंत में एक अल्पविराम भी जोड़ें। फिर आपका चयन '%, someID,%' जैसा प्रयोग करेगा।

यदि आप अपना डेटा ('01, 02,03 ') या इसी तरह से नहीं बदल सकते हैं, तो मान लें कि आप पंक्तियों वाली 01 चाहते हैं, आप अभी भी "चुन सकते हैं ... पसंद करें',% 'या'%, 01 ' या '%, 01,%' "जो शुरू होता है, अंत में या अंदर, समान संख्या से बचते समय (यानी 101)।