procedure TCustomOleDbConnection.DoConnect;
var
  Unknown : IUnknown;
  FDataInitialize : IDataInitializeSC;
begin
  // Tout d'abord, la chaîne de connexion doit avoir été définie
  if FConnectionString = ''
  then raise EOleDbException.Create('La chaîne de connexion n''est pas définie !');

  SQLLogger.Trace(EVENT_SQL_INFO, 'Ouverture de la connexion : ' +
    FConnectionString, TRACE_LEVEL_INFORMATION);
  try
    // Enfin, on a besoin d'un accès à IMAlloc pour gérer certaines allocations
    // de mémoire.
    OleCheck(CoGetMalloc(1, FMAlloc));

    // L'initialisation de la connexion est faite indirectement,
    // par l'intermédiaire du service OLEDB gérant les chaînes de connexion.
    // On commence donc par se connecter à ce service, en instanciant un
    // objet CLSID_MSDAINITIALIZE.
    OleCheck(CoCreateInstance(CLSID_MSDAINITIALIZE, nil, CLSCTX_INPROC_SERVER, IID_IDataInitialize,
      FDataInitialize));

    // Dans un deuxième temps, on crée l'objet DataSource oledb à partir
    // de la chaîne de connexion. L'objet ainsi créé est déjà initialisé.
    // Il ne restera plus qu'à ouvrir la connexion.
    Unknown := nil;
    FDataInitialize.GetDataSource(nil, CLSCTX_INPROC_SERVER,
      PWideChar(FConnectionString), IID_IDBInitialize,  Unknown);
    FDbInitialize := Unknown as IDBInitialize;

    FDataInitialize := nil; // On n'a plus besoin d'accéder au service !
    // On ouvre la connexion sur la source de donnée.
    OleDbCheck(FDbInitialize.Initialize);

    // Avant de créer la session, on peut avoir besoin de modifier les propriétés de la connexion.
    // C'est le rôle de la méthode SetupConnection qui peut être surchargée dans les classes dérivées.
    SetupConnection;

    // Il ne reste plus qu'à créer une session par défaut.
    FSession := nil;
    OleDbCheck((FDbInitialize as IDBCreateSession).CreateSession(nil, IID_IOpenRowset, FSession));

    // On essaie d'obtenir l'interface ITransactionLocal pour la gestion des
    // transaction. Cependant, il se peut que le provider OLEDB ne gère pas les
    // transaction et n'implémente pas l'interface ITransactionLocal.
    if FSession.QueryInterface(IID_ITransactionLocal, unknown) = S_OK
    then FTransaction := unknown as ITransactionLocal
    else FTransaction := nil;

    // La connexion a été effectuée.
    SQLLogger.TraceConnect;
  except
    on e:exception do
    begin
      // En cas d'erreur à la connexion, on trace l'exception.
      SQLLogger.TraceException(e);

      // Puis on nettoie les interfaces.
      FSession := nil; // La connexion a échoué.
      FDbInitialize := nil;
      FDataInitialize := nil;

      // On redéclenche l'exception.
      raise;
    end;
  end;
end;

procedure TOleDbBulkCopyConnection.SetupConnection;
var
  FProperties : TOleDbPropertySet;
  Properties : IDBProperties;
begin
  // Il faut définir la propriété SSPROP_ENABLEFASTLOAD de la connexion à TRUE
  // avant de créer la session. De cette façon, OleDb créera un objet session
  // dédié pour faire des copies en bloc.
  // Dès lors ce dernier ne permettra plus de faire autre chose que des copies en bloc.

  // On va définir une propriété du jeu de propriétés DBPROPSET_SQLSERVERDATASOURCE
  FProperties := TOleDbPropertySet.Create(DBPROPSET_SQLSERVERDATASOURCE);
  try
    // Maintenant, on définit la propriété à modifier ainsi que sa nouvelle valeur
    FProperties.AddOption(SSPROP_ENABLEFASTLOAD, true);

    // Enfin, on utilise l'interface IDBProperties afin de définir la valeur de la propriété.
    Properties := FDbInitialize  as IDBProperties;
    try
      OleCheck(Properties.SetProperties(1, FProperties.AsPropertySet));
    finally
      Properties := nil;
    end;
  finally
    FProperties.Free;
  end;
end;

var
  TableID : DBID;
  ds : TOleDbBulkCopy;
  OpenRowSet : IOpenRowSet;
  unknown : IUnknown;
  Properties : TOleDbPropertySet;
