type
  // 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..3] of byte; // Début des données du champ.
  end;

type
  // TLineBuffer désigne la structure d'un buffer.
  PLineBuffer = ^TLineBuffer;
  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 doit soustraire la taille de TLineBuffer.Data 

  // Maintenant, il faut ajouter la taille de chaque champ. On en profite 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 dans un buffer.
    FFieldInfo[i].Size := GetFieldSize(FieldDefs[i]);
    inc(currentOffset, sizeof(TFieldData) - 4 + FFieldInfo[i].Size);
  end;
  FRecordSize := currentOffset;     // On mémorise la taille du buffer qui vient d'être calculée.
  BookmarkSize := sizeof(cardinal); // On mémorise la taille d'un bookmark.

{$IFDEF TRACE}
  // On vient de calculer la taille des buffers. On trace cette information sous
  // la forme d'un message d'information au niveau TRACE_LEVEL_VERBOSE
  GenericLogger.Trace(EVENT_INFO, 'CalcRecordSize=' +
    IntToStr(FRecordSize), TRACE_LEVEL_VERBOSE);
{$ENDIF}  
end;

    FFieldInfo : array of TFieldInfo;

type
  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;

// Retourne la taille d'un buffer.
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
  ftGuid, ftString, ftFixedChar, ftBytes, ftVarBytes :
    result := FldDef.Size+1; // La taille correspond à la taille du champ plus un 0 terminal.
  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: // Le TCurrencyField veut lire un double dans le dataset
    result := sizeof(double);
  ftBCD: // Le TBCDField lit un currency depuis le dataset.
    result := sizeof(currency);
  ftFMTBcd : // Le TFMTBcdField lit un TBCD.
    result := sizeof(TBCD);
  ftDateTime, ftDate, ftTime : // Dans les trois cas, on lit un TDateTime.
    result := sizeof(TDateTime);
  ftTimeStamp:
    result := sizeof(TSQLTimeStamp);
  ftWideMemo, ftOraBlob, ftOraClob, ftBlob,
  ftMemo, ftGraphic, ftFmtMemo: // Les LOB font l'objet d'une gestion spéciale
    result := 4;
  ftFixedWideChar, ftWideString: // Chaînes unicode.
    result := FldDef.Size*2+2;
  ftLargeint: // Entier long
    result := sizeof(int64);
  ftVariant: // Le variant est stocké dans un variant...
    result := sizeof(variant);
  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
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'AllocRecordBuffer',
    TRACE_LEVEL_VERBOSE);
{$ENDIF}
  // 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
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'FreeRecordBuffer',
    TRACE_LEVEL_VERBOSE);
{$ENDIF}    

  // 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 <Buffer> contient la valeur 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
{$IFDEF TRACE}
  currentTime, Time2 : int64;
{$ENDIF}
  i : integer;
begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'InternalOpen', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    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
    // existants 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. Or il faut initialiser la propriété FieldNo de chaque champ
    // pour connaître sa position à l'intérieur des buffers.
{$IFDEF TRACE}
    GenericLogger.TraceBegin(EVENT_START, 'BindFields', Time2, TRACE_LEVEL_VERBOSE);
    try
{$ENDIF}
      BindFields(true);
{$IFDEF TRACE}
    finally
      GenericLogger.TraceEnd(EVENT_END, 'BindFields', Time2, TRACE_LEVEL_VERBOSE);
    end;
{$ENDIF}

    // On construit un index des champs LOB du dataset. On en profite également
    // pour rechercher et initialiser les auto-incréments.
    FBlobFields.Clear;
    FAutoIncFieldOffset := -1; // Pas de champ autoincrémenté par défaut.
    for i := 0 to Fields.Count -1 do
    begin
      if Fields[i].IsBlob
      then FBlobFields.Add(pointer(Fields[i].FieldNo));

      if Fields[i].DataType = ftAutoInc
      then FAutoIncFieldOffset := FFieldInfo[Fields[i].FieldNo-1].Offset;
    end;
    FIsCursorOpen := true; // L'ouverture vient d'être faite.
    ClearPages;

{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'InternalOpen', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}
end;

// Procède à la fermeture du DataSet.
procedure TMemoryDataSet.InternalClose;
{$IFDEF TRACE}
var
  currentTime : int64;
{$ENDIF}
begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'InternalClose', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    // 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é.
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'InternalClose', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

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

