NavigationInfo.FirstPosition := False;
         repeat
          ClearBLOBFieldsInRecordBuffer(NavigationInfo.RecordBuffer);
          FRecordManager.GetRecordBuffer(SYSTEM_SESSION_ID, NavigationInfo);
         until (NavigationInfo.GetRecordResult <> grrOK);
        end;
     finally
      MemoryManager.FreeAndNillMem(NavigationInfo.RecordBuffer);
     end;
    end;
 if (FRecordManager <> nil) then
  FRecordManager.Empty(SYSTEM_SESSION_ID);

 FPageManager.ApplyChanges(SYSTEM_SESSION_ID);
end; // EmptyTable


//------------------------------------------------------------------------------
// open table
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.OpenTable(Cursor: TMYLDBCursor);
begin
 TableName := Cursor.TableName;
 inherited OpenTable(Cursor);
end;// OpenTable


//------------------------------------------------------------------------------
// close table
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.CloseTable(Cursor: TMYLDBCursor);
begin
 inherited CloseTable(Cursor);
end;// CloseTable


//------------------------------------------------------------------------------
// AddIndex
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.AddIndex(IndexDef: TMYLDBIndexDef; Cursor: TMYLDBCursor);
begin
  Lock;
  try
    inherited AddIndex(IndexDef, Cursor);
    if (not Cursor.Session.InTransaction) then
      PageManager.ApplyChanges(Cursor.Session.SessionID);
  finally
    Unlock;
  end;
end;// AddIndex


//------------------------------------------------------------------------------
// DeleteIndex
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.DeleteIndex(IndexID: TMYLDBObjectID; Cursor: TMYLDBCursor);
begin
  Lock;
  try
    inherited DeleteIndex(IndexID, Cursor);
    if (Cursor <> nil) then
      begin
        if (not Cursor.Session.InTransaction) then
          PageManager.ApplyChanges(Cursor.Session.SessionID);
      end
    else
      PageManager.ApplyChanges(SYSTEM_SESSION_ID);
  finally
    Unlock;
  end;
end;// DeleteIndex


//------------------------------------------------------------------------------
// Write BLOB Field To Record Buffer
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.WriteBLOBFieldToRecordBuffer(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              BLOBStream: TMYLDBStream
              );
var Buffer:                   PChar;
    BufferSize,Offset:        Integer;
    ReadBytes:                Integer;
begin
 Lock;
 try
   Buffer := Cursor.CurrentRecordBuffer;
   if (BLOBStream.Modified) then
    begin
     if (BLOBStream.Size = 0) then
      begin
       // empty stream
       ClearBLOBFieldInRecordBuffer(Buffer,FieldNo);
       Buffer := nil;
       Move(Buffer,PChar(Cursor.CurrentRecordBuffer +
        FieldManager.FieldDefs[FieldNo].MemoryOffset)^,sizeof(Buffer));
       SetNullFlag(True,FieldNo,Cursor.CurrentRecordBuffer);
      end
     else
      begin
       ClearBLOBFieldInRecordBuffer(Buffer,FieldNo);
       Offset := sizeof(TMYLDBPartialBLOBDescriptor);
       BufferSize := Integer(TMYLDBCompressedBLOBStream(
          TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).CompressedStream.Size) +
          Offset;
       Buffer := MemoryManager.GetMem(BufferSize);
       PMYLDBPartialBLOBDescriptor(Buffer)^.NumBlocks := TMYLDBCompressedBLOBStream(
          TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).BLOBDescriptor.NumBlocks;
       PMYLDBPartialBLOBDescriptor(Buffer)^.UncompressedSize := TMYLDBCompressedBLOBStream(
          TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).BLOBDescriptor.UncompressedSize;
       TMYLDBCompressedBLOBStream(
          TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).CompressedStream.
          Position := 0;

       ReadBytes := TMYLDBCompressedBLOBStream(
          TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).CompressedStream.
          Read(PChar(Buffer + Offset)^,(BufferSize - Offset));

       if (ReadBytes <> (BufferSize - Offset)) then
        begin
          MemoryManager.FreeAndNillMem(Buffer);
          raise EMYLDBException.Create(10117,ErrorLCannotReadFromStream,
          [0,(BufferSize - Offset),(BufferSize - Offset),ReadBytes]);
        end;

       //Move(Buffer,PChar(Cursor.CurrentRecordBuffer +
       //  FieldManager.FieldDefs[FieldNo].MemoryOffset)^, sizeof(Buffer));
       PCardinal(Cursor.CurrentRecordBuffer + FieldManager.FieldDefs[FieldNo].MemoryOffset)^ := Cardinal(Buffer);

       SetNullFlag(False,FieldNo,Cursor.CurrentRecordBuffer);
      end; // not empty stream
    end; // Modified
 finally
  Unlock;
 end;
