एक डेटाबेस में संग्रहीत कार्यों की प्राथमिकता सूची

Question

मैं निम्नलिखित करने का सबसे अच्छा तरीका सोचने की कोशिश कर रहा हूं:

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

मैं कुछ हद तक Pivotal Tracker के समान सोच रहा हूँ।

तो कल्पना कीजिए कि हमारे पास निम्नलिखित थे:

1 Task A
2 Task B
3 Task C
4 Task D
5 Task E

हम तय करते हैं कि ई अब सबसे महत्वपूर्ण कार्य है

1 Task E
2 Task A
3 Task B
4 Task C
5 Task D

मुझे उन्हें नई प्राथमिकता देने के लिए सभी 5 कार्यों को अद्यतन करने की आवश्यकता है।

यदि टास्क बी तब और अधिक महत्वपूर्ण हो जाता है तो एआई मेरे पास होगा

1 Task E
2 Task B
3 Task A
4 Task C
5 Task D

मुझे टास्क बी और ए को ही अपडेट करना होगा।

एक DB में इसे संरचित करने के बारे में क्या तरीके होंगे? मुझे लगता है कि आपके पास एक ही तालिका में एक अलग प्रोजेक्ट संग्रहीत होगा, जिसका अपना वजन होगा।

क्या इसके बाद होने वाले कार्य को इंगित करना बेहतर होगा (लिंक सूची की तरह थोड़ा)।

यह वास्तव में सिर्फ एक मस्तिष्क डंप है। बस आप सोच रहे थे कि आप इस तरह से कुछ कैसे लागू करेंगे।

Answer 1

1. ऐसा लगता है कि आप एक प्राथमिकता कतार की तलाश कर रहे हैं। आपको संभवतः कार्यों के लिए प्राथमिकता वाले संख्याओं को फिर से शांत नहीं करना चाहिए, आपको बस उनके लिए एक निश्चित मूल्य की गणना करनी चाहिए। यदि आप चाहते हैं कि कार्य ई अधिक महत्वपूर्ण हो, तो मूल्य में कमी करें।
2. आप अनिवार्य रूप से संबंधों के बारे में बात कर रहे हैं। बी। ई। से अधिक महत्वपूर्ण होना चाहिए। ई सबसे महत्वपूर्ण कार्य होना चाहिए, आदि। यह एक पेड़ की संरचना की तरह लगता है, और आप इसे माता-पिता के लिंक के साथ RDBMS में स्टोर कर सकते हैं।

Answer 2

यदि आप प्राथमिकता बताने के लिए डबल फ़्लोटिंग पॉइंट नंबरों का उपयोग करते हैं, तो आपको फिर से ऑर्डर करने की आवश्यकता नहीं है:

1.00 Task A
2.00 Task B
3.00 Task C
4.00 Task D
5.00 Task E

यदि आप A और B के बीच टास्क E रखना चाहते हैं तो: -

  E.priority = A.priority + ((B.priority - A.priority) / 2)

तो अब आपके पास है:

1.00 Task A
1.50 Task E
2.00 Task B
3.00 Task C
4.00 Task D

यदि आप E और B के बीच D सम्मिलित करना चाहते हैं तो बस इसकी प्राथमिकता को 1.75 पर सेट करें। फ्लोटिंग पॉइंट संख्या में लगभग 18 दशमलव अंक (1.75 वास्तव में 1.7500000000000000 है) को देखते हुए आपके पास पहले से लगातार 53 आवेषण का सबसे खराब मामला होना चाहिए:

 A.priority + ((B.priority - A.priority) / 2) = B.priority

और इससे पहले कि किसी को भी डबल्स बनाम पूर्णांक का उपयोग करने के ओवरहेड के बारे में शिकायत हो, इसके सिर्फ कुछ हार्डवेयर निर्देश, प्रसंस्करण और I / O ओवरहेड की सूची डेटाबेस में सूची को पुन: व्यवस्थित करने की तुलना में जो अधिक से अधिक परिमाण के कई आदेश होंगे।