begin
  // Tout d'abord, on demande l'interface IOpenRowSet de la session.
  OpenRowSet := FSession as IOpenRowSet; 

  // Ensuite, on initialise une structure DBID pour indiquer le nom de la table à utiliser.
  Fillchar(TableId, sizeof(TableId), 0);
  TableID.eKind := DBKIND_NAME; // L'objet est identifié par son nom.
  TableID.uName.pwszName := PWideChar(TableName); // On indique le pointeur sur le nom de la table.

  // A présent on définit les options pour l'opération Bulk :
  Properties := TOleDbPropertySet.Create(DBPROPSET_SQLSERVERROWSET);
  try
    Properties.AddOption(SSPROP_FASTLOADKEEPIDENTITY, KeepIdentity); 
    Properties.AddOption(SSPROP_FASTLOADKEEPNULLS, KeepNulls);
    Properties.AddOption(SSPROP_FASTLOADOPTIONS, 'ROWS_PER_BATCH =' +
      IntToStr(FBulkSize) + ',TABLOCK');
    Properties.AddOption(SSPROP_IRowsetFastLoad, true);

    unknown := nil;
    OleDbCheck(OpenRowSet.OpenRowset(nil, @TableID, nil, IID_IRowsetFastLoad, 1,
      Properties.AsPropertySet, @unknown));
  finally
    Properties.Free;
  end;

IRowsetFastLoad = interface(IUnknown)
  ['{5CF4CA13-EF21-11d0-97E7-00C04FC2AD98}']
  function InsertRow(hAccessor : HACCESSOR; pData : pointer) : HResult; stdcall;
  function Commit(fDone : BOOL) : HResult; stdcall;
end;

TOleDbBulkCopyConnection = class(TCustomOleDbConnection)
private
  FBulkSize : cardinal;
protected
  procedure SetupConnection; override;
public
  constructor Create(AOwner : TComponent); override;

  function OpenForBulkCopy(const TableName : widestring;
    KeepIdentity : boolean = false;
    KeepNulls : boolean = true) : TDataset; virtual;
     
  property BulkSize : cardinal read FBulkSize write FBulkSize;
end;

function TOleDbBulkCopyConnection.OpenForBulkCopy(
  const TableName: widestring; KeepIdentity : boolean; KeepNulls : boolean): TDataset;
var
  TableID : DBID;
  ds : TOleDbBulkCopy;
  OpenRowSet : IOpenRowSet;
  unknown : IUnknown;
  Properties : TOleDbPropertySet;
begin
  CheckConnected; // On s'assure que la connexion est bien ouverte !
  try
    // Tout d'abord, on demande l'interface IOpenRowSet de la session.
    OpenRowSet := FSession as IOpenRowSet; 

    // Ensuite, on initialise une structure DBID pour indiquer le nom de la table à utiliser.
    Fillchar(TableId, sizeof(TableId), 0);
    TableID.eKind := DBKIND_NAME; // L'objet est identifié par son nom.
    TableID.uName.pwszName := PWideChar(TableName); // On indique le pointeur sur le nom de la table.

    // A présent on définit les options pour l'opération Bulk :
    Properties := TOleDbPropertySet.Create(DBPROPSET_SQLSERVERROWSET);
    try
      Properties.AddOption(SSPROP_IRowsetFastLoad, true);
      Properties.AddOption(SSPROP_FASTLOADKEEPIDENTITY, KeepIdentity);
      Properties.AddOption(SSPROP_FASTLOADKEEPNULLS, KeepNulls);
      Properties.AddOption(SSPROP_FASTLOADOPTIONS, 'ROWS_PER_BATCH =' +
        IntToStr(FBulkSize) + ',TABLOCK');

      unknown := nil;
      OleDbCheck(OpenRowSet.OpenRowset(nil, @TableID, nil, IID_IRowsetFastLoad, 1,
        Properties.AsPropertySet, @unknown));
    finally
      Properties.Free;
    end;

    // unknown contient la référence à l'interface IRowsetFastLoad pour le chargement en bloc. 
    // Il ne reste plus qu'à créer un objet TOleDbBulkCopy pour manipuler facilement cette 
    // interface.
    ds := TOleDbBulkCopy.Create(self);
    ds.initialize(TableName, self, unknown as IRowsetFastLoad);
    ds.FBulkSize := BulkSize;
    RegisterClient(ds); // On enregistre le dataset dans la liste des datasets actifs de la connexion.
                        // de cette façon, la fermeture de la connexion fermera automatiquement tous les
                        // dataset associés qui sont encore ouverts.
    result := ds;
  except
    on e:exception do
    begin
      // En cas d'erreur, on écrit l'exception dans la trace, et on la redéclenche pour qu'elle soit
      // traitée par l'appelant. 
      SQLLogger.TraceException(e);
      raise;
    end;
  end;
end;

procedure TOleDbBulkCopy.initialize(ATableName: widestring;
  AConnection: TOleDbBulkCopyConnection; AFastLoad: IRowsetFastLoad);