end; // WriteBLOBFieldToRecordBuffer


//------------------------------------------------------------------------------
// create blob stream
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.ClearBLOBFieldInRecordBuffer(
              RecordBuffer: TMYLDBRecordBuffer;
              FieldNo:      Integer);
var Buffer: PChar;
begin
 Lock;
 try
   if (FFieldManager.BlobFieldsPresent) then
    begin
     // check null
     if (not ((PByte(RecordBuffer + (FieldNo div 8))^) and
            (1 shl (FieldNo mod 8)) <> 0)) then
      begin
       Move(PChar(RecordBuffer +
         FieldManager.FieldDefs[FieldNo].MemoryOffset)^,Buffer,sizeof(Buffer));
       if (Buffer = nil) then
        raise EMYLDBException.Create(10118,ErrorLNilPointer);
       MemoryManager.FreeAndNillMem(Buffer);

       // set null
       PByte(RecordBuffer + (FieldNo div 8))^ := PByte(RecordBuffer + (FieldNo div 8))^ or
        (1 shl (FieldNo mod 8));
      end;
    end;
 finally
  Unlock;
 end;
end; // ClearBLOBFieldInRecordBuffer


//------------------------------------------------------------------------------
// create blob stream
//------------------------------------------------------------------------------
function TMYLDBMemoryTableData.InternalCreateBlobStream(
              Cursor:   TMYLDBCursor;
              ToInsert: Boolean;
              FieldNo:  Integer;
              OpenMode: TMYLDBBLOBOpenMode
              ): TMYLDBStream;
var
    TempStream:             TMYLDBTemporaryStream;
    CompressedStream:       TMYLDBCompressedBLOBStream;
    Buffer:                 PChar;
    Offset,BufferSize:      Integer;
    BLOBDescriptor:         TMYLDBBLOBDescriptor;
begin
 Lock;
 try
   Result := nil;
   BLOBDescriptor.CompressionAlgorithm :=
       Byte(FieldManager.FieldDefs[FieldNo].BLOBCompressionAlgorithm);
   BLOBDescriptor.CompressionMode := FieldManager.FieldDefs[FieldNo].BLOBCompressionMode;
   BLOBDescriptor.BlockSize := FieldManager.FieldDefs[FieldNo].BLOBBlockSize;
   if (BLOBDescriptor.BlockSize = 0) then
    raise EMYLDBException.Create(10420,ErrorLZeroBlockSizeIsNotAllowed);
   BLOBDescriptor.StartPosition := 0;
   TempStream := TMYLDBTemporaryStream.Create(FDisableTempFiles);
   // create new compressed stream
   if ((ToInsert and (OpenMode = bomWrite)) or (OpenMode = bomWrite) or
       (Cursor.CurrentRecordBuffer = nil) or
       (CheckNullFlag(FieldNo,Cursor.CurrentRecordBuffer))) then
    begin
     // empty stream
     BLOBDescriptor.NumBlocks := 0;
     BLOBDescriptor.UncompressedSize := 0;
     CompressedStream := TMYLDBCompressedBLOBStream.Create(TempStream,
      BLOBDescriptor,True);
     Result := TMYLDBLocalBLOBStream.Create(CompressedStream,Cursor,OpenMode,FieldNo);
    end // empty stream
   else
    begin
     // copy value from TableData
     Offset := FieldManager.FieldDefs[FieldNo].MemoryOffset;
     // get pointer to memory buffer with blob stream content

     //Move(PChar(Cursor.CurrentRecordBuffer + Offset)^,Buffer,Sizeof(Buffer));
     Buffer := PChar(PCardinal(Cursor.CurrentRecordBuffer + Offset)^);

     if (Buffer = nil) then
      raise EMYLDBException.Create(10112,ErrorLNilPointer);
     // creating source memory stream
     Offset := sizeof(TMYLDBPartialBLOBDescriptor);
     BufferSize := MemoryManager.GetMemoryBufferSize(Buffer) - Offset;
     // copy partial blob descriptor
     BLOBDescriptor.NumBlocks := PMYLDBPartialBLOBDescriptor(Buffer)^.NumBlocks;
     BLOBDescriptor.UncompressedSize := PMYLDBPartialBLOBDescriptor(Buffer)^.UncompressedSize;
     TempStream.Write(PChar(Buffer + Offset)^,BufferSize);
     TempStream.Position := 0;
     CompressedStream := TMYLDBCompressedBLOBStream.Create(TempStream,
      BLOBDescriptor,False);
     Result := TMYLDBLocalBLOBStream.Create(CompressedStream,Cursor,OpenMode,FieldNo);
    end; // copy value from TableData
 finally
  Unlock;
 end;
