BULK INSATS (Transact-SQL)

Gäller för:SQL ServerAzure SQL DatabaseAzure SQL Managed InstanceLager i Microsoft Fabric

Importerar en datafil till en databastabell eller vy i ett användarangivet format i SQL Server.

Transact-SQL syntaxkonventioner

Syntax

BULK INSERT
   { database_name.schema_name.table_or_view_name | schema_name.table_or_view_name | table_or_view_name }
      FROM 'data_file'
     [ WITH
    (
   [ [ , ] DATA_SOURCE = 'data_source_name' ]

   -- text formatting options
   [ [ , ] CODEPAGE = { 'RAW' | 'code_page' | 'ACP' | 'OEM' } ]
   [ [ , ] DATAFILETYPE = { 'char' | 'native' | 'widechar' | 'widenative' } ]
   [ [ , ] ROWTERMINATOR = 'row_terminator' ]
   [ [ , ] FIELDTERMINATOR = 'field_terminator' ]
   [ [ , ] FORMAT = 'CSV' ]
   [ [ , ] FIELDQUOTE = 'quote_characters' ]

   [ [ , ] FIRSTROW = first_row ]
   [ [ , ] LASTROW = last_row ]

   -- input file format options
   [ [ , ] FORMATFILE = 'format_file_path' ]
   [ [ , ] FORMATFILE_DATA_SOURCE = 'data_source_name' ]

   -- error handling options
   [ [ , ] MAXERRORS = max_errors ]
   [ [ , ] ERRORFILE = 'file_name' ]
   [ [ , ] ERRORFILE_DATA_SOURCE = 'errorfile_data_source_name' ]

   -- database options
   [ [ , ] KEEPIDENTITY ]
   [ [ , ] KEEPNULLS ]
   [ [ , ] FIRE_TRIGGERS ]
   [ [ , ] CHECK_CONSTRAINTS ]
   [ [ , ] TABLOCK ]

   -- source options
   [ [ , ] ORDER ( { column [ ASC | DESC ] } [ , ...n ] ) ]
   [ [ , ] ROWS_PER_BATCH = rows_per_batch ]
   [ [ , ] KILOBYTES_PER_BATCH = kilobytes_per_batch
   [ [ , ] BATCHSIZE = batch_size ]

    ) ]

Argument

Instruktionen BULK INSERT har olika argument och alternativ på olika plattformar. Skillnaderna sammanfattas i följande tabell:

database_name

Databasnamnet där den angivna tabellen eller vyn finns. Om det inte anges är database_name den aktuella databasen.

schema_name

Anger namnet på tabellen eller visningsschemat. schema_name är valfritt om standardschemat för användaren som utför massimportåtgärden är schemat för den angivna tabellen eller vyn. Om schema inte har angetts och standardschemat för användaren som utför massimportåtgärden skiljer sig från den angivna tabellen eller vyn returnerar SQL Server ett felmeddelande och massimportåtgärden avbryts.

table_name

Anger namnet på tabellen eller vyn som massimportera data till. Endast vyer där alla kolumner refererar till samma bastabell kan användas. Mer information om begränsningarna för att läsa in data i vyer finns i INSERT.

FRÅN "data_file"

Anger den fullständiga sökvägen till den datafil som innehåller data som ska importeras till den angivna tabellen eller vyn. BULK INSERT kan importera data från en disk eller Azure Blob Storage (inklusive nätverk, diskett, hårddisk och så vidare).

BULK INSERT bing_covid_19_data
FROM 'C:\\bing_covid-19_data\public\curated\covid-19\latest\bing_covid-19_data.csv';

data_file måste ange en giltig sökväg från servern där SQL Server körs. Om data_file är en fjärrfil anger du UNC-namnet (Universal Naming Convention). Ett UNC-namn har formuläret \\SystemName\ShareName\Path\FileName. Till exempel:

BULK INSERT bing_covid_19_data
FROM '\\ShareX\bing_covid-19_data\public\curated\covid-19\latest\bing_covid-19_data.csv';

Azure SQL Database och Fabric Warehouse stöder endast läsning från Azure Blob Storage.

Från och med SQL Server 2017 (14.x) kan data_file finnas i Azure Blob Storage. I så fall måste du också ange data_source_name alternativ. Ett exempel finns i Importera data från en fil i Azure Blob Storage.

Infrastrukturlager stöder två olika sökvägsformat för att ange källsökväg:

• https://<storage account>.blob.core.windows.net/<container name>/<path to file>
• abfss://<container name>@<storage account>.dfs.core.windows.net/<path to file>

Fabric Warehouse stöder * jokertecken som kan matcha alla tecken i URI:n och gör att du kan definiera ett URI-mönster för de filer som ska importeras. Till exempel:

BULK INSERT bing_covid_19_data
FROM 'https://<data-lake>.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/*.csv';

BATCHSTORLEK = batch_size

Anger antalet rader i en batch. Varje batch kopieras till servern som en transaktion. Om detta misslyckas checkar SQL Server in eller återställer transaktionen för varje batch. Som standard är alla data i den angivna datafilen en batch. Information om prestandaöverväganden finns i Prestandaöverväganden senare i den här artikeln.

KONTROLLBEGRÄNSNINGAR

Anger att alla begränsningar i måltabellen eller vyn måste kontrolleras under massimportåtgärden. Utan alternativet CHECK_CONSTRAINTS ignoreras eventuella CHECK begränsningar och FOREIGN KEY efter åtgärden markeras villkoret för tabellen som ej betrott.

UNIQUE begränsningar PRIMARY KEY tillämpas alltid. När du importerar till en teckenkolumn som har definierats med en NOT NULL begränsning infogar BULK INSERT en tom sträng när det inte finns något värde i textfilen.

Någon gång måste du undersöka begränsningarna för hela tabellen. Om tabellen inte var tom före massimportåtgärden kan kostnaden för att återuppta begränsningen överskrida kostnaden för att tillämpa CHECK begränsningar på inkrementella data.

En situation där du kanske vill inaktivera begränsningar (standardbeteendet) är om indata innehåller rader som bryter mot begränsningar. Med CHECK begränsningar inaktiverade kan du importera data och sedan använda Transact-SQL-instruktioner för att ta bort ogiltiga data.

CODEPAGE = { 'ACP' | OEM | 'RAW' | 'code_page' }

Anger kodsidan för data i datafilen. CODEPAGE är endast relevant om data innehåller tecken-, varchar- eller textkolumner med teckenvärden som är större än 127 eller mindre än 32. Ett exempel finns i Ange en kodsida.

BULK INSERT bing_covid_19_data
FROM 'https://<data-lake>.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.csv'
WITH (CODEPAGE = '65001', FIRSTROW = 2);

CODEPAGE är inte ett alternativ som stöds i Linux för SQL Server 2017 (14.x). För SQL Server 2019 (15.x) tillåts endast 'RAW' alternativet för CODEPAGE.

Du bör ange ett sorteringsnamn för varje kolumn i en formatfil.

DATAFILETYPE = { 'char' | "native" | "widechar" | "widenative" }

Anger som BULK INSERT utför importåtgärden med det angivna värdet för datafilstyp.

BULK INSERT bing_covid_19_data
FROM 'https://<data-lake>.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.csv'
WITH (DATAFILETYPE = 'char', FIRSTROW = 2);

DATA_SOURCE = "data_source_name"

Gäller för: SQL Server 2017 (14.x) och senare versioner och Azure SQL Database.

Anger en namngiven extern datakälla som pekar på Azure Blob Storage-platsen för filen som ska importeras. Den externa datakällan måste skapas med hjälp av alternativet TYPE = BLOB_STORAGE som lades till i SQL Server 2017 (14.x). Mer information finns i CREATE EXTERNAL DATA SOURCE. Ett exempel finns i Importera data från en fil i Azure Blob Storage.

CREATE EXTERNAL DATA SOURCE pandemicdatalake
WITH (
    TYPE = BLOB_STORAGE,
    LOCATION = 'https://<data-lake>.blob.core.windows.net/public/'
);
GO

BULK INSERT bing_covid_19_data
FROM 'curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.csv'
WITH (DATA_SOURCE = '<data-lake>', FIRSTROW = 2, LASTROW = 100, FIELDTERMINATOR = ',');

ERRORFILE = "error_file_path"

Anger den fil som används för att samla in rader som har formateringsfel och som inte kan konverteras till en OLE DB-raduppsättning. Dessa rader kopieras till den här felfilen från datafilen "som den är".

Felfilen skapas när kommandot körs. Ett fel uppstår om filen redan finns. Dessutom skapas en kontrollfil med tillägget .ERROR.txt som refererar till varje rad i felfilen och ger feldiagnostik. Så snart felen har korrigerats kan data läsas in.

Från och med SQL Server 2017 (14.x) kan error_file_path finnas i Azure Blob Storage.

ERRORFILE_DATA_SOURCE = "errorfile_data_source_name"

Gäller för: SQL Server 2017 (14.x) och senare versioner.

Anger en namngiven extern datakälla som pekar på Azure Blob Storage-platsen för felfilen för att hålla reda på fel som hittades under importen. Den externa datakällan måste skapas med hjälp av alternativet TYPE = BLOB_STORAGE som lades till i SQL Server 2017 (14.x). Mer information finns i CREATE EXTERNAL DATA SOURCE.

FIRSTROW = first_row

Anger numret på den första raden som ska läsas in. Standardvärdet är den första raden i den angivna datafilen. FIRSTROW är 1-baserad.

BULK INSERT bing_covid_19_data
FROM 'https://<data-lake>.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.csv'
WITH (FIRSTROW = 2);

Attributet FIRSTROW är inte avsett att hoppa över kolumnrubriker. Instruktionen BULK INSERT har inte stöd för att hoppa över rubriker. Om du väljer att hoppa över rader tittar SQL Server Database Engine bara på fältavgränsarna och validerar inte data i fälten för överhoppade rader.

FIRE_TRIGGERS

Anger att alla infogningsutlösare som definierats i måltabellen körs under massimportåtgärden. Om utlösare definieras för INSERT åtgärder i måltabellen utlöses de för varje slutförd batch.

Om FIRE_TRIGGERS inte anges körs inga infogningsutlösare.

FORMATFILE_DATA_SOURCE = "data_source_name"

Gäller för: SQL Server 2017 (14.x) och senare versioner.

Anger en namngiven extern datakälla som pekar på Azure Blob Storage-platsen för formatfilen för att definiera schemat för importerade data. Den externa datakällan måste skapas med hjälp av alternativet TYPE = BLOB_STORAGE som lades till i SQL Server 2017 (14.x). Mer information finns i CREATE EXTERNAL DATA SOURCE.

KEEPIDENTITY

Anger att identitetsvärdet eller värdena i den importerade datafilen ska användas för identitetskolumnen. Om KEEPIDENTITY inte anges verifieras identitetsvärdena för den här kolumnen men importeras inte och SQL Server tilldelar automatiskt unika värden baserat på de start- och inkrementsvärden som angavs när tabellen skapades. Om datafilen inte innehåller värden för identitetskolumnen i tabellen eller vyn använder du en formatfil för att ange att identitetskolumnen i tabellen eller vyn ska hoppas över när data importeras. SQL Server tilldelar automatiskt unika värden för kolumnen. Mer information finns i DBCC CHECKIDENT.

Mer information finns i om att behålla identifiera värden i Behåll identitetsvärden när du massimporterar data (SQL Server).

KEEPNULLS

Anger att tomma kolumner ska behålla ett null-värde under massimportåtgärden, i stället för att ha några standardvärden för kolumnerna infogade. Mer information finns i Behåll nullvärden eller standardvärden under massimport (SQL Server).

KILOBYTES_PER_BATCH = kilobytes_per_batch

Anger det ungefärliga antalet kilobyte (KB) data per batch som kilobytes_per_batch. Som standard är KILOBYTES_PER_BATCH okänt. Information om prestandaöverväganden finns i Prestandaöverväganden senare i den här artikeln.

LASTROW = last_row

Anger numret på den sista raden som ska läsas in. Standardvärdet är 0, vilket anger den sista raden i den angivna datafilen.

MAXERRORS = max_errors

Anger det maximala antalet syntaxfel som tillåts i data innan massimporten avbryts. Varje rad som inte kan importeras av massimportåtgärden ignoreras och räknas som ett fel. Om max_errors inte anges är standardvärdet 10.

Alternativet MAX_ERRORS gäller inte för begränsningskontroller eller konvertering av pengar och storint datatyper.

ORDER ( { kolumn [ ASC | DESC ] } [ ,... n ] )

Anger hur data i datafilen sorteras. Prestanda för massimport förbättras om data som importeras sorteras enligt det klustrade indexet i tabellen, om det finns några. Om datafilen sorteras i en annan ordning än ordningen på en klustrad indexnyckel, eller om det inte finns något grupperat index i tabellen, ignoreras ORDER-satsen. De kolumnnamn som anges måste vara giltiga kolumnnamn i måltabellen. Som standard förutsätter massinfogningsåtgärden att datafilen är osorterad. För optimerad massimport verifierar SQL Server också att importerade data är sorterade.

n är en platshållare som anger att flera kolumner kan anges.

ROWS_PER_BATCH = rows_per_batch

Anger det ungefärliga antalet rader med data i datafilen.

Som standard skickas alla data i datafilen till servern som en enda transaktion och antalet rader i batchen är okänt för frågeoptimeraren. Om du anger ROWS_PER_BATCH (med värdet > 0) använder servern det här värdet för att optimera massimportåtgärden. Värdet som anges för ROWS_PER_BATCH bör vara ungefär samma som det faktiska antalet rader. Information om prestandaöverväganden finns i Prestandaöverväganden senare i den här artikeln.

TABLOCK

Anger att ett lås på tabellnivå införskaffas under hela massimportåtgärden. En tabell kan läsas in samtidigt av flera klienter om tabellen inte har några index och TABLOCK har angetts. Som standard bestäms låsningsbeteendet av tabellalternativet tabelllås vid massinläsning. Om du håller ett lås under massimportåtgärden minskar låskonkurrationen i tabellen, i vissa fall kan prestandan förbättras avsevärt. Information om prestandaöverväganden finns i Prestandaöverväganden senare i den här artikeln.

För ett kolumnlagringsindex är låsningsbeteendet annorlunda eftersom det är internt indelat i flera rader. Varje tråd läser in data exklusivt i varje raduppsättning genom att ta ett exklusivt (X) lås på raduppsättningen som tillåter parallell databelastning med samtidiga datainläsningssessioner. Användningen av TABLOCK alternativet gör att tråden tar ett exklusivt lås på tabellen (till skillnad från massuppdateringslåset (BU) för traditionella raduppsättningar) vilket förhindrar att andra samtidiga trådar läser in data samtidigt.

Alternativ för indatafilformat

FORMAT = "CSV"

Gäller för: SQL Server 2017 (14.x) och senare versioner.

Anger en fil med kommaavgränsade värden som är kompatibel med RFC 4180 standard.

BULK INSERT Sales.Orders
FROM '\\SystemX\DiskZ\Sales\data\orders.csv'
WITH (FORMAT = 'CSV');

FIELDQUOTE = "field_quote"

Gäller för: SQL Server 2017 (14.x) och senare versioner.

Anger ett tecken som ska användas som citattecken i CSV-filen. Om det inte anges används citattecknet (") som citattecken, enligt definitionen i RFC 4180-standarden .

FORMATFILE = "format_file_path"

Anger den fullständiga sökvägen för en formatfil. En formatfil beskriver den datafil som innehåller lagrade svar som skapats med hjälp av verktyget bcp i samma tabell eller vy. Formatfilen ska användas om:

• Datafilen innehåller större eller färre kolumner än tabellen eller vyn.
• Kolumnerna är i en annan ordning.
• Kolumnavgränsarna varierar.
• Det finns andra ändringar i dataformatet. Formatfiler skapas vanligtvis med hjälp av verktyget bcp och ändras med en textredigerare efter behov. Mer information finns i bcp-verktyget och Skapa en formatfil med bcp (SQL Server).

Från och med SQL Server 2017 (14.x) och i Azure SQL Database kan format_file_path finnas i Azure Blob Storage.

FIELDTERMINATOR = "field_terminator"

Anger fältavgränsaren som ska användas för tecken och widechar datafiler. Standardfältets avslutare är \t (tabbtecken). Mer information finns i Ange fält- och radavgränsare (SQL Server).

BULK INSERT bing_covid_19_data
FROM 'https://<data-lake>.blob.core.windows.net/public/curated/covid-19/bing_covid-19_data/latest/bing_covid-19_data.csv'
WITH (FIELDTERMINATOR = ',', FIRSTROW = 2);

ROWTERMINATOR = "row_terminator"

Anger radavgränsaren som ska användas för tecken och widechar datafiler. Standardradavslutaren är \r\n (nytt radtecken). Mer information finns i Ange fält- och radavgränsare (SQL Server).

Kompatibilitet

BULK INSERT tillämpar strikt dataverifiering och datakontroller av data som lästs från en fil som kan orsaka att befintliga skript misslyckas när de körs på ogiltiga data. Verifierar till exempel BULK INSERT att:

• De inbyggda representationerna av flyttal eller verkliga datatyper är giltiga.
• Unicode-data har en jämn bytelängd.

Datatyper

Konverteringar av datatypen Sträng till decimal

Konverteringarna av datatypen sträng-till-decimal som används i BULK INSERT följer samma regler som funktionen Transact-SQL CONVERT , som avvisar strängar som representerar numeriska värden som använder vetenskaplig notation. Därför BULK INSERT behandlar sådana strängar som ogiltiga värden och rapporterar konverteringsfel.

Om du vill kringgå det här beteendet använder du en formatfil för att massimportera vetenskaplig notation flytta data till en decimalkolumn. I formatfilen beskriver du uttryckligen kolumnen som verkliga eller flytta data. Mer information om dessa datatyper finns i flyttal och verkliga.

Formatfiler representerar verkliga data som SQLFLT4 datatyp och flytta data som SQLFLT8 datatyp. Information om filer som inte är XML-format finns i Ange fillagringstyp med bcp (SQL Server).

Exempel på import av ett numeriskt värde som använder vetenskaplig notation

I det här exemplet används följande tabell i databasen bulktest:

CREATE TABLE dbo.t_float
(
    c1 FLOAT,
    c2 DECIMAL (5, 4)
);

Användaren vill massimportera data till tabellen t_float. Datafilen, C:\t_float-c.dat, innehåller vetenskapliga notationsflötdata , till exempel:

8.0000000000000002E-2 8.0000000000000002E-2

När du kopierar det här exemplet bör du vara medveten om olika textredigerare och kodningar som sparar tabbtecken (\t) som blanksteg. Ett fliktecken förväntas senare i det här exemplet.

Det går dock BULK INSERT inte att importera dessa data direkt till t_float, eftersom dess andra kolumn, c2, använder decimaldatatypen . Därför krävs en formatfil. Formatfilen måste mappa den vetenskapliga notationen flytta data till decimalformatet för kolumn c2.

Följande formatfil använder datatypen SQLFLT8 för att mappa det andra datafältet till den andra kolumnen:

<?xml version="1.0"?>
<BCPFORMAT xmlns="http://schemas.microsoft.com/sqlserver/2004/bulkload/format" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <RECORD>
    <FIELD ID="1" xsi:type="CharTerm" TERMINATOR="\t" MAX_LENGTH="30" />
    <FIELD ID="2" xsi:type="CharTerm" TERMINATOR="\r\n" MAX_LENGTH="30" />
  </RECORD>
  <ROW>
    <COLUMN SOURCE="1" NAME="c1" xsi:type="SQLFLT8" />
    <COLUMN SOURCE="2" NAME="c2" xsi:type="SQLFLT8" />
  </ROW>
</BCPFORMAT>

Om du vill använda den här formatfilen (med filnamnet C:\t_floatformat-c-xml.xml) för att importera testdata till testtabellen utfärdar du följande Transact-SQL-instruktion:

BULK INSERT bulktest.dbo.t_float
FROM 'C:\t_float-c.dat'
WITH (FORMATFILE = 'C:\t_floatformat-c-xml.xml');

Datatyper för massexport eller import av SQLXML-dokument

Om du vill massexportera eller importera SQLXML-data använder du någon av följande datatyper i formatfilen:

Anmärkningar

En jämförelse av -instruktionen BULK INSERT , -instruktionen INSERT ... SELECT * FROM OPENROWSET(BULK...)bcp och kommandot finns i Massimport och export av data (SQL Server).

Information om hur du förbereder data för massimport finns i Förbereda data för massexport eller import.

Instruktionen BULK INSERT kan köras i en användardefinierad transaktion för att importera data till en tabell eller vy. Om du vill använda flera matchningar för massimport av data kan en transaktion ange BATCHSIZE satsen i -instruktionen BULK INSERT . Om en transaktion med flera batchar återställs återställs varje batch som transaktionen skickas till SQL Server.

Samverkan

Importera data från en CSV-fil

Från och med SQL Server 2017 (14.x) BULK INSERT har stöd för CSV-formatet, liksom Azure SQL Database.

Innan SQL Server 2017 (14.x) stöds inte kommaavgränsade värdefiler (CSV) av SQL Server-massimportåtgärder. I vissa fall kan dock en CSV-fil användas som datafil för massimport av data till SQL Server. Information om kraven för att importera data från en CSV-datafil finns i Förbereda data för massexport eller import.

Loggbeteende

Information om när radinfogningsåtgärder som utförs av massimport till SQL Server loggas i transaktionsloggen finns i Krav för minimal loggning vid massimport. Minimal loggning stöds inte i Azure SQL Database.

Begränsningar

När du använder en formatfil med BULK INSERTkan du endast ange upp till 1 024 fält. Detta är samma som det maximala antalet kolumner som tillåts i en tabell. Om du använder en formatfil med BULK INSERT med en datafil som innehåller fler än 1 024 fält BULK INSERT genererar felet 4822. Bcp-verktyget har inte den här begränsningen, så för datafiler som innehåller fler än 1 024 fält använder BULK INSERT du utan en formatfil eller använder kommandot bcp.

Prestandaöverväganden

Om antalet sidor som ska tömmas i en enda batch överskrider ett internt tröskelvärde kan en fullständig genomsökning av buffertpoolen ske för att identifiera vilka sidor som ska tömmas när batchen checkas in. Den här fullständiga genomsökningen kan skada massimportens prestanda. Ett troligt fall av att överskrida det interna tröskelvärdet inträffar när en stor buffertpool kombineras med ett långsamt I/O-undersystem. För att undvika buffertspill på stora datorer använder du antingen inte tipset TABLOCK (som tar bort massoptimeringarna) eller använder en mindre batchstorlek (vilket bevarar massoptimeringarna).

Du bör testa olika batchstorlekar med din databelastning för att ta reda på vad som fungerar bäst för dig. Tänk på att batchstorleken har partiella rollback-konsekvenser. Om processen misslyckas och innan du använder BULK INSERT igen kan du behöva utföra ytterligare manuellt arbete för att ta bort en del av raderna som infogades innan ett fel uppstod.

Med Azure SQL Database kan du överväga att tillfälligt öka prestandanivån för databasen eller instansen före importen om du importerar en stor mängd data.

Säkerhet

Delegering av säkerhetskonto (personifiering)

Om en användare använder en SQL Server-inloggning används säkerhetsprofilen för SQL Server-processkontot. En inloggning med SQL Server-autentisering kan inte autentiseras utanför databasmotorn. När ett BULK INSERT kommando initieras av en inloggning med SQL Server-autentisering görs därför anslutningen till data med hjälp av säkerhetskontexten för SQL Server-processkontot (det konto som används av SQL Server Database Engine-tjänsten).

Om du vill läsa källdata måste du bevilja det konto som används av SQL Server Database Engine åtkomst till källdata. Om en SQL Server-användare däremot loggar in med hjälp av Windows-autentisering kan användaren bara läsa de filer som kan nås av användarkontot, oavsett säkerhetsprofilen för SQL Server-processen.

När du kör -instruktionen BULK INSERT med hjälp av sqlcmd eller osql, från en dator, infogar data i SQL Server på en andra dator och anger en data_file på tredje dator med hjälp av en UNC-sökväg, kan du få ett 4861-fel.

Lös det här felet genom att använda SQL Server-autentisering och ange en SQL Server-inloggning som använder säkerhetsprofilen för SQL Server-processkontot, eller konfigurera Windows för att aktivera delegering av säkerhetskonton. Information om hur du aktiverar ett användarkonto som ska vara betrott för delegering finns i Windows-hjälpen.

Mer information om detta och andra säkerhetsöverväganden för användning finns BULK INSERTi Använda BULK INSERT eller OPENROWSET(BULK...) för att importera data till SQL Server.

När du importerar från Azure Blob Storage och data inte är offentliga (anonym åtkomst) skapar du en DATABASE SCOPED CREDENTIAL baserat på en SAS-nyckel krypterad med en HUVUDnyckel och skapar sedan en extern databaskälla för användning i kommandot BULK INSERT .

Du kan också skapa en DATABASE SCOPED CREDENTIAL- baserat på MANAGED IDENTITY för att auktorisera begäranden om dataåtkomst i icke-offentliga lagringskonton. När du använder MANAGED IDENTITYmåste Azure Storage bevilja behörigheter till den hanterade identiteten för instansen genom att lägga till Storage Blob Data Contributor inbyggd Rollbaserad åtkomstkontroll för Azure (RBAC) som ger läs-/skrivåtkomst till den hanterade identiteten för nödvändiga Azure Blob Storage-containrar. Azure SQL Managed Instance har en systemtilldelad hanterad identitet och kan också ha en eller flera användartilldelade hanterade identiteter. Du kan använda antingen systemtilldelade hanterade identiteter eller användartilldelade hanterade identiteter för att auktorisera begäranden. För auktorisering används identiteten default för den hanterade instansen (dvs. den primära användartilldelade hanterade identiteten eller den systemtilldelade hanterade identiteten om användartilldelad hanterad identitet inte har angetts). Ett exempel finns i Importera data från en fil i Azure Blob Storage.

Behörigheter

Följande behörigheter gäller för den plats där data massimporteras (målet).

Kräver INSERT och ADMINISTER BULK OPERATIONS behörigheter. I Azure SQL Database INSERTADMINISTER DATABASE BULK OPERATIONS krävs behörigheter. ADMINISTER BULK OPERATIONS behörigheter eller bulkadmin-rollen stöds inte för SQL Server i Linux. Endast sysadmin kan utföra massinfogningar för SQL Server i Linux.

Dessutom ALTER TABLE krävs behörighet om ett eller flera av följande villkor är uppfyllda:

• Begränsningar finns och alternativet CHECK_CONSTRAINTS har inte angetts.

  Att inaktivera begränsningar är standardbeteendet. Om du vill kontrollera begränsningar explicit använder du alternativet CHECK_CONSTRAINTS .

• Utlösare finns och alternativet FIRE_TRIGGER har inte angetts.

  Utlösare utlöses inte som standard. Använd alternativet för FIRE_TRIGGER att utlösa utlösare explicit.

• Du använder alternativet KEEPIDENTITY för att importera identitetsvärde från datafilen.

Exempel

Kodexemplen i den här artikeln använder AdventureWorks2022- eller AdventureWorksDW2022-exempeldatabasen, som du kan ladda ned från startsidan Microsoft SQL Server Samples och Community Projects.

A. Använda pipes för att importera data från en fil

I följande exempel importeras information om orderinformation till tabellen AdventureWorks2022.Sales.SalesOrderDetail från den angivna datafilen med hjälp av ett pipe (|) som fältavgränsare och |\n som radavgränsare.

BULK INSERT AdventureWorks2022.Sales.SalesOrderDetail
FROM 'f:\orders\lineitem.tbl'
WITH (FIELDTERMINATOR = ' |', ROWTERMINATOR = ' |\n');

B. Använd argumentet FIRE_TRIGGERS

I följande exempel anges argumentet FIRE_TRIGGERS.

BULK INSERT AdventureWorks2022.Sales.SalesOrderDetail
FROM 'f:\orders\lineitem.tbl'
WITH (FIELDTERMINATOR = ' |', ROWTERMINATOR = ':\n', FIRE_TRIGGERS);

C. Använda radmatning som radavgränsare

I följande exempel importeras en fil som använder radflödet som en radavgränsare, till exempel en UNIX-utdata:

DECLARE @bulk_cmd AS VARCHAR (1000);

SET @bulk_cmd = 'BULK INSERT AdventureWorks2022.Sales.SalesOrderDetail
FROM ''<drive>:\<path>\<filename>''
WITH (ROWTERMINATOR = ''' + CHAR(10) + ''')';

EXECUTE (@bulk_cmd);

D. Ange en kodsida

I följande exempel visas hur du anger en kodsida.

BULK INSERT MyTable
FROM 'D:\data.csv'
WITH (CODEPAGE = '65001', DATAFILETYPE = 'char', FIELDTERMINATOR = ',');

E. Importera data från en CSV-fil

I följande exempel visas hur du anger en CSV-fil som hoppar över rubriken (första raden), med ; som fältavgränsare och 0x0a som radavgränsare:

BULK INSERT Sales.Invoices
FROM '\\share\invoices\inv-2016-07-25.csv'
WITH (
    FORMAT = 'CSV',
    FIRSTROW = 2,
    FIELDQUOTE = '\',
    FIELDTERMINATOR = ';',
    ROWTERMINATOR = '0x0a'
);

I följande exempel visas hur du anger en CSV-fil i UTF-8-format (med hjälp av en CODEPAGE av 65001), hoppar över rubriken (första raden), med ; som fältavslutare och 0x0a som radavslutare:

BULK INSERT Sales.Invoices
FROM '\\share\invoices\inv-2016-07-25.csv'
WITH (
    CODEPAGE = '65001',
    FORMAT = 'CSV',
    FIRSTROW = 2,
    FIELDQUOTE = '\',
    FIELDTERMINATOR = ';',
    ROWTERMINATOR = '0x0a'
);

F. Importera data från en fil i Azure Blob Storage

I följande exempel visas hur du läser in data från en CSV-fil på en Azure Blob Storage-plats där du har skapat en signatur för delad åtkomst (SAS). Azure Blob Storage-platsen är konfigurerad som en extern datakälla, vilket kräver en databasomfattande autentiseringsuppgifter med hjälp av en SAS-nyckel som krypteras med hjälp av en huvudnyckel i användardatabasen.

--> Optional - a MASTER KEY is not required if a DATABASE SCOPED CREDENTIAL is not required because the blob is configured for public (anonymous) access!
CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<password>';
GO

--> Optional - a DATABASE SCOPED CREDENTIAL is not required because the blob is configured for public (anonymous) access!
CREATE DATABASE SCOPED CREDENTIAL MyAzureBlobStorageCredential
    WITH IDENTITY = 'SHARED ACCESS SIGNATURE', SECRET = '******srt=sco&sp=rwac&se=2017-02-01T00:55:34Z&st=2016-12-29T16:55:34Z***************';
-- NOTE: Make sure that you don't have a leading ? in SAS token, and
-- that you have at least read permission on the object that should be loaded srt=o&sp=r, and
-- that expiration period is valid (all dates are in UTC time)

CREATE EXTERNAL DATA SOURCE MyAzureBlobStorage
WITH (
    TYPE = BLOB_STORAGE,
    LOCATION = 'https://****************.blob.core.windows.net/invoices',
    CREDENTIAL = MyAzureBlobStorageCredential
--> CREDENTIAL is not required if a blob is configured for public (anonymous) access!
);

BULK INSERT Sales.Invoices
FROM 'inv-2017-12-08.csv'
WITH (DATA_SOURCE = 'MyAzureBlobStorage');

I följande exempel visas hur du använder BULK INSERT kommandot för att läsa in data från en csv-fil på en Azure Blob Storage-plats med hjälp av hanterad identitet. Azure Blob Storage-platsen är konfigurerad som en extern datakälla.

--> Optional - a MASTER KEY is not required if a DATABASE SCOPED CREDENTIAL is not required because the blob is configured for public (anonymous) access!
CREATE MASTER KEY ENCRYPTION BY PASSWORD = '<password>';
GO

--> Optional - a DATABASE SCOPED CREDENTIAL is not required because the blob is configured for public (anonymous) access!
CREATE DATABASE SCOPED CREDENTIAL MyAzureBlobStorageCredential
    WITH IDENTITY = 'Managed Identity';

-- NOTE: Make sure you have granted Storage Bob Data Contributor RBAC on storage to provides read/write access to the managed identity for the necessary Azure Blob Storage containers.
CREATE EXTERNAL DATA SOURCE MyAzureBlobStorage
WITH (
    TYPE = BLOB_STORAGE,
    LOCATION = 'https://****************.blob.core.windows.net/invoices',
    CREDENTIAL = MyAzureBlobStorageCredential
--> CREDENTIAL is not required if a blob is configured for public (anonymous) access!
);

BULK INSERT Sales.Invoices
FROM 'inv-2017-12-08.csv'
WITH (DATA_SOURCE = 'MyAzureBlobStorage');

G. Importera data från en fil i Azure Blob Storage och ange en felfil

I följande exempel visas hur du läser in data från en CSV-fil på en Azure Blob Storage-plats, som är konfigurerad som en extern datakälla och även anger en felfil. Du behöver en databasomfattande autentiseringsuppgift med hjälp av en signatur för delad åtkomst. Om du kör i Azure SQL Database ERRORFILE bör alternativet åtföljas av ERRORFILE_DATA_SOURCE annars kan importen misslyckas med behörighetsfel. Filen som anges i ERRORFILE bör inte finnas i containern.

BULK INSERT Sales.Invoices
FROM 'inv-2017-12-08.csv'
WITH (
    DATA_SOURCE = 'MyAzureInvoices',
    FORMAT = 'CSV',
    ERRORFILE = 'MyErrorFile',
    ERRORFILE_DATA_SOURCE = 'MyAzureInvoices'
);

Fullständiga BULK INSERT exempel, inklusive konfiguration av autentiseringsuppgifter och extern datakälla, finns i Exempel på massåtkomst till data i Azure Blob Storage.

Fler exempel

Andra BULK INSERT exempel finns i följande artiklar:

• Exempel på massimport och export av XML-dokument (SQL Server)
• Behåll identitetsvärden vid massimport av data (SQL Server)
• Behåll null-värden eller standardvärden under massimport (SQL Server)
• Ange fält- och radavgränsare (SQL Server)
• Använd en formatfil för att massimportera data (SQL Server)
• Använd teckenformat för att importera eller exportera data (SQL Server)
• Använda internt format för att importera eller exportera data (SQL Server)
• Använda Unicode-teckenformat för att importera eller exportera data (SQL Server)
• Använda unicode-inbyggt format för att importera eller exportera data (SQL Server)
• Använda en formatfil för att hoppa över en tabellkolumn (SQL Server)
• Använd en formatfil för att mappa tabellkolumner till datafilfält (SQL Server)

Relaterat innehåll

• massimport och export av data (SQL Server)
• bcp-verktyg
• Formatera filer för att importera eller exportera data (SQL Server)
• INFOGA (Transact-SQL)
• OPENROWSET (Transact-SQL)
• Förbereda data för massexport eller import
• sp_tableoption (Transact-SQL)