Soustraction d'une ligne de données d'une autre dans SQL

J'ai été perplexe avec certains SQL où j'ai plusieurs lignes de données, et je veux en supprimer une ligne de la rangée précédente et de l'avoir répéter tout le chemin vers le bas.

Voici donc le tableau:

CREATE TABLE foo ( 
id, 
longueur 
)
INSERT INTO foo (id,longueur) VALUES(1,1090) 
INSERT INTO foo (id,longueur) VALUES(2,888) 
INSERT INTO foo (id,longueur) VALEURS(sur 3545) 
INSERT INTO foo (id,longueur) VALUES(4,434) 
INSERT INTO foo (id,longueur) VALUES(5,45)

Je veux les résultats pour afficher une troisième colonne appelée différence qui est une ligne à soustraire de celui-ci avec la dernière rangée de la soustraction à partir de zéro.

+------+------------------------+ 
| id |longueur | différence | 
+------+------------------------+ 
| 1 | 1090 | 202 | 
| 2 | 888 | 343 | 
| 3 | 545 | 111 | 
| 4 | 434 | 389 | 
| 5 | 45 | 45 |

J'ai essayé une auto-jointure mais je ne suis pas exactement sûr de savoir comment limiter les résultats au lieu de la faire défiler. Je ne peut pas dépendre que de la valeur de l'id sera séquentielle pour un résultat donné, donc je ne suis pas en utilisant cette valeur. Je pourrais étendre le schéma d'inclure une sorte de valeur séquentielle.

C'est ce que j'ai essayé:

SELECT id, f.longueur, f2.la longueur, (f.longueur - f2.la longueur) QUE la différence 
DE foo f, foo f2

Merci à vous pour l'aider.

source d'informationauteur Doc Falken

  1. 13

    Ce qui pourrait vous aider (un peu).

    
select a.id, a.length, 
coalesce(a.length - 
    (select b.length from foo b where b.id = a.id + 1), a.length) as diff
from foo a
  2. 6

    Yipee!!! cela fait l'affaire:

    SELECT  f.id, f.length, 
    (f.length - ISNULL(f2.length,0)) AS diff
FROM foo f
LEFT OUTER JOIN foo f2
ON  f2.id = (f.id +1)

    Veuillez vérifier pour d'autres cas aussi, c'est de travailler pour les valeurs que vous avez posté!
    Remarque c'est pour SQL Server 2005

  3. 2

    De sorte qu'ils sont juste commandé la plus grande à la plus petite?

    SELECT f.id, f.length, (f.length - ISNULL(t.length, 0)) AS difference
FROM foo AS f
LEFT JOIN (
    SELECT f1.id
        ,MAX(f2.length) as length
    FROM foo AS f1
    INNER JOIN foo AS f2
        ON f1.length > f2.length
    GROUP BY f1.id
) AS t -- this is the triangle
    ON t.id = f.id

    Vous pouvez utiliser COALESCE (ou IFNULL) au lieu de ISNULL pour MySQL.

  4. 1

    Ce que quelque chose comme cela:

    SELECT T2.ID, T2.[Length], T2.[Length]-T1.[Length] AS 'Difference'
FROM Foo AS T1 RIGHT OUTER JOIN Foo AS T2 ON ( T1.ID = (T2.ID-1) )
ORDER BY T1.ID
  5. 1
    Select f1.id, f1.seqnum, f2.seqnum, f1.length, f2.length, f1.length-f2.length 

From (

Select Id, length, row_number(order by length) 'seqnum'
From
foo

) f1

Inner join (

Select 
Id, length, row_number(order by length) 'seqnum' from foo union select 0, 0, 0

) f2 

On f1.seqnum = f2.seqnum + 1

Order by f1.length desc
  6. 1

    edit: fixe lors de la re-lecture Q (mal compris)

    SELECT f.id, 
       f2.id, 
       f.length, 
       f2.length, 
       (f.length -f2.length) AS difference
FROM foo f, 
     foo f2 
where f2.id = f.id+1

    id est ambigu

    edit: remarque: testé en mysql 5.0

  7. 0

    J'ai eu ce problème et il est intéressant de regarder vos solutions.
    Je trouve étrange qu'une telle normale problème de la vie est si compliquée dans SQL.
    Comme j'ai besoin de les valeurs dans un rapport seulement, j'ai choisi une solution complètement différente.
    Je suis en cours d'exécution Ruby on Rails avant la fin de ma base de données sqlite3, et viens de faire la soustraction dans la vue comme:

    Dans votre ruby contrôleur, il y a un objet variable @foo qui contient le nombre de lignes retournées par la requête.

    Dans la vue, il suffit de faire

    <table border=1>
  <tr>
    <th>id</th>
    <th>length</th>
    <th>difference</th>
  </tr>

<% for i in 0..@foo.length-1 do %>
  <tr>
    <td><%=h @foo[i].id %></td>
    <td><%=h @foo[i].length %></td>
    <td><% if (i==@foo.length-1) then %>
        <%=  @foo[i].length %>
      <% else %>
        <%= @foo[i+1].length.to_i - @foo[i].length.to_i %>
      <% end %>
    </td>
  </tr>
<% end %>
</table>

    Semble être plus robuste que le SQL des solutions.