begin
  SQLLogger.TraceSQLBegin('Initialisation BULK : ' + ATableName, t0); 
  FTableName := ATableName;
  FOleDbBulkConnection := AConnection;
  FFastLoad := AFastLoad;

  // On définit la structure des champs en fonction de la table.
  Describe(FFastLoad as IColumnsInfo, FOleDbBulkConnection);

  // Lorsqu'on fait un Bulk insert, seul l'insertion de nouvelles lignes est
  // autorisée. On passe le dataset en mode Unidirectionnel pour désactiver
  // toutes les autres fonctionnalités.
  SetUniDirectional(true);

  // On demande l'ouverture du dataset. Cette opération va initialiser les buffers
  // de stockage interne et créer les champs.
  Open;

  // Il ne reste plus qu'à créer l'accesseur qui nous permettra d'écrire les
  // données dans la table.
  CreateAccessor;

  FNbLineDone := 0;
  FBulkSize := 1000;
end;

procedure TOleDbBulkCopy.CreateAccessor;
begin
  InitializeBindings;

  // Ensuite, on crée un accesseur basé sur ce binding.
  FOleDbBulkConnection.OleDbCheck((FFastLoad as IAccessor).CreateAccessor(
      DBACCESSOR_ROWDATA + DBACCESSOR_OPTIMIZED,
      FieldDefs.Count,
      @Bindings[0],
      RecordSize,
      FAccessor,
      nil));
end;

procedure TOleDbBulkCopy.InternalPost;
var
  Buffer : Pointer;
  i : integer;
  FieldData : PFieldData;
  FBlobIdx : cardinal;
  Size : cardinal;
  LineMin : integer;
begin
  // On commence par vérifier l'état du dataset. Pour un chargement en bloc, seules les insertions
  // sont autorisées. Le Dataset ne doit donc jamais se retrouver en édition. Si ce cas se produit
  // un déclenche une erreur.
  if state = dsEdit
  then begin
    Raise Exception.Create('Seul les Insertions sont autorisées !');
  end
  else begin
    // Avant d'écrire la ligne, il faut initialiser la longueur de chaque champ
    Buffer := GetActiveBuffer;
    for i := 0 to Fields.Count -1 do
    begin
      FieldData := GetPFieldData(Buffer, FFieldInfo[i].Offset);
      if FieldData.NullStatus = 0
      then begin
        FieldData.NullStatus := DBSTATUS_S_OK; // La valeur du champ est définie
        size := FFieldInfo[i].Size;

        // Maintenant, on calcule la longueur des champs
        case Fields[i].DataType of
        ftString:
          size := strlen(PAnsiChar(@FieldData.Data[0]));
        ftWideString:
          size := WStrLen(@FieldData.Data[0])*2;
        ftBlob, ftMemo, ftWideMemo:
          begin
            // Pour les champs Blob, il faut remplacer le numéro du Blob par son pointeur direct sur
            // ses données.
            FBlobIdx := cardinal(FieldData.Data);
            pointer(FieldData.Data) := FBlobList[FBlobIdx];
            size := FIeldData.LengthValue;
          end;
        end;
        FieldData.LengthValue := size;
      end
      else FieldData.NullStatus := DBSTATUS_S_ISNULL; // Le champ est à NULL
    end;

    // Il reste à insérer la ligne en base avec InsertRow.
    try
      FOleDbBulkConnection.OleDbCheck(FFastLoad.InsertRow(Accessor, GetActiveBuffer));
    except
      on e:exception do
      begin
        // En cas d'erreur on trace l'exception et on la redéclenche pour qu'elle soit traitée par
        // l'appelant.
        SQLLogger.Trace(EVENT_SQL_ERROR, 'Erreur lors de l''insertion de la ligne n°' + 
            IntToStr(FNbLineDone) + ' : ' + e.Message);
        raise;
      end;
    end;

    inc(FNbLineDone); // On compte les lignes insérées
    FPending := true; // Une ligne a été insérée et devra être validée !

    ClearBlobs; // La ligne vient d'être insérée. Elle n'est plus lisible. On libère la mémoire utilisée
                // pour les Blobs.

    if FNbLineDone mod FBulkSize = 0 // Lorsqu'on a atteind la taille d'un lot, il faut valider les
    then begin                       // données en base.
      try
        // On effectue la validation dans la base. On part du principe que les insertions vont continuer
        // tant que le dataset n'a pas été fermée.
        FOleDbBulkConnection.OleDbCheck(FFastLoad.Commit(false));
        FPending := false; // Les lignes insérées ont été validées. Il n'y a plus de lignes en attente.
        SQLLogger.Trace('BULK: ' + TableName + ' Commit'); // On trace la validation.
      except
        on e:exception do
        begin
          // En cas d'erreur on trace l'exception et on la redéclenche pour qu'elle soit traitée par
          // l'appelant.
          LineMin := FNbLineDone - FBulkSize+1;
          if (LineMin<0)
          then LineMin := 0;

          SQLLogger.Trace(EVENT_SQL_ERROR,
            Format('Erreur lors de la validation du lot %d-%d : %s', [LineMin, FNbLineDone, e.Message]));
          raise;
        end;
      end;
    end;
  end;