end; // InternalCreateBlobStream


//------------------------------------------------------------------------------
// GetDirectBlobData
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.GetDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar);
var
    Buffer:                 PChar;
    Offset,BufferSize:      Integer;
begin
 Lock;
 try
   if (CheckNullFlag(FieldNo,RecordBuffer)) then
    begin
     BLOBDescriptor.NumBlocks := 0;
     BLOBDescriptor.UncompressedSize := 0;
     BLOBDescriptor.CompressedSize := 0;
     pBlobData := nil;
    end
   else
    begin
     // copy value from TableData
     Offset := FieldManager.FieldDefs[FieldNo].MemoryOffset;
     // get pointer to memory buffer with blob stream content
     Buffer := PChar(PCardinal(RecordBuffer + Offset)^);
     if (Buffer = nil) then
      raise EMYLDBException.Create(10511,ErrorLNilPointer);
     // creating source memory stream
     Offset := sizeof(TMYLDBPartialBLOBDescriptor);
     BufferSize := MemoryManager.GetMemoryBufferSize(Buffer) - Offset;
     // copy partial blob descriptor
     BLOBDescriptor.NumBlocks := PMYLDBPartialBLOBDescriptor(Buffer)^.NumBlocks;
     BLOBDescriptor.UncompressedSize := PMYLDBPartialBLOBDescriptor(Buffer)^.UncompressedSize;
     BLOBDescriptor.CompressedSize := BufferSize;
     // get blob data
     pBlobData := MemoryManager.GetMem(BufferSize);
     Move(PChar(Buffer + Offset)^,pBlobData^,BufferSize);
    end; // copy value from TableData
 finally
  Unlock;
 end;
end;// GetDirectBlobData


//------------------------------------------------------------------------------
// SetDirectBlobData
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.SetDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar);
var
    Buffer: PChar;
    BufferSize,Offset: Integer;
begin
 Lock;
 try
   if (BLOBDescriptor.CompressedSize = 0) then
    begin
     // empty stream
     ClearBLOBFieldInRecordBuffer(RecordBuffer,FieldNo);
     Buffer := nil;
     Move(Buffer,PChar(RecordBuffer +
      FieldManager.FieldDefs[FieldNo].MemoryOffset)^,sizeof(Buffer));
     SetNullFlag(True,FieldNo,RecordBuffer);
    end
   else
    begin
     ClearBLOBFieldInRecordBuffer(RecordBuffer,FieldNo);
     Offset := sizeof(TMYLDBPartialBLOBDescriptor);
     BufferSize := BLOBDescriptor.CompressedSize + Offset;
     Buffer := MemoryManager.GetMem(BufferSize);
     PMYLDBPartialBLOBDescriptor(Buffer)^.NumBlocks := BLOBDescriptor.NumBlocks;
     PMYLDBPartialBLOBDescriptor(Buffer)^.UncompressedSize := BLOBDescriptor.UncompressedSize;
     Move(pBlobData^,PChar(Buffer + Offset)^,(BufferSize - Offset));
     PCardinal(RecordBuffer + FieldManager.FieldDefs[FieldNo].MemoryOffset)^ := Cardinal(Buffer);
     SetNullFlag(False,FieldNo,RecordBuffer);
    end; // not empty stream
 finally
  Unlock;
 end;
end;// SetDirectBlobData


//------------------------------------------------------------------------------
// FreeDirectBlobData
//------------------------------------------------------------------------------
procedure TMYLDBMemoryTableData.FreeDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar);
begin
 Lock;
 try
  if (pBlobData <> nil) then
    MemoryManager.FreeAndNillMem(pBlobData);
 finally
  Unlock;
 end;
end;// FreeDirectBlobData


//------------------------------------------------------------------------------
// insert record
//-----------------------------------------------------