// Doit être surchargée pour initialiser la liste des FieldDefs, sans ouvrir
// le curseur sur la source de données.
procedure TMemoryDataSet.InternalInitFieldDefs;
begin
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'InternalInitFieldDefs', TRACE_LEVEL_VERBOSE);
{$ENDIF}

  // 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éfinis.
end;

function TMemoryDataSet.GetRecord(Buffer: PChar; GetMode: TGetMode;
  DoCheck: Boolean): TGetResult;
var
  TempBuf : PChar;
{$IFDEF TRACE}
  currentTime : int64;
{$ENDIF}

begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'GetRecord', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    // Premièrement, il faut rechercher l'enregistrement en fonction du mode de déplacement demandé.
    case GetMode of
    gmCurrent: // On veut l'enregistrement courant.
      begin
        dec(FCursor);   // on remonte d'un enregistrement
        FindNextRecord; // et on recherche l'enregistrement suivant
      end;
    gmPrior: // On veut l'enregistrement précédent.
      FindPriorRecord;
    gmNext: // On veut l'enregistrement suivant.
      FindNextRecord;
    end;

    // A présent, il faut vérifier si on se trouve au début ou à la fin du DataSet
    if (FCursor <0) // On se trouve au début, il faut renvoyer BOF.
    then result := grBOF
    else begin
      if FCursor>=integer(FLineIndex.Count) // On se trouve à la fin, on retourne EOF.
      then result := grEOF
      else begin // L'enregistrement existe, on lit le buffer.
        TempBuf := FLineIndex[FCursor];
        move(TempBuf^, Buffer^, RecordSize);
        PLineBuffer(Buffer).BkFlags := bfCurrent; // L'enregistrement est valide
        GetCalcFields(Buffer); // C'est le moment de calculer les champs calculés.
        result := grOK;
      end;
    end;
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'GetRecord', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

// Recherche l'enregistrement suivant sur la source de données.
function TMemoryDataSet.FindNextRecord: boolean;
var
  Accept : boolean;
  Buffer : PChar;
{$IFDEF TRACE}
  currentTime : int64;
{$ENDIF}

begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'FindNextRecord', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}  
    // On recherche le premier enregistrement suivant qui n'est pas filtré.
    repeat
      // On se déplace sur l'enregistrement suivant.
      inc(FCursor);
      if (FCursor<FLineIndex.Count) // Il faut vérifier si on a atteint la fin.
      then begin
        // L'enregistrement pointé par FCursor existe. Il faut vérifier s'il n'est pas filtré.
        Buffer := FLineIndex[FCursor];
        Accept := FilterRecord(Buffer);   // On regarde s'il n'est pas filtré
      end
      else begin
        Accept := false;
        FCursor := FLineIndex.Count;
      end;
    until Accept or (FCursor >=integer(FLineIndex.Count));
    result := Accept;
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'FindNextRecord', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

// Recherche l'enregistrement précédent sur la source de données.
function TMemoryDataSet.FindPriorRecord: boolean;
var
  Accept : boolean;
  Buffer : PChar;
{$IFDEF TRACE}
  currentTime : int64;
{$ENDIF}

begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'FindPriorRecord', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}  
    // On recherche le premier enregistrement précédent qui n'est pas filtré.
    repeat
      // On se déplace sur l'enregistrement précédent.
      dec(FCursor);
      if (FCursor>=0) // Il faut vérifier si on a atteint la fin.
      then begin
        // L'enregistrement pointé par FCursor existe. Il faut vérifier s'il n'est pas filtré.
        Buffer := FLineIndex[FCursor]; 
        Accept := FilterRecord(Buffer);   // On regarde s'il n'est pas filtré
      end
      else Accept := false;
    until Accept or (FCursor<0);
    result := Accept;
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'FindPriorRecord', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

// Teste si l'enregistrement <Buffer> est filtré ou doit être conservé.
// La méthode renvoie true si l'enregistrement doit faire partie du jeu
// de résultat.
function TMemoryDataSet.FilterRecord(Buffer: PChar): boolean;
var
  Accept : boolean;
  OldState : TDataSetState;
{$IFDEF TRACE}
  currentTime : int64;
{$ENDIF}

begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'FilterRecord', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}  
    // Par défaut, l'enregistrement est conservé.
    Accept := true;

    if Filtered and Assigned(OnFilterRecord)
    then begin
      // On doit basculer le Dataset dans l'état dsFilter. Dans ce mode, les TField ne lisent plus
      // la ligne courante du DataSet, mais la ligne mémorisée dans FilterBuffer. De cette façon,
      // l'événement OnFilterRecord pourra lire les champs de la ligne à filtrer au lieu de ceux
      // de la ligne courante.
      OldState := SetTempState(dsFilter);
      try
        FFilterBuffer := Buffer;

        // Si les filtres sont activés et qu'un gestionnaire d'événement
        // OnFilterRecord existe, il faut l'appeler.
        OnFilterRecord(Self, Accept);

      finally
        RestoreState(OldState);
        FFilterBuffer := nil;
      end;
    end;
    result := Accept;
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'FilterRecord', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

// Lit la valeur du BookmarkFlag du buffer.
function TMemoryDataSet.GetBookmarkFlag(Buffer: PChar): TBookmarkFlag;
begin
  result := PLineBuffer(Buffer).BkFlags
end;

// Ecrit la valeur du BookmarkFlag du buffer.
procedure TMemoryDataSet.SetBookmarkFlag(Buffer: PChar; Value: TBookmarkFlag);
begin
  PLineBuffer(Buffer).BkFlags := Value;
end;

// Lit la valeur du bookmark de <buffer> et la retourne dans la zone pointée
// par <Data>.
procedure TMemoryDataSet.GetBookmarkData(Buffer: PChar; Data: Pointer);
begin
  cardinal(Data^) := PLineBuffer(Buffer).Bookmark;
end;

// Ecrit la valeur du bookmark <Data> à l'intérieur du buffer <Buffer>
procedure TMemoryDataSet.SetBookmarkData(Buffer: PChar; Data: Pointer);
begin
  PLineBuffer(Buffer).Bookmark := Cardinal(Data^);
end;

// Recherche la ligne qui possède le bookmark <Bookmark>.
procedure TMemoryDataSet.InternalGotoBookmark(Bookmark: Pointer);
var
  TestCursor : integer;
{$IFDEF TRACE}
  currentTime : int64;
{$ENDIF}

begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'InternalGotoBookmark', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    TestCursor := FindBookmark(Bookmark);

    if TestCursor <0
    then raise MemoryDataSetException.Create('Enregistrement non trouvé !');

    FCursor := TestCursor;
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'InternalGotoBookmark', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

// Recherche le numéro de la ligne qui possède le bookmark <Bookmark>.
// Si la ligne n'existe pas, la fonction renvoie -1
function TMemoryDataSet.FindBookmark(Bookmark: pointer): integer;
var
  bk : cardinal;
  TestCursor : integer;
  bkTest : cardinal;
  borneMin, borneMax : cardinal;
begin
  bk := Cardinal(Bookmark^);

  // Les lignes sont triées dans l'ordre des bookmark dans FBookmarkIndex.
  // On effectue donc une recherche dichotomique dans la liste.

  // On commence par utiliser la valeur du bookmark comme point de départ pour
  // la recherche.
  borneMin := 0;
  borneMax := FBookmarkIndex.Count -1;

  while (borneMax-borneMin)>3 do
  begin
    TestCursor := (borneMin + borneMax) div 2;
    bkTest := cardinal(FBookmarkIndex[TestCursor]);
    if bkTest>=bk
    then borneMax := TestCursor
    else borneMin := TestCursor;
  end;

  // A présent, on a restreint l'intervale de recherche, on termine par une
  // recherche séquentielle. 
  result := -1; // Par défaut, le bookmark n'a pas été trouvé.
  for TestCursor := borneMin to borneMax do
  begin
    if cardinal(FBookmarkIndex[TestCursor]) = bk
    then begin // Le bookmark a été trouvé.
      result := TestCursor;
      break;
    end;
  end;
end;

// Indique si le bookmark <Bookmark> référence un enregistrement du jeu de
// données.
function TMemoryDataSet.BookmarkValid(Bookmark: TBookmark): Boolean;
begin
  result := FindBookmark(Bookmark)<>-1;
end;

// Positionne le jeu de données sur l'enregistrement <Buffer>.
procedure TMemoryDataSet.InternalSetToRecord(Buffer: PChar);
{$IFDEF TRACE}
var
  currentTime : int64;
{$ENDIF}
begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'InternalSetToRecord', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    InternalGotoBookmark(@(PLineBuffer(Buffer).Bookmark));
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'InternalSetToRecord', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}
end;

