मान लीजिए, मेरे पास निम्न तालिका है:

ID | UID | Version | Content
---+-----+---------+-----------------------------
 1 |   1 |       1 | Something
 2 |   1 |       2 | Something (changed)
 3 |   2 |       1 | Alice has a cat
 4 |   2 |       2 | Alice has a cat and a dog
 5 |   2 |       3 | Alice has a cat and a canary

मुझे क्वेरी बनाने की आवश्यकता है, जो सभी वस्तुओं को वापस कर देगी, लेकिन केवल नवीनतम संस्करण के साथ, इसलिए इस मामले में:

ID | UID | Version | Content
---+-----+---------+-----------------------------
 2 |   1 |       2 | Something (changed)
 5 |   2 |       3 | Alice has a cat and a canary

चूंकि SQL बोलियाँ भिन्न हैं, इसलिए मैं इस क्वेरी को MS Sql Server 2008 और SQLite 3 पर चला रहा हूँ।

मैं उसे कैसे प्राप्त कर सकता हूं?

0
Spook 4 पद 2015, 13:47

2 जवाब

सबसे बढ़िया उत्तर

NOT EXISTS क्वेरी:

select *
from tablename t1
where not exists (select 1 from tablename t2
                  where t2.uid = t1.uid
                    and t2.version > t1.version)

JOIN क्वेरी:

select t1.*
from tablename t1
    join (select uid, max(version) as version from tablename group by uid) t2
    on t2.uid = t1.uid and t2.version = t1.version

संबंधित उप-क्वेरी:

select t1.*
from tablename t1
where t1.version = (select max(version) from tablename t2
                    where t2.uid = t1.uid)

IN उप-क्वेरी:

select *
from tablename
where (uid, version) IN (select uid, max(version) from tablename
                         group by uid)
2
jarlh 4 पद 2015, 12:02

इस समस्या को हल करने के लिए कुछ अलग तरीके हैं। लेकिन प्रत्येक दृष्टिकोण समान सिद्धांत का पालन करता है।

आपकी क्वेरी का एक भाग प्रत्येक UID के नवीनतम संस्करण की पहचान करेगा। यह तब recordet फ़िल्टर करने के लिए उपयोग किया जाएगा।

नीचे दिए गए उदाहरण में, मैंने प्रत्येक UID के वर्तमान संस्करण को एक उप क्वेरी का उपयोग करते हुए पाया है, जिसका उपयोग मैंने मुख्य रिकॉर्डसेट को फ़िल्टर करने के लिए किया है।

उदाहरण

/* This table gives us some sample records
 * to experiment with.
 */
DECLARE @Example TABLE
    (
        ID            INT                PRIMARY KEY,
        [UID]        INT                NOT NULL,
        [Version]    INT                NOT NULL,
        Content        VARCHAR(255)    NOT NULL
    )
;

/* Populate the sample data.
 */
INSERT INTO @Example
    (
        ID,
        [UID],
        [Version],
        Content
    )
VALUES
    (1, 1, 1, 'Something'),
    (2, 1, 2, 'Something (changed)'),
    (3, 2, 1, 'Alice has a cat'),
    (4, 2, 2, 'Alice has a cat and a dog'),
    (5, 2, 3, 'Alice has a cat and a canary')
;

/* Return the most recent version of each UID.
 * This is done by using a sub query to calcualte the max of each UIDs version.
 */
SELECT
    e.*
FROM
    @Example AS e
        INNER JOIN
            (    
                /* This sub query finds the max version of
                 * each UID.
                 */
                SELECT
                    [UID],
                    MAX([Version]) AS Current_Version
                FROM
                    @Example    
                GROUP BY
                    [UID]
            ) AS mv
        ON    mv.[UID]            = e.[UID]
        AND    mv.Current_Version    = e.[Version]
;
0
David Rushton 4 पद 2015, 11:04