end;

procedure TOleDbBulkCopy.InternalClose;
begin
  // On regarde s'il reste des données à valider
  if FPending
  then begin
    // et on appelle Commit pour effectuer la validation.
    FOleDbBulkConnection.OleDbCheck(FFastLoad.Commit(true));
    FPending := false;
    SQLLogger.Trace('BULK: ' + TableName + ' Commit');
  end;

  // On n'a plus besoin de l'accesseur.
  (FFastLoad as IAccessor).ReleaseAccessor(FAccessor, nil);

  FFastLoad := nil;
  
  FOleDbBulkConnection.UnRegisterClient(self); // Le dataset n'est plus connecté. On le supprime des
                                               // dataset actifs de la connexion.
  
  inherited internalClose;
  SQLLogger.TraceSQLEnd('Fermeture du BULK : ' + TableName, t0); 
end;

CREATE TABLE [dbo].[ErrorLog](
	[ErrorLogID] [int] IDENTITY(1,1) NOT NULL,
	[ErrorTime] [datetime] NOT NULL CONSTRAINT [DF_ErrorLog_ErrorTime]  DEFAULT (getdate()),
	[UserName] [sysname] NOT NULL,
	[ErrorNumber] [int] NOT NULL,
	[ErrorSeverity] [int] NULL,
	[ErrorState] [int] NULL,
	[ErrorProcedure] [nvarchar](126) NULL,
	[ErrorLine] [int] NULL,
	[ErrorMessage] [nvarchar](4000) NOT NULL,
 CONSTRAINT [PK_ErrorLog_ErrorLogID] PRIMARY KEY CLUSTERED 
(
	[ErrorLogID] ASC
)
)

var
  ds : TDataset;
  i : integer;
  fldID : TField;
  fldUser : TField;
  flderrorTime : TField;
  FldErrNr : TField;
  FldErrMsg : TField;
  BulkCnt : TOleDbBulkCopyConnection;
begin
  // Premièrement, il faut créer et initialiser une connexion à la base de données en vue d'effectuer
  // une copie en blocs. On instancie un objet TOleDbBulkCopyConnection
  BulkCnt := TOleDbBulkCopyConnection.Create(nil);
  try

    // On configure les paramètres de connexion avec une chaîne de connexion assez standard :
    BulkCnt.ConnectionString := 'Provider=SQLNCLI.1;Integrated Security=SSPI;' + 
      'Persist Security Info=False;Initial Catalog=AdventureWorksLT;Data Source=.\SQLExpress';
    BulkCnt.Connected := true; // Enfin on ouvre la connexion

    // Une fois la connexion ouverte, il ne reste plus qu'à préparer la copie en blocs pour la table
    // ErrorLog.
    ds := BulkCnt.OpenForBulkCopy('ErrorLog', true);
    try
      // Le dataset est maintenant prêt pour effectuer le chargement. On commence par rechercher les
      // composants TField correspondants aux champs qui vont être initialisés de façon à ne pas appeler
      // FieldByName en boucle lors de l'insertion des lignes. En effet, on perdrait alors le bénéfice de
      // la copie en blocs du fait des recherches des TField.
      fldID := ds.FieldByName('ErrorLogid');
      fldErrorTime := ds.FieldByName('ErrorTime');
      fldUser := ds.FieldByName('UserName');
      FldErrNr  := ds.FieldByName('ErrorNumber');
      fldErrMsg := ds.FieldByName('ErrorMEssage');
      for i := 1 to 1000000 do // On boucle pour insérer 1 000 000 de ligne dans la table !
      begin
        // Enfin on peut insérer les lignes comme avec un TTable :
        ds.Append; // On passe le dataset en insertion (Rq: Insert fait exactement la même chose).

        // On initialise les valeurs des champs.
        fldID.AsInteger := i;
        fldErrorTime.AsDateTime := now;
        fldUser.AsString := 'Erreur';
        fldErrNr.AsInteger := i;
        FldErrMsg.AsString := 'Message d''erreur n°' + IntToStr(i);

        // Enfin, on demande l'insertion de la ligne.
        ds.Post;
      end;
    finally
      ds.Free; // En fin de traitement, on détruit le Dataset.
    end;
  finally
    BulkCnt.Free; // Enfin, on ferme la connexion.
  end;
end;

Erreur lors de la validation du lot 1-1000 : MSG-2627, Line 1, Violation de la contrainte PRIMARY KEY
 'PK_ErrorLog_ErrorLogID'. Impossible d'insérer une clé en double dans l'objet 'dbo.ErrorLog'.