'Id' con il formato: AAAAMMGNNNN con la parte NNNNNN che si riavvia ogni anno

Ho un requisito aziendale che ogni record nella tabella Fattura abbia un ID che assomiglia a AAAAMMGNNNN.

La parte NNNNNN deve essere riavviata all'inizio di ogni anno. Quindi la prima riga immessa nel 2016 sarebbe simile a 2016000001 e la seconda come 2016000002 ecc. Supponiamo che l'ultimo record per il 2016 sia stato 2016123456, La riga successiva (del 2017) dovrebbe apparire come 2017000001

Non ho bisogno che questo ID sia la chiave primaria e memorizzo anche la data di creazione. L'idea è che questo "ID di visualizzazione" sia unico (quindi posso interrogarlo da esso) e capace di essere utilizzato da gruppi umani, per anno.

È improbabile che qualsiasi record venga cancellato; tuttavia, sarei propenso a codificare sulla difensiva qualcosa del genere.

Esiste un modo per creare questo ID senza dover richiedere l'id massimo quest'anno ogni volta che inserisco una nuova riga?

idee:

• A CreateNewInvoiceSP, che ottiene il MAXvalore per quell'anno (schifo)
• Alcune funzionalità magiche integrate per fare esattamente questo (posso sognare bene)
• Essere in grado di specificare un UDF o qualcosa nella dichiarazione IDENTITYo DEFAULT(??)
• Una vista che utilizza PARTITION OVER + ROW()(eliminata sarebbe problematica)
• Un trigger attivato INSERT(sarebbe comunque necessario eseguire alcune MAXquery :()
• Un lavoro in background annuale, aggiornato una tabella con il MAX per ogni anno inserito che poi ... Qualcosa ?!

Tutto ciò non è l'ideale. Eventuali idee o variazioni sono benvenute!

Ci sono 2 elementi nel tuo campo

• Anno
• Un numero con incremento automatico

Non è necessario che siano memorizzati come un campo

Esempio:

• Una colonna dell'anno con un valore predefinito di YEAR(GETDATE())
• Una colonna numerica basata su una sequenza.

Quindi creare una colonna calcolata concatenandoli (con la formattazione appropriata). La sequenza può essere ripristinata al cambio di anno.

Codice di esempio in SQLfiddle : ^{* (SQLfiddle non funziona sempre)}

-- Create a sequence
CREATE SEQUENCE CountBy1
    START WITH 1
    INCREMENT BY 1 ;

-- Create a table
CREATE TABLE Orders
    (Yearly int NOT NULL DEFAULT (YEAR(GETDATE())),
    OrderID int NOT NULL DEFAULT (NEXT VALUE FOR CountBy1),
    Name varchar(20) NOT NULL,
    Qty int NOT NULL,
    -- computed column
    BusinessOrderID AS RIGHT('000' + CAST(Yearly AS VARCHAR(4)), 4)
                     + RIGHT('00000' + CAST(OrderID AS VARCHAR(6)), 6),
    PRIMARY KEY (Yearly, OrderID)
    ) ;


-- Insert two records for 2015
INSERT INTO Orders (Yearly, Name, Qty)
    VALUES
     (2015, 'Tire', 7),
     (2015, 'Seat', 8) ;


-- Restart the sequence (Add this also to an annual recurring 'Server Agent' Job)
ALTER SEQUENCE CountBy1
    RESTART WITH 1 ;

-- Insert three records, this year.
INSERT INTO Orders (Name, Qty)
    VALUES
     ('Tire', 2),
     ('Seat', 1),
     ('Brake', 1) ;

Hai considerato di creare un campo identità con seed = 2016000000?

 create table Table1 (
   id bigint identity(2016000000,1),
   field1 varchar(20)...
)

Questo seme dovrebbe essere autoincrementato ogni anno, ad esempio nella notte del 2017/1/1 che devi programmare

DBCC CHECKIDENT (Table1, RESEED, 2017000000)

Ma vedo già problemi con il design, ad esempio: cosa succede se hai milioni di record?

Quello che ho fatto in questo scenario è stato moltiplicare l'anno per 10 ^ 6 e aggiungere il valore della sequenza a quello. Ciò ha il vantaggio di non richiedere un campo calcolato con il suo (piccolo) overhead in corso e il campo può essere utilizzato come PRIMARY KEY.

Esistono due possibili gotcha:

• assicurati che il tuo moltiplicatore sia sufficientemente grande da non essere mai esaurito, e

• non è garantita una sequenza senza lacune a causa della memorizzazione nella cache della sequenza.

Non sono un esperto di SQL Server, ma probabilmente puoi impostare un evento da attivare a 201x 00:00:00 per ripristinare la sequenza su zero. Questo è anche quello che ho fatto su Firebird (o era Interbase?).

Modifica: questa soluzione non funziona sotto carico

Non sono un fan dei fattori scatenanti, ma questo mi sembra meglio che potrei capire.

Professionisti:

• Nessun lavoro in background
• Può eseguire query rapide su DisplayId
• Il trigger non deve eseguire la scansione per la parte NNNNNN precedente
• Riavvia la parte NNNNN ogni anno
• Funzionerà se ci sono più di 100000 righe all'anno
• Non richiede aggiornamenti dello schema (ad es. Ripristini di sequenza) per continuare a funzionare in futuro

Modifica: Contro:

• Fallirà sotto carico (torna al tavolo da disegno)

(Ringraziamo @gbn perché ho preso ispirazione dalla loro risposta) (Qualsiasi feed back e sottolineando gli ovvi errori benvenuti :)

Aggiungi alcuni nuovi se COLUMNunINDEX

ALTER TABLE dbo.Invoices
ADD     [NNNNNNId]      INT  NULL 

ALTER TABLE dbo.Invoices
ADD [Year]              int NOT NULL DEFAULT (YEAR(GETDATE()))

ALTER TABLE dbo.Invoices
ADD [DisplayId]     AS  'INV' +
                        CAST([Year] AS VARCHAR(4))+
                        RIGHT('00000' + CAST([NNNNNNId] AS VARCHAR(4)),  IIF (5  >= LEN([NNNNNNId]), 5, LEN([NNNNNNId])) )                  

EXEC('CREATE NONCLUSTERED INDEX IX_Invoices_DisplayId
ON dbo.Invoices (DisplayId)')

Aggiungi il nuovo TRIGGER

CREATE TRIGGER Invoices_DisplayId
ON dbo.Invoices
  AFTER  INSERT
AS 
BEGIN

SET NOCOUNT ON;    

UPDATE dbo.Invoices
SET NNNNNNId = CalcDisplayId
FROM (SELECT I.ID, IIF (Previous.Year = I.Year , (ISNULL(Previous.NNNNNNId,0) + 1), 1) AS CalcDisplayId  FROM
        (SELECT 
            ID  
           ,NNNNNNId 
           ,[year]
        FROM  dbo.Invoices
        ) AS Previous
    JOIN inserted AS I 
    ON Previous.Id = (I.Id -1) 
    ) X
WHERE 
   X.Id = dbo.Invoices.ID       
END
GO