// La structure TFieldData représente le format de stockage d'un champ
  // à l'intérieur d'un buffer du DataSet.
  PFieldData = ^TFieldData;
  TFieldData = packed record
    NullStatus : integer;  // Indique si le champ est à NULL.
    LengthValue : integer;  // Indique la longueur actuelle du champ.
                            // LengthValue n'a de sens que pour les champs de
                            // taille variable.
    Data : array[0..0] of byte; // Début des données du champ.
  end;

  // TLineBuffer désigne la structure d'un buffer.
  TLineBuffer = packed record
    BkFlags : TBookmarkFlag;    // Bookmark flag
    Bookmark : cardinal;        // Valeur du bookmark/identifiant du buffer
    Data : array[0..0] of byte; // Début de la zone des données des champs
  end;

// Calcule la taille d'un buffer, en fonction des champs définis dans
// FieldDefs.
// Une fois calculé, le résultat est mémorisé dans FRecordSize.
procedure TMemoryDataSet.CalcRecordSize;
var
  i : integer;
  currentOffset : cardinal;
begin
  SetLength(FFieldInfo, FieldDefs.Count);

  // Initialisation de la taille initiale du buffer.
  currentOffset := sizeof(TLineBuffer) - 1;

  // On agrandit le buffer pour stocker chaque champ un par un. On en profite
  // également pour indexer les champs à l'intérieur du buffer et initialiser
  // le tableau FFieldInfo.
  for i := 0 to FieldDefs.Count -1 do
  begin
    FFieldInfo[i].Offset := currentOffset; // On mémorise la position du champ
                                           // à l'intérieur du buffer.
    FFieldInfo[i].Size := GetFieldSize(FieldDefs[i]);
    inc(currentOffset, sizeof(TFieldData) - 1 + FFieldInfo[i].Size);
  end;
  FRecordSize := currentOffset;
end;

    FFieldInfo : array of TFieldInfo;

  TFieldInfo = record
    Offset : cardinal; // Offset d'un champ dans un buffer, par rapport au début
                       // du buffer.
    Size : cardinal;   // Taille de la zone des données du champ à l'intérieur
                       // du buffer.
  end;

function TMemoryDataSet.GetRecordSize: word;
begin
  result := FRecordSize; // On renvoie la valeur calculée lors de l'ouverture
                         // du DataSet.
end;

// Retourne la taille en octets nécessaire pour stocker le champ décrit dans
// <FldDef>.
function TMemoryDataSet.GetFieldSize(FldDef: TFieldDef): cardinal;
begin
  case FldDef.DataType of
  ftString, ftFixedChar:
    result := FldDef.Size; // La taille correspond à la taille du champ.
  ftSmallint, ftWord: // Entier court
    result := 2;
  ftAutoInc, ftInteger: // Entier long
    result := 4;
  ftBoolean: // Les boolean sont stockés comme des entiers courts.
    result := 2;
  ftFloat: // Les floats sont stockés dans des double.
    result := sizeof(double);
  ftCurrency:
    result := sizeof(currency);
  ftBCD, ftFMTBcd : // Les BCD sont convertis en double.
    result := sizeof(double);
  ftDateTime, ftDate, ftTime :
    result := sizeof(TDateTime);

  ftWideMemo, ftOraBlob, ftOraClob, ftBlob, ftBytes, ftVarBytes,
  ftMemo, ftGraphic, ftFmtMemo: // Les LOB font l'objet d'une gestion spéciale
    result := 4;

  ftFixedWideChar, ftWideString: // Chaînes unicode.
    result := FldDef.Size*2;

  ftLargeint:
    result := sizeof(int64);
  ftVariant: // Le variant est stocké dans un variant...
    result := sizeof(variant);
  ftGuid:
    result := sizeof(TGUID);
  else raise MemoryDataSetNotSupported.Create(FldDef.Name, FldDef.DataType);
  end;
end;

// Cette méthode est appelée par TDataSet pour allouer un nouveau buffer.
function TMemoryDataSet.AllocRecordBuffer: PChar;
begin
  // On trace l'appel à AllocRecordBuffer au niveau TRACE_LEVEL_VERBOSE.
  // On pourra ainsi suivre les allocations/libération de buffer effectuées par
  // le TDataSet et analyser son fonctionnement en détails si besoin.
  SQLLogger.Trace(EVENT_TRACE_TYPE_INFO, 'AllocRecordBuffer',
    TRACE_LEVEL_VERBOSE);

  // On alloue simplement un bloc mémoire de la taille d'un buffer.
  GetMem(Result, GetRecordSize);

  // Ensuite on initialise le buffer pour définir tous les champs à NULL.
  InternalInitRecord(Result);
end;

// Libère la mémoire utilisée par le buffer <Buffer>. <Buffer> doit contenir
// un buffer préallablement alloué avec AllocRecordBuffer.
procedure TMemoryDataSet.FreeRecordBuffer(var Buffer: PChar);
begin
  // On trace l'appel à FreeRecordBuffer au niveau TRACE_LEVEL_VERBOSE.
  // On pourra ainsi suivre les allocations/libération de buffer effectuées par
  // le TDataSet et analyser son fonctionnement en détails si besoin.
  SQLLogger.Trace(EVENT_TRACE_TYPE_INFO, 'FreeRecordBuffer',
    TRACE_LEVEL_VERBOSE);

  // Libération de la mémoire.
  FreeMem(Buffer);
