bcp_init

Artikel
01/23/2025

gäller för:SQL Server Azure SQL Database Azure SQL Managed Instance Azure Synapse Analytics Analytics Platform System (PDW)

Initierar masskopieringsåtgärden.

Syntax

RETCODE bcp_init (  
        HDBC hdbc,  
        LPCTSTR szTable,  
        LPCTSTR szDataFile,  
        LPCTSTR szErrorFile,  
        INT eDirection);

Unicode- och ANSI-namn:

bcp_initA (ANSI)
bcp_initW (Unicode)

Argument

hdbc
Är den masskopieringsaktiverade ODBC-anslutningshandtaget.

szTable
Är namnet på databastabellen som ska kopieras till eller från. Det här namnet kan också innehålla databasnamnet eller ägarnamnet. Till exempel pubs.gracie.titles, pubar.. rubriker, gracie.titlesoch rubriker är alla juridiska tabellnamn.

Om eDirection är DB_OUT kan szTable också vara namnet på en databasvy.

Om eDirection är DB_OUT och en SELECT-instruktion anges med bcp_control innan bcp_exec anropas, måste bcp_initszTable anges till NULL.

szDataFile
Är namnet på användarfilen som ska kopieras till eller från. Om data kopieras direkt från variabler med hjälp av bcp_sendrowanger du szDataFile till NULL.

szErrorFile
Är namnet på felfilen som ska fyllas med förloppsmeddelanden, felmeddelanden och kopior av rader som av någon anledning inte kunde kopieras från en användarfil till en tabell. Om NULL skickas som szErrorFileanvänds ingen felfil.

eDirection
Är kopieringsriktningen, antingen DB_IN eller DB_OUT. DB_IN anger en kopia från programvariabler eller en användarfil till en tabell. DB_OUT anger en kopia från en databastabell till en användarfil. Du måste ange ett användarnamn med DB_OUT.

Returnerar

SUCCEED eller FAIL.

Anmärkningar

Anropa bcp_init innan du anropar någon annan masskopieringsfunktion. bcp_init utför nödvändiga initieringar för en masskopia av data mellan arbetsstationen och SQL Server.

Funktionen bcp_init måste ha ett ODBC-anslutningshandtag aktiverat för användning med masskopieringsfunktioner. Om du vill aktivera handtaget använder du SQLSetConnectAttr med SQL_COPT_SS_BCP inställt på SQL_BCP_ON på en allokerad, men inte ansluten, anslutningsreferens. Om du försöker tilldela attributet på en ansluten referens resulterar det i ett fel.

När en datafil har angetts undersöker bcp_init strukturen för databaskällan eller måltabellen, inte datafilen. bcp_init anger dataformatvärden för datafilen baserat på varje kolumn i databastabellen, vyn eller SELECT-resultatuppsättningen. Den här specifikationen innehåller datatypen för varje kolumn, förekomsten eller frånvaron av en längd- eller null-indikator och terminator-bytesträngar i data samt bredden på datatyper med fast längd. bcp_init anger följande värden:

Den angivna datatypen är datatypen för kolumnen i databastabellen, vyn eller SELECT-resultatuppsättningen. Datatypen räknas upp av inbyggda SQL Server-datatyper som anges i sqlncli.h. Data representeras i dess datorform. Data från en kolumn med heltal datatyp representeras av en 4-bytessekvens som är stor eller liten slutpunkt baserat på datorn som skapade datafilen.
Om en databasdatatyp är fast i längd, är datafildata också fasta i längd. Masskopieringsfunktioner som bearbetar data (till exempel bcp_exec) parsar datarader som förväntar sig att längden på data i datafilen ska vara identisk med längden på de data som anges i databastabellen, vyn eller SELECT-kolumnlistan. Till exempel måste data för en databaskolumn som definieras som tecken(13) representeras med 13 tecken för varje rad med data i filen. Data med fast längd kan prefixeras med en null-indikator om databaskolumnen tillåter null-värden.
När sekvensen terminator-byte har definierats anges längden på sekvensen terminator-byte till 0.
När du kopierar till SQL Server måste datafilen ha data för varje kolumn i databastabellen. När du kopierar från SQL Server kopieras data från alla kolumner i databastabellen, vyn eller SELECT-resultatuppsättningen till datafilen.
Vid kopiering till SQL Server måste ordningstalet för en kolumn i datafilen vara identisk med kolumnens ordningstal i databastabellen. När du kopierar från SQL Server placerar bcp_exec data baserat på kolumnens ordningstal i databastabellen.
Om en databasdatatyp är variabel i längd (till exempel varbinary(22)) eller om en databaskolumn kan innehålla null-värden, prefixeras data i datafilen av en längd-/null-indikator. Indikatorns bredd varierar beroende på datatyp och version av masskopiering.

Om du vill ändra dataformatvärden som angetts för en datafil anropar du bcp_columns och bcp_colfmt.

