गोल्फ एप्लिकेशन में टी ऑर्डर निर्धारित करने के लिए एसक्यूएल

Question

मैं एक गोल्फ एप्लिकेशन पर काम कर रहा हूं जिसमें स्कोरकार्ड सिस्टम शामिल है। मैं डेटाबेस में प्रत्येक खिलाड़ी के लिए प्रत्येक स्कोर संग्रहित कर रहा हूं और मुझे टी ऑर्डर निर्धारित करने के लिए एक क्वेरी के साथ आने की आवश्यकता है। उदाहरण के लिए अगर खिलाड़ियों 3 छेद निभाई है और स्कोर इस तरह दिखेगा ...

Player 1 2 3 
--------- - - - 
Player 1: 3, 4, 3 
Player 2: 2, 3, 3 
Player 3: 2, 4, 3 

... तो फिर इस तरह देखने के लिए ...

1.) Player 2 
2.) Player 3 
3.) Player 1 

की जरूरत है ... तो खिलाड़ियों को अपने विरोधियों के स्कोर की तुलना में उनके स्कोर द्वारा आदेश दिया जाएगा। क्या इसका कोई मतलब है? क्या यह एक क्वेरी के साथ भी संभव है, या मुझे कोड में 2 डी सरणी पार्स करने के लिए एक फ़ंक्शन लिखना चाहिए? मैं उस मामले में जावा का उपयोग कर रहा हूं।

• प्लेयर (प्लेयर आईडी, और खिलाड़ी का नाम)
• राउंड्स (दौर आईडी, पाठ्यक्रम आईडी)
• स्कोर (दौर आईडी, खिलाड़ी आईडी, छेद संख्या:

  मेरे तालिका संरचना इस तरह दिखता है , और स्कोर)

Answer 1

मैं एक समाधान देख सकता हूं जो प्रत्येक चरण (या SQL सर्वर में रिकर्सिव सीटीई) के क्रम में विंडोज फ़ंक्शन row_number() और डेटाबेस में एक अतिरिक्त कॉलम का उपयोग करता है। हालांकि, SQLite इसका समर्थन नहीं करता है।

(1) निरुपित पहले टी के लिए टी आदेश:

यहाँ पीछे की ओर से क्वेरी की एक बहुत कुछ कर के बिना समाधान को लागू करने पर मेरी सिफारिश है।

(2) प्रत्येक अगले टी के लिए, पिछले स्कोर और पिछले टी आदेश पर नज़र डालें:

(3) द्वारा उच्चतम स्कोर DESC और पिछले टी आदेश देने से पिछले स्कोर के माध्यम से पाशन द्वारा नए टी आदेश असाइन करें आदेश एएससी।

क्योंकि आपके पास प्रति राउंड केवल कुछ खिलाड़ी हैं, यह ऐप परत में ऐसा करना उचित है। हालांकि, यदि आपके पास एक डेटाबेस था जो विंडो फ़ंक्शन का समर्थन करता था, तो आप डेटाबेस को केवल समाधान आसानी से कर सकते थे।

मैं विरोध नहीं कर सकता। यहां कुछ कोड जो ऑर्डर स्टोर करने के लिए टेबल के साथ ऐसा करेंगे। प्रति छेद के बाद आपको लूप की आवश्यकता होती है:

create table ThisOrder (
    ThisOrderId int primary key autoincrement, 
    RoundId int, 
    Hole int, 
    PlayerId int 
) 

कुछ क्रम में प्रत्येक खिलाड़ी के साथ इसे आरंभ करें।

फिर, प्रत्येक छेद के लिए तालिका में नई पंक्तियाँ सम्मिलित करें:

insert into ThisOrder(RoundId, HoleId, PlayerId) 
    select s.RoundId, s.Hole+1, s.PlayerId 
    from Scores s join 
     ThisOrder to 
     on s.PlayerId = to.PlayerId and 
      s.RoundId = to.RoundId and 
      s.Hole = to.Hole 
    order by s.Score DESC, to.Order ASC 

आप प्रत्येक छेद, शून्य से एक के लिए एक बार यह कॉल करने के लिए की आवश्यकता होगी।

फिर अपने आदेश के रूप में:

select * 
from ThisOrder 
where roundid = <roundid> and hole = <thehole> 
order by ThisOrderId 

Answer 2

तो, आप प्रत्येक छेद के लिए स्कोर को योग करने के लिए प्रत्येक खिलाड़ी के लिए वर्तमान छेद करने के लिए पिछले है, तो अभिव्यक्त द्वारा खिलाड़ी ID की सूची को सॉर्ट आवश्यकता होगी स्कोर।

कुछ इस तरह काम करना चाहिए:

SELECT SUM(score) AS score, player_id FROM Scores WHERE round_id=$current_round AND hole_number<$current_hole GROUP BY player_id ORDER BY score; 

यह दो कॉलम (player_id और स्कोर) के रूप में कई पंक्तियों के साथ का एक परिणाम तालिका में जो परिणाम के रूप में वहाँ खिलाड़ी हैं, उच्चतम स्कोर के साथ खिलाड़ी डाल पहले।

Answer 3

इस क्वेरी उच्चतम छेद जहां खिलाड़ी सबसे कम स्कोर और उस द्वारा आदेश दिए गए थे देता है:

SELECT * FROM Players p 
ORDER BY 
    (SELECT MAX(s1.hole_number) FROM Scores s1 
    LEFT JOIN Scores s2 
    ON s2.round_id = s1.round_id AND 
     s1.hole_number = s2.hole_number AND 
     s2.score < s1.score 
    WHERE s1.player_id = p.player_id AND 
    s1.round_id = 1 AND s2.round_id IS NULL) DESC