limitation des lignes à l'endroit où la somme d'une colonne est égale à une certaine valeur dans MySQL

Je veux écrire une requête qui retourne toutes les lignes jusqu'à ce que la somme de l'une des colonnes de la valeur atteint une certaine valeur.

Par exemple dans le tableau ci-dessous:

           DATE             ETC      Meeting
    2013-02-01 00:00:00    85482        1
    2013-02-01 00:00:00    47228        2
    2013-02-02 00:00:00    12026        4
    2013-02-03 00:00:00    78927        6
    2013-02-04 00:00:00    85662        2
    2013-03-05 00:00:00    47978        1
    2013-08-07 00:00:00     8582        1

Si je veux obtenir les lignes jusqu'à ce que la somme de la colonne Meeting est égal à 7.

           DATE             ETC      Meeting
    2013-02-01 00:00:00    85482        1
    2013-02-01 00:00:00    47228        2
    2013-02-02 00:00:00    12026        4

Si je veux obtenir les lignes jusqu'à ce que la somme de la colonne Meeting est égale à 13.

     DATE                   ETC      Meeting
    2013-02-01 00:00:00    85482        1
    2013-02-01 00:00:00    47228        2
    2013-02-02 00:00:00    12026        4
    2013-02-03 00:00:00    78927        6

Qui SGBDR utilisez-vous, MS SQL Server, MySQL, PostgreSQL...? Qu'avez-vous essayé? Poste de travail requêtes, n'a pas d'importance si le résultat est incorrect, est un point de départ et peut-être que vous n'êtes pas loin de la solution.
Vous semblez avoir aucune CLÉ PRIMAIRE/aucun moyen d'établir l'ordre dans lequel les lignes sont à considérer

OriginalL'auteur Hemant | 2013-02-15

mysql sql

5

Ici un moyen qui devrait fonctionner dans MySQL :
```
SELECT
  O.Id,
  O.Type,
  O.MyAmountCol,
  (SELECT
     sum(MyAmountCol) FROM Table1
   WHERE Id <= O.Id) 'RunningTotal'
FROM Table1 O
HAVING RunningTotal <= 7
```
Il consiste à calculer le total et la sélection de documents, tandis que le total cumulé est inférieur ou égal au nombre donné, dans ce cas 7.

SQL Violon

Où avez-id vient?
Remarque il est probable O(N^2) la requête sur le serveur de base de données que le sous-sélectionnez pousse vers la fin de la requête, et il n'y a pas de début de l'arrêt, toutes les sommes seront évaluées. Pourvu que l'étendue de la sélectionne est petit, il a l'avantage d'être d'une seule requête (donc pas besoin d'une procédure stockée, etc).

OriginalL'auteur DMK
7

Voici un moyen de le faire sans une procédure stockée:
```
SET @msum := 0;
SELECT t1.* 
FROM (
    SELECT m.*,  
          (@msum := @msum + m.meetings) AS cumulative_meetings
    FROM meetings m 
    ORDER BY m.date ASC
) t1 
WHERE t1.cumulative_meetings <= 7;
```
c'est en fait un meilleur, plus rapide solution pour de grandes quantités de données. je vous remercie.
Sauf les dates ne sont pas uniques
Si la ligne a plus de réunions que les X, cette requête va retourner la valeur 0 à la ligne.

OriginalL'auteur toomanyredirects

Ce un surpasse toutes.

SET @runningTotal=0;
SELECT
  O.Id,
  O.Type,
  O.MyAmountCol,
  @runningTotal + O.MyAmountCol as 'RunningTotal',
  @runningTotal := @runningTotal + O.MyAmountCol
FROM Table1 O
HAVING RunningTotal <=7;

SQL Violon

Jeter un oeil à des plans d'exécution pour les deux requêtes.

Merci pour cette. Pour ceux qui veulent l'utiliser WHERE requête avec cela, utilisez AND dans HAVING au lieu

OriginalL'auteur valdas.mistolis

Hemant vous ne précisez pas le SGBDR qui l'utilisent. Voici un script t-sql que vous pouvez utiliser afin de résoudre votre problème.

DECLARE @numberToReach INT;
SET @numberToReach = 10; --you can change this

DECLARE @date DATETIME;
DECLARE @etc VARCHAR(20);
DECLARE @meeting INT;
DECLARE @temp_sum INT;

CREATE TABLE #tempTable
    (
        Dates DATETIME,
        Etcs VARCHAR(20),
        Meeting INT,
    )

DECLARE tempcursor CURSOR FOR
        SELECT *
        FROM YourTABLENAME
OPEN tempcursor;
FETCH NEXT FROM tempcursor INTO @date, @etc, @meeting;

WHILE(@@FETCH_STATUS = 0)
BEGIN
    SET @temp_sum = @temp_sum + @meeting;
    IF @temp_sum < @numberToReach 
    BEGIN
        INSERT INTO #tempTable
        (
            Dates,
            Etcs,
            Meeting
        )
        VALUES
        (
            @date, 
            @etc, 
            @meeting
        )

        FETCH NEXT FROM tempcursor INTO @date, @etc, @meeting;
    END 
END

SELECT * FROM #tempTable

CLOSE tempcursor
DEALLOCATE tempcursor

DROP TABLE  #tempTable

OriginalL'auteur Manolis

0

Voici une vilaine façon:
```
SELECT *
FROM meetings m1
WHERE (SELECT SUM(m2.Meeting) 
       FROM meetings m2 
       WHERE m2.DATE < m1.DATE OR (m2.DATE = m1.DATE AND m2.ETC >= m1.ETC)) <= 7
```
De la commande est basé sur DATE d'abord, puis ETC dans l'ordre décroissant, depuis que semble être ce que nous avons à faire. Notez que si ce n'est pas unique, vous obtiendrez le mauvais résultat.

OriginalL'auteur lc.
0

Dans Oracle, je pense que vous pouvez utiliser la SOMME analytique de la fonction. Vous pouvez consulter ici: http://www.adp-gmbh.ch/ora/sql/analytical/sum.html

OriginalL'auteur Lloyd Santos
0

Comme aucun SGBD est donné, ce qui suit est un ANSI SQL solution qui fonctionne sur une large gamme de SGBD:
```
select *
from (
    select date_column, 
           etc, 
           sum(Meeting) over (order by date_column asc) run_sum
    from meetings
) t
where run_sum <= 7
order by date_column asc;
```
(J'ai utilisé le nom de la colonne date_column au lieu de date parce que DATE est un mot réservé en SQL et ne doit pas être utilisé comme un nom de colonne pour éviter les problèmes)

La Date n'est pas un mot réservé, et les dates ne sont pas uniques dans l'exemple fourni
oui date un mot-clé (mais pas réservé). Même MySQL pense: dev.mysql.com/doc/refman/5.5/en/keywords.html et les dates n'ont pas à être unique pour que cela fonctionne

OriginalL'auteur a_horse_with_no_name
-1

Si vous utilisez SQL Server, puis utilisez CROIX APPLIQUER.

OriginalL'auteur IamIC

Vous devez vous connecter pour publier un commentaire.