// Positionne le curseur sur le premier enregistrement du jeu de données.
procedure TMemoryDataSet.InternalFirst;
begin
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'InternalFirst', TRACE_LEVEL_VERBOSE);
{$ENDIF}  
  FCursor := -1; // On se positionne au début.
end;

// Positionne le curseur sur le dernier enregistrement du jeu de données.
procedure TMemoryDataSet.InternalLast;
begin
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'InternalLast', TRACE_LEVEL_VERBOSE);
{$ENDIF}  
  FCursor := FLineIndex.Count; // On se positionne à la fin.
end;

// positionne le DataSet sur l'enregistrement <Value>.
procedure TMemoryDataSet.SetRecNo(Value: Integer);
{$IFDEF TRACE}
var
  currentTime : int64;
{$ENDIF}
begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'SetRecNo', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    CheckBrowseMode; // On s'assure que le dataset est ouvert et déplaçable.
    dec(Value); // Le premier enregistrement porte le numéro 1
    if Value<>FCursor // On ne fait le traitement que si on se déplace vraiment
    then begin
      // Déclanche l'événement BeforeScroll.
      DoBeforeScroll;

      // Positionne le curseur à la position demandée.
      FCursor := Value;

      // Provoque la relecture des buffers du DataSet.
      Resync([rmCenter]);

      // Déclenche l'événement AfterScroll.
      DoAfterScroll;
    end;
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'SetRecNo', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

function GetFieldData(Field: TField;
   Buffer: Pointer): Boolean; overload; override;
   
function GetFieldData(FieldNo: Integer;
  Buffer: Pointer): Boolean; overload; override;
   
function GetFieldData(Field: TField;
  Buffer: Pointer; NativeFormat: Boolean): Boolean; overload; override;

// Retourne dans Buffer les données du champ <FieldNo>. Si le champ est à
// NULL, la fonction retourne false.
function TMemoryDataSet.GetFieldData(FieldNo: Integer;
  Buffer: Pointer): Boolean;
var
  LineBuf : PChar;
  FieldOffset : cardinal;
  FieldSize : cardinal;
begin
  CheckActive; // Le DataSet doit être ouvert.

  LineBuf := GetActiveBuffer; // On recherche le buffer de la ligne à lire.

  FieldOffset := FFieldInfo[FieldNo-1].Offset;
  FieldSize := FFieldInfo[FieldNo-1].Size;

  // On commence par regarder si la valeur du champ est définie
  result := Assigned(LineBuf) and not IsNull(LineBuf, FieldOffset);

  // Si Buffer est défini, il faut également lire la valeur
  if result and Assigned(Buffer)
  then move(GetPFieldData(LineBuf, FieldOffset).Data, Buffer^, FieldSize);

  case FieldDefs[FieldNo-1].DataType of
  ftTimeStamp:
    TSQLTimeStamp(Buffer^).Fractions := TSQLTimeStamp(Buffer^).Fractions div 1000000;
  end;
end;

// Retourne le Buffer à Lire/Ecrire en fonction de l'état du DataSet.
function TMemoryDataSet.GetActiveBuffer: PChar;
begin
  case State of
    dsBlockRead, dsSetKey, dsCalcFields: // Non géré.
      result := nil;
    dsBrowse: // Cas normal, on renvoie ActiveBuffer sauf si le dataset est vide
      if IsEmpty
      then result := nil
      else result := ActiveBuffer;
    dsEdit, dsInsert: // En Edit ou Insert on utilise toujours ActiveBuffer
      result := ActiveBuffer;
    dsFilter: // On est en train de filtrer les enregistrements, il faut
              // utiliser l'enregistrement FFilterBuffer.
      result := FFilterBuffer;
    dsNewValue: // On veut lire/ecrire la nouvelle valeur d'une ligne en cours
                // de modification. On retourne ActiveBuffer.
      result := ActiveBuffer;
    dsOldValue: // On veut lire l'ancienne valeure d'une ligne en cours de
                // modification. On retourne FOldBuffer.
      result := FOldBuffer;
  else
    result := nil;
  end;
end;

// Définit la valeur d'un champ.
procedure TMemoryDataSet.SetFieldData(Field: TField; Buffer: Pointer);
var
  LineBuf : PCHar;
  FieldOffset : cardinal;
  FieldSize : cardinal;
  FieldData : PFieldData;