Comments

मुझे यह दृष्टिकोण पसंद है, लेकिन यह होना चाहिए: E.priority = A.pityity + ((B.priority - A.priority) / 2) और A.priority + ((B.priority - A.priority) / 2) · बी.पैरिटी

— मार्सेल

उस ओर इशारा करने के लिए धन्यवाद - जवाब तदनुसार संशोधित

— जेम्स एंडरसन

Answer 3

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

उदाहरण के लिए:

TaskId int identity(1,1),
Task varchar(50),
SortOrder int

संग्रहीत कार्यविधि जो आइटम को पुन: क्रमबद्ध करती है, दो इनपुट पैरामीटर लेती है:

@TaskId int,
@NewSortOrder int

हमने नए ऑर्डर में वस्तुओं को संग्रहीत करने के लिए एक अस्थायी तालिका का उपयोग किया:

CREATE TABLE #Tasks
(
RowId int identity(1,1),
TaskId int
)

हमने उन्हें नए क्रम में लाने के लिए तीन चुनिंदा बयानों का इस्तेमाल किया:

-- Step 1
INSERT INTO #Tasks
SELECT TaskId FROM tblTasks
WHERE SortOrder < @NewSortOrder
ORDER BY SortOrder

--Step 2
INSERT INTO #Tasks
VALUES(@TaskId)

--Step 3
INSERT INTO #Tasks
SELECT TaskId FROM tblTasks
WHERE SortOrder >= @NewSortOrder
ORDER BY SortOrder

हमने तब आधार तालिका (tblTasks) को नए प्रकार के क्रम के साथ अद्यतन किया जो वास्तव में अस्थायी तालिका का पंक्ति पहचान स्तंभ है:

-- Update Base Table
UPDATE tblTasks
SET SortOrder = t2.RowId
FROM tblTasks t1
INNER JOIN #Tasks t2
ON t1.TaskId = t2.TaskId

यह हर बार एक विजेता की तरह काम करता है।

Answer 4

मैंने अभी तक इसके बारे में नहीं सोचा है ..... लेकिन क्यों न केवल दशमलव को अनुमति दें ताकि आप सब कुछ अपडेट किए बिना दूसरों के बीच सामान रख सकें?

आप 1 और 2 के बीच 1.5 के मूल्य के साथ कुछ स्क्विश कर सकते हैं।

मैं भी न्यूनतम और अधिकतम मूल्यों से बचना चाहता था। यदि वर्तमान में जो कुछ भी है उससे पहले नंबर को नकारात्मक में रोल करने दें।

आप एक "मानव प्रदर्शन" की प्राथमिकता को आंतरिक "आदेश" की प्राथमिकताओं से अलग कर सकते हैं, जो कि विकट दशमलव और नकारात्मक मूल्यों को दिखाने से बचें।

Comments

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

— केविन क्लाइन

Answer 5

RDBMS में लिंक्ड लिस्ट और इसके संचालन को लागू करना बहुत उचित है। बस SQL ​​प्रश्नों के साथ सरणी और संदर्भ जोड़तोड़ को बदलें। हालांकि, मुझे यकीन नहीं है कि अगर यह वास्तव में सबसे सरल तरीका है क्योंकि कुछ सरल ऑपरेशन में कई SQL प्रश्नों की आवश्यकता होगी

टास्क टेबल के लिए, आप एक कॉलम "next_task" और "prev_task" जोड़ते हैं जो एक ही टेबल के आईडी कॉलम के लिए विदेशी कुंजी हैं (यह मानते हुए कि "-1" NULL के बराबर है)

उच्चतम_पायरिटी () के साथ कार्य लौटाएँ : SQL क्वेरी जो कार्य को prev_task = -1 के साथ लौटाती है

