So che c'è molto qui. Ho cercato di documentarlo piuttosto bene all'interno del codice e qua e là. Utilizza stored procedure. Puoi naturalmente estrarre il codice e non utilizzare quel metodo. Utilizza un tavolo principale che ospita i successivi incrementatori disponibili. Utilizza INNODB sicuro Intention Locks per concorrenza. Ha una tabella di riutilizzo e processi memorizzati per supportarlo.
Non utilizza in alcun modo la tabella myTable . Viene mostrato lì per la tua immaginazione in base ai commenti sotto la tua domanda. Il riassunto è che sai che avrai delle lacune su DELETE . Vuoi un po' di moda ordinata per riutilizzare quegli slot, quei numeri di sequenza. Quindi, quando DELETE una riga, utilizzare i processi memorizzati di conseguenza per aggiungere quel numero. Naturalmente c'è un processo memorizzato per ottenere il numero di sequenza successivo per il riutilizzo e altre cose.
Ai fini del test, il tuo sectionType ='dispositivi'
E soprattutto è testato!
Schema:
create table myTable
( -- your main table, the one you cherish
`id` int auto_increment primary key, -- ignore this
`seqNum` int not null, -- FOCUS ON THIS
`others` varchar(100) not null
) ENGINE=InnoDB;
create table reuseMe
( -- table for sequence numbers to reuse
`seqNum` int not null primary key, -- FOCUS ON THIS
`reused` int not null -- 0 upon entry, 1 when used up (reused)
-- the primary key enforces uniqueness
) ENGINE=InnoDB;;
CREATE TABLE `sequences` (
-- table of sequence numbers system-wide
-- this is the table that allocates the incrementors to you
`id` int NOT NULL AUTO_INCREMENT,
`sectionType` varchar(200) NOT NULL,
`nextSequence` int NOT NULL,
PRIMARY KEY (`id`),
UNIQUE KEY `sectionType` (`sectionType`)
) ENGINE=InnoDB;
INSERT sequences(sectionType,nextSequence) values ('devices',1); -- this is the focus
INSERT sequences(sectionType,nextSequence) values ('plutoSerialNum',1); -- not this
INSERT sequences(sectionType,nextSequence) values ('nextOtherThing',1); -- not this
-- the other ones are conceptuals for multi-use of a sequence table
Processo memorizzato:uspGetNextSequence
DROP PROCEDURE IF EXISTS uspGetNextSequence;
DELIMITER $$
CREATE PROCEDURE uspGetNextSequence(p_sectionType varchar(200))
BEGIN
-- a stored proc to manage next sequence numbers handed to you.
-- driven by the simple concept of a name. So we call it a section type.
-- uses SAFE INNODB Intention Locks to support concurrency
DECLARE valToUse INT;
START TRANSACTION;
SELECT nextSequence into valToUse from sequences where sectionType=p_sectionType FOR UPDATE;
IF valToUse is null THEN
SET valToUse=-1;
END IF;
UPDATE sequences set nextSequence=nextSequence+1 where sectionType=p_sectionType;
COMMIT; -- get it and release INTENTION LOCK ASAP
SELECT valToUse as yourSeqNum; -- return as a 1 column, 1 row resultset
END$$
DELIMITER ;
-- ****************************************************************************************
-- test:
call uspGetNextSequence('devices'); -- your section is 'devices'
Dopo aver chiamato uspGetNextSequence() è tua RESPONSABILITÀ assicurarti che quella sequenza #
viene aggiunto a myTable (confermandolo), o che se fallisce lo inserisca in
la tabella di riutilizzo con una chiamata a uspAddToReuseList(). Non tutti gli inserti hanno successo. Concentrati su questa parte.
Perché con questo codice non puoi "rimetterlo" nelle sequences tabella a causa di
concorrenza, altri utenti e l'intervallo già superato. Quindi, semplicemente, se l'inserimento fallisce,
inserisci il numero in reuseMe tramite uspAddToReuseList()
...
Processo memorizzato:uspAddToReuseList:
DROP PROCEDURE IF EXISTS uspAddToReuseList;
DELIMITER $$
CREATE PROCEDURE uspAddToReuseList(p_reuseNum INT)
BEGIN
-- a stored proc to insert a sequence num into the reuse list
-- marks it available for reuse (a status column called `reused`)
INSERT reuseMe(seqNum,reused) SELECT p_reuseNum,0; -- 0 means it is avail, 1 not
END$$
DELIMITER ;
-- ****************************************************************************************
-- test:
call uspAddToReuseList(701); -- 701 needs to be reused
Processo memorizzato:uspGetOneToReuse:
DROP PROCEDURE IF EXISTS uspGetOneToReuse;
DELIMITER $$
CREATE PROCEDURE uspGetOneToReuse()
BEGIN
-- a stored proc to get an available sequence num for reuse
-- a return of -1 means there aren't any
-- the slot will be marked as reused, the row will remain
DECLARE retNum int; -- the seq number to return, to reuse, -1 means there isn't one
START TRANSACTION;
-- it is important that 0 or 1 rows hit the following condition
-- also note that FOR UPDATE is the innodb Intention Lock
-- The lock is for concurrency (multiple users at once)
SELECT seqNum INTO retNum
FROM reuseMe WHERE reused=0 ORDER BY seqNum LIMIT 1 FOR UPDATE;
IF retNum is null THEN
SET retNum=-1;
ELSE
UPDATE reuseMe SET reused=1 WHERE seqNum=retNum; -- slot used
END IF;
COMMIT; -- release INTENTION LOCK ASAP
SELECT retNum as yoursToReuse; -- >0 or -1 means there is none
END$$
DELIMITER ;
-- ****************************************************************************************
-- test:
call uspGetOneToReuse();
Processo memorizzato:uspCleanReuseList:
DROP PROCEDURE IF EXISTS uspCleanReuseList;
DELIMITER $$
CREATE PROCEDURE uspCleanReuseList()
BEGIN
-- a stored proc to remove rows that have been successfully reused
DELETE FROM reuseMe where reused=1;
END$$
DELIMITER ;
-- ****************************************************************************************
-- test:
call uspCleanReuseList();
Processo memorizzato:uspOoopsResetToAvail:
DROP PROCEDURE IF EXISTS uspOoopsResetToAvail;
DELIMITER $$
CREATE PROCEDURE uspOoopsResetToAvail(p_reuseNum INT)
BEGIN
-- a stored proc to deal with a reuse attempt (sent back to you)
-- that you need to reset the number as still available,
-- perhaps because of a failed INSERT when trying to reuse it
UPDATE reuseMe SET reused=0 WHERE seqNum=p_reuseNum;
END$$
DELIMITER ;
-- ****************************************************************************************
-- test:
call uspOoopsResetToAvail(701);
Idee per il flusso di lavoro:
Lascia che GNS significa una chiamata a uspGetNextSequence() .
Lascia che RS significa Sequenza di riutilizzo tramite una chiamata a uspGetOneToReuse()
Quando un nuovo INSERT si desidera, chiamare RS :
R. Se RS restituisce -1 quindi nulla deve essere riutilizzato, quindi chiama GNS che restituisce N. Se riesci a INSERT con myTable.seqNum=N con una conferma, hai finito. Se non riesci a INSERT it, quindi chiama uspAddToReuseList(N) .
B. Se RS restituisce> 0, nota nella tua testa che lo slot ha reuseMe.reused=1 , una buona cosa da ricordare. Quindi si presume che sia in procinto di essere riutilizzato con successo. Chiamiamo quel numero di sequenza N. Se riesci a INSERT con successo con myTable.seqNum=N con una conferma, hai finito. Se non riesci a INSERT it, quindi chiama uspOoopsResetToAvail(N) .
Quando ritieni sicuro chiamare uspCleanReuseList() fare così. Aggiunta di un DATETIME al reuseMe table potrebbe essere una buona idea, indicando quando una riga da myTable originariamente stava eliminando e causando il reuseMe riga per ottenere il suo INSERT originale .