begin
  CheckActive; // On vérifie que le DataSet est ouvert.

  // On vérifie que le dataset se trouve dans un état autorisant les écritures.
  if not (State in dsWriteModes)
  then DatabaseError(SNotEditing, Self);

  // On rechercher le buffer de la ligne à modifier.
  LineBuf := GetActiveBuffer;

  if Field.FieldNo > 0 // Les champs calculés ne sont pas supportés !
  then begin
    // Si le champ est en lecture seule, on ne peut pas le modifier
    if Field.ReadOnly
    then DatabaseErrorFmt(SFieldReadOnly, [Field.FieldName]);

    // Déclenche l'événement on Validate du TField.
    Field.Validate(Buffer);

    FieldOffset := FFieldInfo[Field.FieldNo-1].Offset;
    FieldSize := FFieldInfo[Field.FieldNo-1].Size;
     
    if Assigned(Buffer) // On définit une valeur pour le champ
    then begin
      // On commence par obtenir le pointeur sur les données du champ
      FieldData := GetPFieldData(LineBuf, FieldOffset);

      // Le champ ne vaut pas NULL.
      FieldData.NullStatus := DBNOTNULL_VALUE;

      move(Buffer^, FieldData.Data, FieldSize);
      case Field.DataType of
      ftTimeStamp:
        TSQLTimeStamp((@FieldData.Data[0])^).Fractions := 
                TSQLTimeStamp((@FieldData.Data[0])^).Fractions * 1000000;         
      end;
    end
    else ClearField(LineBuf, FieldOffset);

    // Enfin, il faut déclencher les événements
    if not (State in [dsCalcFields, dsFilter, dsNewValue])
    then DataEvent(deFieldChange, Longint(Field));
  end;
end;

// Réserve une position pour la valeur d'un LOB et retourne l'emplacement réservé.
function TMemoryDataSet.AllocBlob: cardinal;
begin
  // On commence par regarder dans FEmptyBlob pour voir si un LOB préalablement
  // défini ne peut pas être recyclé.
  if FEmptyBlob.Count > 0
  then begin
    // Il existe un élément recyclable. On renvoie la dernière position libérée.
    result := cardinal(FEmptyBlob[FEmptyBlob.Count-1]);
    FEmptyBlob.Delete(FEmptyBlob.Count-1);
  end
  else begin
    // Il n'existe pas d'élément recyclable. On crée un nouvel emplacement.
    result := FBlobList.Add(nil);
  end;
end;

// Libère un LOB préalablement alloué avec AllocBlob
procedure TMemoryDataSet.ReleaseBlob(idx: cardinal);
begin
  if integer(idx) < FBlobList.Count
  then begin
    Freemem(FBlobList[idx]); // Libère la mémoire utilisée par le LOB
    FBlobList[idx] := nil;  // Le pointeur ne référence plus rien.
    FEmptyBlob.Add(pointer(idx)); // Ajoute l'emplacement aux LOB à recycler.
  end;
end;

  // TMemoryBlobStream permet de manipuler les données d'un champ LOB comme
  // s'il s'agissait d'un TStream.
  TMemoryBlobStream = class(TStream)
  private
    FDataSet : TMemoryDataSet; // DataSet à lire/écrite
    FBlobData : pointer;       // pointeur sur les données du LOB à lire.
    FFieldData : pointer;      // pointeur sur le champ LOB manipulé
    FieldOffset : cardinal;    // offset du champ à l'intérieur d'un Buffer.
    FBlobIdx : cardinal;       // Numéro du LOB à l'intérieur du dataset.
    FSize : cardinal;          // Longueur du LOB.
    FMode : TBlobStreamMode;   // Mode d'accès demandé.
    FLineBuf : PChar;          // Buffer de la ligne contenant le LOB.
  public
    // Crée et initialise une nouvelle instance de la classe TMemoryBlobStream
    constructor Create(Field : TField; Mode: TBlobStreamMode);

    // Detruit l'instance et libère la mémoire utilisée.
    destructor Destroy; override;

    // Lit les données depuis le LOB.
    function Read(var Buffer; Count: Longint): Longint; override;

    // Ecrit les données dans le LOB.
    function Write(const Buffer; Count: Longint): Longint; override;

    // Déplace le curseur à l'intérieur du LOB.
    function Seek(Offset: Longint; Origin: Word): Longint; override;
  end;