Masskopior till SQL Server kan optimeras för tabeller som inte innehåller index genom att ställa in databasåterställningsmodellen på SIMPLE eller BULK_LOGGED. Mer information finns i krav för minimal loggning i massimport och ALTER DATABASE.

Om ingen datafil används måste du anropa bcp_bind för att ange format och plats i minnet för data för varje kolumn och sedan kopiera datarader till SQL Server med hjälp av bcp_sendrow.

Exempel

Det här exemplet visar hur du använder funktionen ODBC bcp_init med en formatfil.

Innan du kompilerar och kör C++-koden måste du göra följande:

Skapa en ODBC-datakälla med namnet Test. Du kan associera den här datakällan med valfri databas.

Kör följande Transact-SQL på databasen:

CREATE TABLE BCPDate (cola int, colb datetime);

I katalogen där du kör programmet lägger du till en fil med namnet Bcpfmt.fmt och lägger till det här innehållet i filen:
```
8.0  
2  
1SQLCHAR04"\t"1colaSQL_Latin1_General_Cp437_Bin  
2SQLCHAR08"\r\n"2colbSQL_Latin1_General_Cp437_Bin  
```
I katalogen där du kör programmet lägger du till en fil med namnet Bcpodbc.bcp och lägger till innehåll i filen:
```
1  
2  
```

Nu är du redo att kompilera och köra C++-koden.

// compile with: odbc32.lib sqlncli11.lib  
#include <stdio.h>  
#include <windows.h>  
#include <sql.h>  
#include <sqlext.h>  
#include <odbcss.h>  
  
SQLHENV henv = SQL_NULL_HENV;  
HDBC hdbc1 = SQL_NULL_HDBC;   
  
void Cleanup() {  
   if (hdbc1 != SQL_NULL_HDBC) {  
      SQLDisconnect(hdbc1);  
      SQLFreeHandle(SQL_HANDLE_DBC, hdbc1);  
   }  
  
   if (henv != SQL_NULL_HENV)  
      SQLFreeHandle(SQL_HANDLE_ENV, henv);  
}  
  
int main() {  
   RETCODE retcode;  
   SDWORD cRows;  
  
   // Allocate the ODBC environment and save handle.  
   retcode = SQLAllocHandle (SQL_HANDLE_ENV, NULL, &henv);  
   if ( (retcode != SQL_SUCCESS_WITH_INFO) && (retcode != SQL_SUCCESS)) {  
      printf("SQLAllocHandle(Env) Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   // Notify ODBC that this is an ODBC 3.0 app.  
   retcode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER);  
   if ( (retcode != SQL_SUCCESS_WITH_INFO) && (retcode != SQL_SUCCESS)) {  
      printf("SQLSetEnvAttr(ODBC version) Failed\n\n");  
      Cleanup();  
      return(9);      
   }  
  
   // Allocate ODBC connection handle, set BCP mode, and connect.  
   retcode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc1);  
   if ( (retcode != SQL_SUCCESS_WITH_INFO) && (retcode != SQL_SUCCESS)) {  
      printf("SQLAllocHandle(hdbc1) Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   retcode = SQLSetConnectAttr(hdbc1, SQL_COPT_SS_BCP, (void *)SQL_BCP_ON, SQL_IS_INTEGER);  
   if ( (retcode != SQL_SUCCESS_WITH_INFO) && (retcode != SQL_SUCCESS)) {  
      printf("SQLSetConnectAttr(hdbc1) Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   // Sample uses Integrated Security. Create SQL Server DSN using Windows NT authentication.  
   retcode = SQLConnect(hdbc1, (UCHAR*)"Test", SQL_NTS, (UCHAR*)"", SQL_NTS, (UCHAR*)"", SQL_NTS);  
   if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {  
      printf("SQLConnect() Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   // Initialize the bulk copy.  
   retcode = bcp_init(hdbc1, "BCPDate", "BCPODBC.bcp", NULL, DB_IN);  
   if ( (retcode != SUCCEED) ) {  
      printf("bcp_init(hdbc1) Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   // Read the format file.  
   retcode = bcp_readfmt(hdbc1, "BCPFMT.fmt");  
   if ( (retcode != SUCCEED) ) {  
      printf("bcp_readfmt(hdbc1) Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   // Execute the bulk copy.  
   retcode = bcp_exec(hdbc1, &cRows);  
   if ( (retcode != SUCCEED) ) {  
      printf("bcp_exec(hdbc1) Failed\n\n");  
      Cleanup();  
      return(9);  
   }  
  
   printf("Number of rows bulk copied in = %d.\n", cRows);  
  
   // Cleanup  
   SQLDisconnect(hdbc1);  
   SQLFreeHandle(SQL_HANDLE_DBC, hdbc1);  
   SQLFreeHandle(SQL_HANDLE_ENV, henv);  
}

Se även

masskopieringsfunktioner

Dela via