curseur de mettre à jour une ligne avec les valeurs de la précédente et actuelle des lignes

Collègues Requête Écrivains,

J'ai un tableau comme suit:

myTable t1
col2 col3
 2    1
 3    0
 4    0
 5    0
 6    0

et je veux mettre à jour chaque zéro sur col3 avec la valeur de col3 dans la rangée précédente, majorée de la valeur de col2 de la ligne actuelle. Donc ma table de comme suit:

myTable t1
col2 col3
 2    1 
 3    4  (1+3)
 4    8  (4+4)
 5    13 (5+8) 
 6    19 (6+13)

Je suis absent la logique ici, la myopie peut-être. J'ai essayé avec un curseur comme suit:

DECLARE @var3 FLOAT

DECLARE cursor3 CURSOR FOR
SELECT col2, col3 FROM table1
FOR UPDATE OF col3
OPEN cursor3


FETCH FIRST FROM cursor3
WHILE (@@FETCH_STATUS > -1)
BEGIN
 UPDATE @table1
 SET col3 = isnull(@var3, 0) + isnull(col2, 0)
 WHERE CURRENT OF cursor3
 FETCH NEXT FROM cursor3 INTO @var3
END

mais c'est faux.
Des idées?

Merci d'avance.

Avez-vous une autre colonne, comme une colonne d'ID sur la table? les curseurs sont presque jamais une bonne idée...
D'autres colonnes, mais pas de Clé Primaire. C'est une table temporaire pour générer des rapports. Je suis assez convaincu que les curseurs existent pour ce type de problèmes.
Les curseurs existent pour ce type de problèmes, mais cela ne veut pas dire qu'ils sont le meilleur/le plus approprié. Si vous ajoutez une colonne d'identité à votre table temp c'est environ la 10000x plus facile.
Si j'ajoute une colonne d'Identité, comment pourrais-je résoudre le problème, alors?
Je suis en train d'écrire la requête, donnez-moi une minute 🙂
faire de votre temps.
MMMMMMMMMMMMMMM peut-être pas, puisque vous souhaitez utiliser la mise à jour de la valeur pour calculer la ligne suivante.
Oh que oui! Leçon du jour: ne jamais dénigrer les curseurs de nouveau. Écrire sur le tableau noir 100 fois. Merci quand même! 🙂
Mensonges, je l'ai eu. Vérifier la réponse ci-dessous! 🙂

InformationsquelleAutor Lynx Kepler | 2010-11-03

9

OK, Essayez ceci.
```
CREATE TABLE MyTable (Id INT Identity, Col2 int, Col3 int)

INSERT INTO MyTable (Col2, Col3)
VALUES (2,1), (3,0), (4,0),(5,0),(6,0)

SELECT * from MyTable

WHILE (SELECT COUNT(*) FROM MyTable WHERE Col3=0) > 0
BEGIN
    UPDATE TOP (1) MyTable
    SET CoL3 = (Mytable.col2 + (select col3 from mytable t2 where (t2.id = mytable.id-1)))
    WHERE Col3 = 0
END

SELECT * from MyTable
```
Utilise un WHILE boucle qui doit être plus rapide qu'un curseur dans la plupart des circonstances.
- Donc il fait ce que vous voulez? Quelle est la taille réelle de jeu de données et est-il assez rapide? Vous pouvez bien évidemment modifier pour utiliser #Temp ou @TableVar type de tables de trop, j'ai juste fait un réel, l'autre pour le tester.
- Le jeu de données est d'environ 100 lignes, toute solution est acceptable. Le temps total est de moins de 2 secondes, tout inclus. J'utilise un @tableVar. Merci pour votre temps consacré !
- Heureux de vous aider!_
- Toute autre approche que l'utilisation de la boucle While, coz dans mon cas, les enregistrements dans la table pourrait être autour de 200 000, et à l'aide de la boucle while, puis définitivement ralentit les choses.
- vous pouvez remplacer le conditionnel dans le temps à un EXISTE qui devrait être plus rapide car il les courts-circuits. Le nombre de dossiers ne sera pas de trop. Si vous avez besoin d'être VRAIMENT rapide, vous pouvez utiliser votre PK pour parcourir les dossiers de trop, c'est à dire seulement le travail sur le PK des valeurs entre 1 et 10,000 pour la première boucle, puis faire la prochaine 10k etc.
- Merci pour la réponse, j'ai reçu la première partie de votre réponse. Pourriez-vous expliquer deuxième partie, c'est à dire en boucle sur les valeurs de clé primaire dans les parties par le biais de tout Tripoter? Ce serait très utile.
InformationsquelleAutor JNK

