valori di spostamento lungo la catena in una tabella

Question

a condizione che ho il seguente set di risultati da una tabella di database mysql:

+----+------+-------+ 
| ID | type | value | 
+----+------+-------+ 
| 8 | A | 1435 | 
| 9 | B | 7348 | 
| 10 | A | 1347 | 
| 11 | A | 3478 | 
| 12 | A | 4589 | 
| 13 | B | 6789 | 
+----+------+-------+ 

Vorrei eliminare la riga ID 8 e spingere i valori nel campo 'valore' in basso, in modo tale che ogni riga abbia il valore della voce precedente, ma influisce solo su quelli in cui il campo 'tipo' è uguale alla riga che si sta eliminando ('A' in questo caso).

Vale a dire, la cancellazione fila id 8 alla fine dovrebbe produrre il seguente:

+----+------+-------+ 
| ID | type | value | 
+----+------+-------+ 
| - | - | - | * 
| 9 | B | 7348 | | 
| 10 | A | 1435 | * | 
| 11 | A | 1347 | * | 
| 12 | A | 3478 | * | 
| 13 | B | 6789 | V 
+----+------+-------+ 

ID 10 ha ereditato il valore ID 8, quindi ID 11 eredita da ID 10, e così via. Si noti tuttavia come le righe con tipo "B" non sono interessate.

Quindi la domanda: esiste un modo per eseguire questo "spostamento" dei valori senza dover interrogare e aggiornare ogni riga una per una? In un mondo ideale vorrei fare una query per fare shift e poi un'altra per cancellare la riga, ma non sono del tutto sicuro se questo è possibile.

(Anche io preferirei non utilizzare i trigger, dal momento che ho intenzione incapsulare tutta la logica dell'applicazione all'interno dell'applicazione stessa)

Answer 1

SET @remove_id = 8; 

SELECT ID, type, value FROM (
    SELECT ID, 
      type, 
      CAST(IF(type <> @type OR ISNULL(@val), value, @val) AS UNSIGNED) 
      AS value, 
      @type := IF(ID = @remove_id, type, @type), 
      @val := IF(type = @type, value, @val) 
    FROM  my_table JOIN (SELECT @type := NULL, @val := NULL) AS z 
    ORDER BY ID ASC 
) AS t 
WHERE ID <> @remove_id 

vedi sul sqlfiddle.

---

UPDATE

Non avevo capito che in realtà ha voluto aggiornare la tabella sottostante. Per fare ciò, è possibile utilizzare un po 'di hackery per fare effettivamente la stessa cosa in un'istruzione UPDATE (non è possibile assegnare direttamente le variabili utente, quindi assegnare a una colonna la concatenazione del suo nuovo valore e una stringa nulla formata dall'assunzione del primi 0 caratteri della variabile utente appena assegnato):

SET @remove_id = 8, @type = NULL, @val = NULL; 

UPDATE my_table SET 
    value = IF(
    type <> @type OR ISNULL(@val), 
    value, 
    CONCAT(@val, LEFT(@val := value, 0)) 
), 
    type = CONCAT(type, LEFT(
    @type := IF(
     ID <> @remove_id, 
     @type, 
     CONCAT(type, LEFT(@val := value, 0)) 
    ) 
    , 0)) 
ORDER BY ID ASC; 

DELETE FROM my_table WHERE ID = @remove_id; 

Vedi sulla sqlfiddle.

Answer 2

vorrei suggerire di utilizzare le tabelle InnoDB in modo da poter eseguire le 2 domande in una singola transazione. farei questo:

Step 1: Start a transaction on the table 
Step 2: Get the record that is to be deleted (e.g. ID #8) 
Step 3: Issue a query DELETE FROM tablename WHERE `ID`=$record_id 
Step 4: Issue a query UPDATE tablename SET `value`='former_value' WHERE `type`='former_type' LIMIT 1 
Step 5: if all operations were successful, commit the transaction else rollback 
Step 6: End the transaction 

Spero che questo aiuti

Answer 3

Questa operazione viene eseguita molto facilmente utilizzando le funzioni finestra/analitiche. Dato che MySQL non ha tale, possono essere simulati con la seguente restrizione:

• si dovrebbe avere un campo unico su cui ordinare.

Ho utilizzato id per questo scopo.

La seguente query enumarte ogni riga della tabella, utilizzando type come indicatore di partizione:

SELECT t.id, t.type, t.value, 
    (SELECT count(*) FROM testbed WHERE type = t.type AND id <= t.id) AS rownum 
    FROM testbed t 
ORDER BY t.type, t.id; 

Ho aggiunto ORDER BY solo per visibilità, non è richiesto nella query finale.

interrogazione successiva consente di unire 2 risultati ed avere modo di “valori di spostamento”, il modo necessario:

SELECT c.id AS c_id, c.type AS c_type, c.value AS c_value, 
     p.id AS p_id, p.type AS p_type, p.value AS p_value 
    FROM (SELECT t.id, t.type, t.value, 
       (SELECT count(*) FROM testbed 
       WHERE type = t.type AND id <= t.id) AS rownum 
      FROM testbed t) AS c 
    LEFT JOIN (SELECT t.id, t.type, t.value, 
        (SELECT count(*) FROM testbed 
         WHERE type = t.type AND id <= t.id) AS rownum 
       FROM testbed t) AS p 
     ON c.type = p.type AND c.rownum = p.rownum + 1 
ORDER BY c.type, c.id; 

Infine, il vostro compito è compiuta con i seguenti 2 domande, UPDATE e DELETE:

UPDATE testbed AS t 
JOIN (
    SELECT c.id AS c_id, c.type AS c_type, c.value AS c_value, 
     p.id AS p_id, p.type AS p_type, p.value AS p_value 
    FROM (SELECT t.id, t.type, t.value, 
       (SELECT count(*) FROM testbed 
        WHERE type = t.type AND id <= t.id) AS rownum 
      FROM testbed t) AS c 
    LEFT JOIN (SELECT t.id, t.type, t.value, 
         (SELECT count(*) FROM testbed 
         WHERE type = t.type AND id <= t.id) AS rownum 
       FROM testbed t) AS p 
      ON c.type = p.type AND c.rownum = p.rownum + 1 
) AS s 
    ON t.id = s.c_id 
    SET t.value = s.p_value 
WHERE t.value = 'A'; -- you can use more complex predicate(s) here 

DELETE FROM testbed WHERE id = 8; -- make sure both predicate(s) match 

È possibile verificare questa query su SQL Fiddle (non gli aggiornamenti).