end;

// Permet d'initialiser une nouveau <Buffer>. Le <Buffer est initialisé en
// définissant tous les champs à NULL.
procedure TMemoryDataSet.InternalInitRecord(Buffer: PChar);
var i : integer;
begin
  // On trace l'appel à InternalInitRecord au niveau TRACE_LEVEL_VERBOSE.
  // On pourra ainsi suivre les allocations/libération de buffer effectuées par
  // le TDataSet et analyser son fonctionnement en détails si besoin.
  SQLLogger.Trace(EVENT_TRACE_TYPE_INFO, 'InternalInitRecord',
    TRACE_LEVEL_VERBOSE);

  // On définit tous les champs à NULL un par un.
  for i := 0 to high(FFieldInfo) do
  begin
    ClearField(Buffer, FFieldInfo[i].Offset);
  end;
end;

// Renvoie un pointeur sur le champ qui se trouve à l'offset <Offset> dans
// le buffer <Buffer>.
function GetPFieldData(Buffer : PChar; Offset : cardinal) : PFieldData; inline;
begin
  result := PFieldData(Buffer + Offset);
end;

// Renvoie true si le champ pointé par <Field> vaut NULL.
function IsNull(Field : PFieldData) : boolean; inline; overload;
begin
  result := Field.NullStatus < 0;
end;

// Renvoie true si le champ qui se trouve à l'offset <Offset> du buffer
// <Buffer> vaut NULL.
function IsNull(Buffer : PChar; Offset : cardinal) : boolean; inline; overload;
begin
  result := IsNull(GetPFieldData(Buffer, Offset));
end;

// Indique que le champ qui se trouve à l'offset <Offset> dans le buffer
// <Buffer> contient une valeur autre que NULL.
procedure ClearField(Buffer : PChar; Offset : cardinal); inline;
begin
  GetPFieldData(Buffer, Offset).NullStatus := DBNULL_VALUE;
end;

// Procède à l'ouverture du DataSet.
procedure TMemoryDataSet.InternalOpen;
var
  currentTime : int64;
begin
  SQLLogger.TraceBegin(EVENT_TRACE_TYPE_START, 'InternalOpen', currentTime,
    TRACE_LEVEL_VERBOSE);
  try
    FCursor := -1; // On se positionne au début du DataSet.

    // On va ouvrir le DataSet. C'est le moment pour calculer la taille des
    // buffers.
    CalcRecordSize;

    // Si les TField n'ont pas été créés en Design, on détruit les champs
    // existant pour les recréer à partir de leur définition actuelle.
    if DefaultFields
    then begin
      DestroyFields;
      CreateFields;
    end;

    // A présent, il faut faire mapper les TField sur les champs définis
    // dans TFieldDefs. En effet, les TField ont pu être créés en Design. Dans
    // ce cas, l'ordre des champs dans Fields peut ne pas être le même que dans
    // FieldDefs. Hors il faut initialiser la propriété FieldNo de chaque champ
    // pour connaître sa position à l'intérieure des buffers.
    BindFields(true);

    FIsCursorOpen := true; // L'ouverture vient d'être faite.

  finally
    SQLLogger.TraceEnd(EVENT_TRACE_TYPE_END, 'InternalOpen', currentTime,
      TRACE_LEVEL_VERBOSE);
  end;
end;

// Procède à la fermeture du DataSet.
procedure TMemoryDataSet.InternalClose;
var
  currentTime : int64;
begin
  SQLLogger.TraceBegin(EVENT_TRACE_TYPE_START, 'InternalClose', currentTime,
    TRACE_LEVEL_VERBOSE);
  try
    // Annule le binding des TField.
    BindFields(False);

    // Si les champs ont été créés à l'ouverture du DataSet, c'est le moment
    // de les détruire.
    if DefaultFields
    then DestroyFields;

    FIsCursorOpen := false; // Le curseur vient d'être fermé.
  finally
    SQLLogger.TraceEnd(EVENT_TRACE_TYPE_END, 'InternalClose', currentTime,
      TRACE_LEVEL_VERBOSE);
  end;
end;

// Indique si le curseur a été ouvert.
function TMemoryDataSet.IsCursorOpen: Boolean;
begin
  result := FIsCursorOpen;
end;

// Doit être surchargé pour initialiser la liste des FieldDefs, sans ouvrir
// le curseur sur la source de données.
procedure TMemoryDataSet.InternalInitFieldDefs;
begin
  SQLLogger.Trace(EVENT_TRACE_TYPE_INFO, 'InternalInitFieldDefs',
    TRACE_LEVEL_VERBOSE);

  // Comme la structure du dataset est définie manuellement par l'intermédiaire
  // des FieldDefs, on n'a rien à faire. Ils ont déjà été définits.
end;

// Retourne la taille d'un buffer.
function TMemoryDataSet.GetRecord(Buffer: PCha