J'ai ajouté une colonne d'identité à ma table et a fini à l'aide d'un code comme ceci:

DECLARE @saldo_Q_previous FLOAT
DECLARE @ID INTEGER

DECLARE cursor3 CURSOR FOR
SELECT ID FROM @myTable
FOR UPDATE OF col2
OPEN cursor3

FETCH NEXT FROM cursor3 INTO @ID
FETCH NEXT FROM cursor3 INTO @ID

WHILE (@@FETCH_STATUS > -1)
BEGIN

    SET @col2_previous = ISNULL((SELECT TOP 1 col2 FROM @myTable WHERE ID < @ID ORDER BY ID DESC), 0)
    SET @vrQ = ISNULL((SELECT TOP 1 vr_Q FROM @myTable WHERE ID < @ID ORDER BY ID DESC), 0)

    UPDATE @myTable
    SET col2 = isnull(@col2_previous, 0) + isnull(vrMov_Q, 0)
    WHERE CURRENT OF cursor3

    FETCH NEXT FROM cursor3 INTO @ID
END

CLOSE cursor3
DEALLOCATE cursor3

Il a résolu mon problème. Merci à vous tous.

InformationsquelleAutor Lynx Kepler

0

Voici une instruction de mise à JOUR qui utilise des expressions de table communes (CTE) pour mettre à jour les données.
```
WITH myTable2 AS
    (
    SELECT col2, col3, ROW_NUMBER() OVER (ORDER BY col2) AS sequence
    FROM myTable
    ),
  newTable AS
    (
    SELECT t1.col2, SUM(t2.col2) - SUM(t2.col3) AS col3
    FROM myTable2 t1
    LEFT OUTER JOIN myTable2 t2 ON t1.sequence >= t2.sequence
    GROUP BY t1.col2
    )

UPDATE myTable
SET col3 = newTable.col3
FROM myTable
JOIN newTable on myTable.col2 = newTable.col2
;
```
- c'est que récursive? c'est à dire il va utiliser la mise à jour de la valeur de la colonne 3 pour la ligne suivante?
- Ce n'est pas récursive. Avis dans la nouvelletable CTE, la condition de jointure utilise un >= de sorte qu'il peut la somme de toutes les copies précédentes de col2. La somme de col3 est un moyen facile de soustraire le 1 dans la première rangée.
InformationsquelleAutor bobs
0

FWIW de La principale raison impérieuse d'utiliser un CURSEUR est en ne le faisant pas, allez mettre trop d'un coup sur votre sgbdr. Vous pouvez presque toujours utiliser une boucle WHILE au lieu d'un CURSEUR; traitement d'UN enregistrement à la fois, qui peut être très utile lorsque, pour quelque raison que ce soit vous devrez peut-être effectuer une itération sur un grand nombre de documents... les opérations de CURSEUR sont encore plus efficaces que l'équivalent de l'opération.

Donc, en général, il revient à la vitesse & les frais généraux et efficacité...

Les CURSEURS sont en assez beaucoup la façon la plus lente, mais ont le moins de frais généraux et sont toujours utile, même dans MSSQL 2012 ...

InformationsquelleAutor OldSqlDude

Vous devez vous connecter pour publier un commentaire.