E सबसे महत्वपूर्ण कार्य है : SQL क्वेरी जो E के अगले_task को सर्वोच्च प्राथमिकता के साथ कार्य की ID में बदल देती है। और परिवर्तन E के -1 के prev_task ...

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

Answer 6

प्राथमिकता समस्या के लिए एक और दृष्टिकोण यह निर्दिष्ट करना होगा कि आइटम किस आइटम से अधिक महत्वपूर्ण है। एचआर एप्लिकेशन में, यह कहना होगा कि कर्मचारी का प्रबंधक कौन है।

ID  Name           ParentPriority
1   TopPriority    NULL
2   Medium         1
3   Low            2
4   AnotherMedium  1
5   Less than 2    2

इसके बाद इस http://blog.sqlauthority.com/2012/04/24/sql-server-introduction-to-hierarchical-query-use-a-recursive-cte-a-primer/ पर एक प्रश्न लिखें जो प्राथमिकता देता है स्तरों।

ID  Name           ParentPriority  PriorityLevel
1   TopPriority    NULL            1
2   Medium         1               2
3   Low            2               3
4   AnotherMedium  1               2
5   Less than 2    2               3

मुझे लगता है कि प्राथमिकताओं को स्थापित करने में यह एक सरल उपयोगकर्ता अनुभव है, लेकिन यह एक ही स्तर की कई प्राथमिकताओं के लिए अनुमति देता है।

Answer 7

एक सरल तरीका इस तरह से कुछ के साथ शुरू होगा:

100 Task A
200 Task B
300 Task C
400 Task D
500 Task E

फिर, टास्क ए और टास्क बी के बीच "टास्क ई" को स्थानांतरित करने के लिए, आप बस टास्क ए और टास्क बी (इस मामले में "150") के बीच कुछ आधे रास्ते में "टास्क ई" की प्राथमिकता निर्धारित करेंगे।

बेशक, यदि आप लगातार प्राथमिकताओं को पुन: व्यवस्थित करते हैं, तो आप अंततः एक ऐसी समस्या में भाग लेंगे जिसके तहत दो अलग-अलग कार्यों के लिए दो प्रविष्टियाँ सम्मिलित करने के लिए कोई "गैप" नहीं है। लेकिन जब ऐसा होता है, तो आप एक बार में सभी प्राथमिकताओं को "रीसेट" कर सकते हैं 100, 200, 300, आदि।

Comments

यह वास्तव में मेरे जवाब के समान ही है, बस बारीकी से समूहीकृत दशमलव के बजाय बड़े पूर्णांक के साथ शुरू होता है। :)

— जोजो

Answer 8

मैं कोई डेटाबेस गुरु नहीं हूं, इसलिए मैंने इसे एक्सेस लॉजिक 2010 में सबसे तार्किक तरीके से हल किया। मेरे पास "प्राथमिकता" फ़ील्ड है जो संख्यात्मक क्षेत्र है। फिर मेरे पास इस क्षेत्र के लिए एक घटना है।

यह घटना फ़ील्ड "प्राथमिकता" के लिए एक अपडेट के बाद की घटना है जो एक अपडेट क्वेरी "क्यूरीपैरिटी" को ट्रिगर करती है जो अन्य सभी रिकॉर्डों की प्राथमिकता संख्या में 1 को जोड़ने के लिए है जो कि प्राथमिकता वाले नंबर से अधिक या उसके बराबर एक प्राथमिकता है।

यहाँ घटना VB कोड और अद्यतन क्वेरी SQL है:

"प्राथमिकता" इवेंट VB कोड:

Private Sub Priority_AfterUpdate()
Me.Refresh
If Priority > 0 Then
DoCmd.OpenQuery ("qryPriority")
End If
Me.Refresh
Priority = Priority - 1
End Sub

"qryPyerity" अपडेट क्वेरी SQL:

UPDATE YOURTABLENAME SET YOURTABLENAME.Priority = [Priority]+1
WHERE (((YOURTABLENAME.Priority)>=[Forms]![YOURFORMNAME]![Priority]));