// Crée et initialise une nouvelle instance de la classe TMemoryBlobStream
constructor TMemoryBlobStream.Create(Field: TField; Mode: TBlobStreamMode);
begin
  // On commence par mémoriser les paramètres de création.
  FDataSet := TMemoryDataSet(Field.DataSet);
  FMode := Mode;

  // On lit les informations du champ pour lequel on veut accéder au LOB.
  FLineBuf := FDataSet.GetActiveBuffer;
  FieldOffset := FDataSet.FFieldInfo[Field.FieldNo-1].Offset;
  FFieldData := GetPFieldData(FLineBuf, FieldOffset);
  FBlobIdx := cardinal(PFieldData(FFieldData).Data[0]);

  // Maintenant, le mode d'accès demandé determine la suite des traitements
  case Mode of
  bmRead: // Lecture seul.
    begin
      // On doit juste retourner un flux en lecture seule. Dans ce cas, il suffit
      // d'initialiser les paramètres de lecture.
      if IsNull(PFieldData(FFieldData))
      then FSize := 0 // Pour les champs NULL, on doit retourner un flux de
                      // longueur 0.
      else begin
        // Le champ existe, on initialise la taille et le buffer à lire.
        // Les LOB sont stockés indirectement. Le champ contient le numéro du
        // tampon dans FBlobList.
        FBlobData := FDataSet.FBlobList[FBlobIdx];

        // La taille du LOB est donnée par la longueur courante du champ.
        FSize := PFieldData(FFieldData).LengthValue;
      end;
    end;
  bmWrite, bmReadWrite: // Le mode bmReadWrite n'est pas supporté. Il est traité
    begin               // Comme un write et tronque le champ.
      // On doit pouvoir écrire le champ. Ca signifie que si le champ est à NULL
      // il faut créer un nouveau tampon de données.
      if IsNull(PFieldData(FFieldData))
      then begin
        FBlobData := nil; // Pour l'instant le buffer n'est pas défini.
        FBlobIdx := FDataSet.AllocBlob; // On demande au dataset de réserver
                                        // un emplacement pour le LOB.

        // On définit la valeur du champ sur le nouveau LOB.
        PFieldData(FFieldData).NullStatus := DBNOTNULL_VALUE;
        PFieldData(FFieldData).LengthValue := 0;
        move(FBlobIdx, PFieldData(FFieldData).Data[0], sizeof(FBlobIdx));
      end
      else begin
        // Le champ existe, on initialise la taille et le buffer à lire.
        // Les LOB sont stockés indirectement. Le champ contient le numéro du
        // tampon dans FBlobList.

        // On vide le LOB qui va être réécrit.
        Freemem(FDataSet.FBlobList[FBlobIdx]);
        FDataSet.FBlobList[FBlobIdx] := nil;
        FBlobData := nil;
        FSize := 0;
        PFieldData(FFieldData).LengthValue := 0;
      end;
    end;
  end;
end;

// Lit les données depuis le LOB.
function TMemoryBlobStream.Read(var Buffer; Count: Integer): Longint;
begin
  // On limite la lecture aux données disponibles
  if Count > integer(FSize)
  then Count := FSize;

  if (FBlobData<>nil)
  then begin
    move(FBlobData^, Buffer, Count);
    result := count;
  end
  else result := 0;
end;

// Ecrit les données dans le LOB.
function TMemoryBlobStream.Write(const Buffer; Count: Integer): Longint;
begin
  // On alloue un bloc mémoire pour contenir les données à écrire.
  GetMem(FBlobData, Count);
  FDataSet.FBlobList[FBlobIdx] := FBlobData;

  move(Buffer, FBlobData^, Count); // recopie des données du LOB

  // On définit la nouvelle taille du champ.
  FSize := Count;
  PFieldData(FFieldData).LengthValue := FSize;

  result := count;
end;

// Detruit l'instance et libère la mémoire utilisée.
destructor TMemoryBlobStream.Destroy;
begin
  // Si on a définit un LOB de longueur 0, le champ doit passer à NULL.
  if (FMode = bmWrite) or (FMode = bmReadWrite)
  then begin
    if FSize = 0
    then begin
      ClearField(FLineBuf, FieldOffset);
      FDataSet.ReleaseBlob(FBlobIdx);
    end;
  end;
  inherited Destroy;
end;

function TMemoryDataSet.CreateBlobStream(Field: TField;
  Mode: TBlobStreamMode): TStream;
begin
  result := TMemoryBlobStream.Create(Field, Mode);
end;

// Indique si le Dataset peut être modifié.
function TMemoryDataSet.GetCanModify: boolean;
begin
  result := FIsCursorOpen;
end;

