SQL उन तत्वों का चयन करता है जहाँ फ़ील्ड का योग N . से कम है

SELECT m.id, sum(m1.verbosity) AS total
FROM   messages m
JOIN   messages m1 ON m1.id <= m.id
WHERE  m.verbosity < 70    -- optional, to avoid pointless evaluation
GROUP  BY m.id
HAVING SUM(m1.verbosity) < 70
ORDER  BY total DESC
LIMIT  1;

यह एक अद्वितीय, आरोही id मानता है जैसे आपके उदाहरण में है।

आधुनिक पोस्टग्रेज में - या आम तौर पर आधुनिक मानक SQL . के साथ (लेकिन नहीं SQLite में):

सरल सीटीई

WITH cte AS (
   SELECT *, sum(verbosity) OVER (ORDER BY id) AS total
   FROM   messages
   )
SELECT *
FROM   cte
WHERE  total <= 70
ORDER  BY id;

पुनरावर्ती CTE

बड़ी तालिकाओं के लिए तेज़ होना चाहिए जहाँ आप केवल एक छोटा सेट प्राप्त करते हैं।

WITH RECURSIVE cte AS (
   (  -- parentheses required
   SELECT id, verbosity, verbosity AS total
   FROM   messages
   ORDER  BY id
   LIMIT  1
   )

   UNION ALL 
   SELECT c1.id, c1.verbosity, c.total + c1.verbosity 
   FROM   cte c
   JOIN   LATERAL (
      SELECT *
      FROM   messages
      WHERE  id > c.id
      ORDER  BY id
      LIMIT  1
      ) c1 ON  c1.verbosity <= 70 - c.total
   WHERE c.total <= 70
   )
SELECT *
FROM   cte
ORDER  BY id;

LIMIT . को छोड़कर सभी मानक सुविधाएं ।

कड़ाई से बोलते हुए, "डेटाबेस-स्वतंत्र" जैसी कोई चीज नहीं है। विभिन्न SQL-मानक हैं, लेकिन कोई भी RDBMS पूरी तरह से अनुपालन नहीं करता है। LIMIT PostgreSQL और SQLite (और कुछ अन्य) के लिए काम करता है। TOP 1 का उपयोग करें SQL सर्वर के लिए, rownum ओरेकल के लिए। यहाँ विकिपीडिया पर एक विस्तृत सूची है।

SQL:2008 मानक होगा:

...
FETCH  FIRST 1 ROWS ONLY

... जो PostgreSQL का समर्थन करता है - लेकिन शायद ही कोई अन्य RDBMS।

अधिक सिस्टम के साथ काम करने वाला शुद्ध विकल्प यह होगा कि इसे एक सबक्वेरी में लपेटा जाए और

SELECT max(total) FROM <subquery>

लेकिन यह धीमा और बोझिल है।

एसक्यूएल फिडल.