SKAPA TABELL (Transact-SQL) IDENTITET (egenskap)

Gäller för:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceAzure Synapse AnalyticsSQL-databas i Förhandsversion av Microsoft Fabric

Skapar en identitetskolumn i en tabell. Den här egenskapen används med satserna CREATE TABLE och ALTER TABLE Transact-SQL.

Transact-SQL syntaxkonventioner

Syntax

IDENTITY [ (seed , increment) ]

Den här syntaxen stöds inte av en serverlös SQL-pool i Azure Synapse Analytics.

Arguments

seed

Det värde som används för den allra första raden som läses in i tabellen.

increment

Det inkrementella värde som läggs till i identitetsvärdet för föregående rad som lästes in.

Du måste ange både fröet och öka eller ingetdera. Om inget av dem anges är standardvärdet (1,1).

Remarks

Identitetskolumner kan användas för att generera nyckelvärden. Identitetsegenskapen i en kolumn garanterar följande villkor:

• Varje nytt värde genereras baserat på aktuellt startvärde och inkrement.

• Varje nytt värde för en viss transaktion skiljer sig från andra samtidiga transaktioner i tabellen.

Identitetsegenskapen i en kolumn garanterar inte följande villkor:

• Värdets unikhet – Unikhet måste framtvingas med hjälp av en begränsning eller UNIQUEUNIQUE ett PRIMARY KEY index.

  Note

  Azure Synapse Analytics stöder PRIMARY KEY inte begränsningar eller UNIQUEUNIQUE index. Mer information finns i Använda IDENTITY för att skapa surrogatnycklar i en Synapse SQL-pool.

• Efterföljande värden inom en transaktion – En transaktion som infogar flera rader garanteras inte att få efterföljande värden för raderna eftersom andra samtidiga infogningar kan förekomma i tabellen. Om värdena måste vara på varandra följande bör transaktionen använda ett exklusivt lås i tabellen eller använda SERIALIZABLE isoleringsnivån.

• Efterföljande värden efter omstart av servern eller andra fel – SQL Server kan cachelagra identitetsvärden av prestandaskäl och vissa av de tilldelade värdena kan gå förlorade vid ett databasfel eller vid omstart av servern. Detta kan resultera i luckor i identitetsvärdet vid infogning. Om luckor inte är acceptabla bör programmet använda sin egen mekanism för att generera nyckelvärden. Om du använder en sekvensgenerator med NOCACHE alternativet kan du begränsa luckor till transaktioner som aldrig har checkats in.

• Återanvändning av värden – För en viss identitetsegenskap med specifik seed/increment återanvänds inte identitetsvärdena av motorn. Om en viss insert-instruktion misslyckas eller om insert-instruktionen återställs går de förbrukade identitetsvärdena förlorade och genereras inte igen. Detta kan leda till luckor när efterföljande identitetsvärden genereras.

Dessa begränsningar är en del av designen för att förbättra prestanda och eftersom de är acceptabla i många vanliga situationer. Om du inte kan använda identitetsvärden på grund av dessa begränsningar skapar du en separat tabell med ett aktuellt värde och hanterar åtkomst till tabell- och nummertilldelningen med ditt program.

Om en tabell med en identitetskolumn publiceras för replikering måste identitetskolumnen hanteras på ett sätt som är lämpligt för den typ av replikering som används. Mer information finns i Replikera identitetskolumner.

Endast en identitetskolumn kan skapas per tabell.

I minnesoptimerade tabeller måste startvärdet och inkrementet anges till 1, 1. Om du anger startvärdet eller inkrementet till ett annat värde än 1 resulterar det i följande fel: The use of seed and increment values other than 1 is not supported with memory optimized tables.

När identitetsegenskapen har angetts för en kolumn kan den inte tas bort. Datatypen kan ändras så länge den nya datatypen är kompatibel med identitetsegenskapen.

Examples

A. Använda identitetsegenskapen med CREATE TABLE

I följande exempel skapas en ny tabell med egenskapen IDENTITY för ett automatiskt inkrementellt identifieringsnummer.

USE AdventureWorks2022;
GO
IF OBJECT_ID('dbo.new_employees', 'U') IS NOT NULL
    DROP TABLE new_employees;
GO

CREATE TABLE new_employees (
    id_num INT IDENTITY(1, 1),
    fname VARCHAR(20),
    minit CHAR(1),
    lname VARCHAR(30)
);

INSERT new_employees (fname, minit, lname)
VALUES ('Karin', 'F', 'Josephs');

INSERT new_employees (fname, minit, lname)
VALUES ('Pirkko', 'O', 'Koskitalo');

B. Använd allmän syntax för att hitta luckor i identitetsvärden

I följande exempel visas allmän syntax för att hitta luckor i identitetsvärden när data tas bort.

-- Here is the generic syntax for finding identity value gaps in data.
-- The illustrative example starts here.
SET IDENTITY_INSERT tablename ON;

DECLARE @minidentval column_type;
DECLARE @maxidentval column_type;
DECLARE @nextidentval column_type;

SELECT @minidentval = MIN($IDENTITY),
    @maxidentval = MAX($IDENTITY)
FROM tablename

IF @minidentval = IDENT_SEED('tablename')
    SELECT @nextidentval = MIN($IDENTITY) + IDENT_INCR('tablename')
    FROM tablename t1
    WHERE $IDENTITY BETWEEN IDENT_SEED('tablename')
            AND @maxidentval
        AND NOT EXISTS (
            SELECT *
            FROM tablename t2
            WHERE t2.$IDENTITY = t1.$IDENTITY + IDENT_INCR('tablename')
            )
ELSE
    SELECT @nextidentval = IDENT_SEED('tablename');

SET IDENTITY_INSERT tablename OFF;

-- Here is an example to find gaps in the actual data.
-- The table is called img and has two columns: the first column
-- called id_num, which is an increasing identification number, and the
-- second column called company_name.
-- This is the end of the illustration example.
-- Create the img table.
-- If the img table already exists, drop it.
-- Create the img table.
IF OBJECT_ID('dbo.img', 'U') IS NOT NULL
    DROP TABLE img;
GO

CREATE TABLE img (
    id_num INT IDENTITY(1, 1),
    company_name SYSNAME
);

INSERT img (company_name)
VALUES ('New Moon Books');

INSERT img (company_name)
VALUES ('Lucerne Publishing');

-- SET IDENTITY_INSERT ON and use in img table.
SET IDENTITY_INSERT img ON;

DECLARE @minidentval SMALLINT;
DECLARE @nextidentval SMALLINT;

SELECT @minidentval = MIN($IDENTITY)
FROM img

IF @minidentval = IDENT_SEED('img')
    SELECT @nextidentval = MIN($IDENTITY) + IDENT_INCR('img')
    FROM img t1
    WHERE $IDENTITY BETWEEN IDENT_SEED('img')
            AND 32766
        AND NOT EXISTS (
            SELECT *
            FROM img t2
            WHERE t2.$IDENTITY = t1.$IDENTITY + IDENT_INCR('img')
            )
ELSE
    SELECT @nextidentval = IDENT_SEED('img');

SET IDENTITY_INSERT img OFF;

Related content

• ALTER TABLE (Transact-SQL)
• SKAPA TABELL (Transact-SQL)
• DBCC CHECKIDENT (Transact-SQL)
• IDENT_INCR (Transact-SQL)
• @@IDENTITY (Transact-SQL)
• Identitet (funktion) (Transact-SQL)
• IDENT_SEED (Transact-SQL)
• SELECT (Transact-SQL)
• SET IDENTITY_INSERT (Transact-SQL)
• Replikera identitetskolumner