// Réagit au passage en mode Edition du Dataset.
procedure TMemoryDataSet.InternalEdit;
begin
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'InternalEdit', TRACE_LEVEL_VERBOSE);
{$ENDIF}
  // On garde une référence sur la ligne en cours de modification.
  FOldBuffer := FLineIndex[FCursor];

  // Ensuite, on effectue une copie des LOB de la ligne en cours. De cette façon
  // en cas de modification, on ne touche pas au LOB avant modification,
  // seule la copie est modifiée.
  CopyBufferBlob(GetActiveBuffer);

  inherited InternalEdit;
end;

// Remplace les LOB du buffer <Buffer> par une copie de leur valeur.
procedure TMemoryDataSet.CopyBufferBlob(Buffer: PChar);
var
  FieldNo : cardinal;
  Offset : Cardinal;
  Data : PFieldData;
  Valeur, ValeurDest,
  size : cardinal;
  ptr : pointer;
  i : integer;
begin
  for i := 0 to FBLobList.Count -1 do
  begin
    FieldNo := cardinal(FBLobList[i]);
    Offset := FFieldInfo[FieldNo-1].Offset;
    Data := GetPFieldData(Buffer, Offset);
    if not IsNull(Data)
    then begin
      // On lit la valeur et la taille du LOB à copier.
      Valeur := cardinal(Data.Data[0]);
      size := Data.LengthValue;

      // On alloue un nouveau LOB pour la copie.
      ValeurDest := AllocBlob;

      // Copie de la valeur.
      GetMem(ptr, Size);
      move(FBlobList[Valeur]^, ptr^, size);
      FBlobList[ValeurDest] := ptr;

      // On affecte la nouvelle valeur au champ destination.
      move(ValeurDest, Data.Data[0], sizeof(ValeurDest));
    end;
  end;
end;

// Réagit à l'annulation des modifications.
procedure TMemoryDataSet.InternalCancel;
begin
{$IFDEF TRACE}
  GenericLogger.Trace(EVENT_INFO, 'InternalCancel', TRACE_LEVEL_VERBOSE);
{$ENDIF}  
  // Le TDataSet traite automatiquement l'annulation des modifications :
  // Les buffers vont être relus sur la source de données.
  // Cependant, comme les LOB ont été dupliqués au moment du passage en mode
  // edition, il faut les détruire.
  ReleaseBufferBlob(GetActiveBuffer);
  FOldBuffer := nil;
end;

// Valide les modifications de l'enregistrement.
procedure TMemoryDataSet.InternalPost;
var
{$IFDEF TRACE}
  currentTime : int64;
{$ENDIF}
  Buffer : Pointer;
  FieldData : PFieldData;
begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'InternalPost', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}  
    Buffer := GetActiveBuffer;
    if State = dsEdit
    then begin
      // Commençons par le cas simple. La ligne courante est en cours de modification. Il faut
      // écrire le buffer dans la source de données. Cela signifie que la ligne avant modification
      // va être écrasée. Si elle contenait des LOB, il faut également détruire ces LOB.
      ReleaseBufferBlob(FOldBuffer);
      move(Buffer^, FLineIndex[FCursor]^, RecordSize);
    end
    else begin
      // On est en insertion (dsInsert), il faut ajouter la ligne à la source de données.
      // Si le dataset contient des champs auto incrémentés, il faut gérer l'autoincrément.
      if FAutoIncFieldOffset<>-1
      then begin
        // On a un champ auto incrémenté, il faut définir sa valeur.
        FieldData := GetPFieldData(Buffer, FAutoIncFieldOffset);
        inc(FAutoIncValue);
        FieldData.NullStatus := DBNOTNULL_VALUE;
        move(FAutoIncValue, FieldData.Data[0], sizeof(FAutoIncValue));
      end;
      FCursor := AddLine(Buffer);
    end;
    FOldBuffer := nil; // Le buffer n'est plus valide.
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'InternalPost', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}
end;

// Supprime la ligne en cours.
procedure TMemoryDataSet.InternalDelete;
{$IFDEF TRACE}
var
  currentTime : int64;
{$ENDIF}
begin
{$IFDEF TRACE}
  GenericLogger.TraceBegin(EVENT_START, 'InternalDelete', currentTime, TRACE_LEVEL_VERBOSE);
  try
{$ENDIF}
    // On commence par détruire les LOB de la ligne à supprimer.
    ReleaseBufferBlob(FLineIndex[FCursor]);

    // La ligne va être supprimée, on ajoute l'emplacement à la liste des lignes à recycler.
    FEmptyLine.Add(FLineIndexCursor[FCursor]);

    FLineIndex.Delete(FCursor); // La ligne n'existe plus.
    FLineIndexCursor.Delete(FCursor); // La ligne n'existe plus.
    FBookmarkIndex.Delete(FCursor); // La ligne n'existe plus.
{$IFDEF TRACE}
  finally
    GenericLogger.TraceEnd(EVENT_END, 'InternalDelete', currentTime, TRACE_LEVEL_VERBOSE);
  end;
{$ENDIF}  
end;

  FMemoryDataSet := TMemoryDataSet.Create(nil);
  FMemoryDataSet.FieldDefs.Add('ftString', ftString, 20);
  FMemoryDataSet.FieldDefs.Add('ftSmallint', ftSmallint);
  FMemoryDataSet.FieldDefs.Add('ftInteger', ftInteger);
  FMemoryDataSet.FieldDefs.Add('ftWord', ftWord);
  FMemoryDataSet.FieldDefs.Add('ftBoolean', ftBoolean);
  FMemoryDataSet.FieldDefs.Add('ftFloat', ftFloat);
  FMemoryDataSet.FieldDefs.Add('ftCurrency', ftCurrency);
  FMemoryDataSet.FieldDefs.Add('ftBCD', ftBCD, 2);
  FMemoryDataSet.FieldDefs.Add('ftDate', ftDate);
  FMemoryDataSet.FieldDefs.Add('ftTime', ftTime);
  FMemoryDataSet.FieldDefs.Add('ftDateTime', ftDateTime);
  FMemoryDataSet.FieldDefs.Add('ftAutoInc', ftAutoInc);
  FMemoryDataSet.FieldDefs.Add('ftFixedChar', ftFixedChar, 10);
  FMemoryDataSet.FieldDefs.Add('ftWideString', ftWideString, 20);
  FMemoryDataSet.FieldDefs.Add('ftLargeint', ftLargeint);
  FMemoryDataSet.FieldDefs.Add('ftGuid', ftGuid, 38);
  FMemoryDataSet.FieldDefs.Add('ftFMTBcd', ftFMTBcd, 4);
  FMemoryDataSet.FieldDefs.Add('ftBytes', ftBytes, 40);
  FMemoryDataSet.FieldDefs.Add('ftVarBytes', ftVarBytes, 40);
  FMemoryDataSet.FieldDefs.Add('ftOraBlob', ftOraBlob);
  FMemoryDataSet.FieldDefs.Add('ftOraClob', ftOraClob);
  FMemoryDataSet.FieldDefs.Add('ftBlob', ftBlob);
  FMemoryDataSet.FieldDefs.Add('ftMemo', ftMemo);
  FMemoryDataSet.FieldDefs.Add('ftGraphic', ftGraphic);
  FMemoryDataSet.FieldDefs.Add('ftFmtMemo', ftFmtMemo);
  FMemoryDataSet.FieldDefs.Add('ftWideMemo', ftWideMemo);

  FMemoryDataSet.Open;
  FMemoryDataSet.Close;

for i := 0 to Fields.count-1 do
begin
  Fields[i].FieldNo := i+1;
end;

  TPrivateField = class(TComponent)
  public
    FAutoGenerateValue: TAutoRefreshFlag;
    FDataSet: TDataSet;
    FFieldName: WideString;
    FFields: TFields;
    FDataType: TFieldType;
    FReadOnly: Boolean;
    FFieldKind: TFieldKind;
    FAlignment: TAlignment;
    FVisible: Boolean;
    FRequired: Boolean;
    FValidating: Boolean;
    FSize: Integer;
    FOffset: Integer;
    FFieldNo: Integer;
    FDisplayWidth: Integer;
  end;

procedure TMemoryDataSet.BindFields(Binding: boolean);
var
  i : integer;
  Field : TPrivateField;
begin
  if Binding
  then begin
    for i := 0 to Fields.Count -1 do
    begin
      Field := TPrivateField(Fields[i]);
      Field.FFieldNo := i+1;
      TProtectedField(Field).Bind(Binding);
    end;
  end
  else begin
    for i := 0 to Fields.Count -1 do
    begin
      Field := TPrivateField(Fields[i]);
      Field.FFieldNo := 0;
      TProtectedField(Field).Bind(Binding);
    end;
  end;
end;