// AddIndex
//------------------------------------------------------------------------------
procedure TMYLDBTemporaryTableData.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 TMYLDBTemporaryTableData.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


//------------------------------------------------------------------------------
// insert record
//------------------------------------------------------------------------------
function TMYLDBTemporaryTableData.InsertRecord(var Cursor: TMYLDBCursor): Boolean;
var RecordID: TMYLDBRecordID;
begin
  if (FRecordManager = nil) then
   raise EMYLDBException.Create(10134,ErrorLNilPointer);
  if (Cursor.CurrentRecordBuffer = nil) then
   raise EMYLDBException.Create(10135,ErrorLNilPointer);
  // add record to first empty space
  try
    Result := FRecordManager.AddRecord(Cursor.Session.SessionID,
                                           Cursor.CurrentRecordBuffer,RecordID);
    Move(RecordID,Cursor.CurrentRecordID,sizeof(Cursor.CurrentRecordID));
  except
    Result := False;
  end;
  if (Result) then
   begin
     if (TMYLDBRecordBitmap(Cursor.RecordBitmap).Active) then
      begin
        if (IsRecordVisible(Cursor)) then
         TMYLDBRecordBitmap(Cursor.RecordBitmap).ShowRecord(Cursor.CurrentRecordID)
        else
         TMYLDBRecordBitmap(Cursor.RecordBitmap).HideRecord(Cursor.CurrentRecordID);
      end;
     FIndexManager.InsertRecord(Cursor);
     Cursor.FirstPosition := False;
     Cursor.LastPosition := False;
     if (not Cursor.Session.InTransaction) then
      FPageManager.ApplyChanges(Cursor.Session.SessionID);
   end;
end; // InsertRecord;


//------------------------------------------------------------------------------
// delete record
//------------------------------------------------------------------------------
function TMYLDBTemporaryTableData.DeleteRecord(Cursor: TMYLDBCursor): Boolean;
begin
 Result := False;
end; // DeleteRecord


//------------------------------------------------------------------------------
// update record
//------------------------------------------------------------------------------
function TMYLDBTemporaryTableData.UpdateRecord(Cursor: TMYLDBCursor): Boolean;
begin
 Result := False;
end; // UpdateRecord


//------------------------------------------------------------------------------
// return record count
//------------------------------------------------------------------------------
function TMYLDBTemporaryTableData.InternalGetRecordCount(Cursor: TMYLDBCursor): TMYLDBRecordNo;
begin
  if (FRecordManager = nil) then
   raise EMYLDBException.Create(10133,ErrorLNilPointer);
  Result := FRecordManager.RecordCount;
end; // GetRecordCount


//------------------------------------------------------------------------------
// move cursor to specified position and set current record id in cursor
//------------------------------------------------------------------------------
procedure TMYLDBTemporaryTableData.InternalSetRecNo(Cursor: TMYLDBCursor; RecNo: TMYLDBRecordNo);
var RecordID: TMYLDBRecordNo;
begin
  if (FRecordManager = nil) then
   raise EMYLDBException.Create(10136,ErrorLNilPointer);
  if (RecNo > 1) then
   RecordID := RecNo-1
  else
   RecordID := 0;
  Move(RecordID,Cursor.CurrentRecordID,sizeof(Cursor.CurrentRecordID));
end; // SetRecNo


//------------------------------------------------------------------------------
// get current record position from cursor
//------------------------------------------------------------------------------
function TMYLDBTemporaryTableData.InternalGetRecNo(Cursor: TMYLDBCursor): TMYLDBRecordNo;
begin
  if (FRecordManager = nil) then
   raise EMYLDBException.Create(10137,ErrorLNilPointer);
  Result := 0;
  Move(Cursor.CurrentRecordID,Result,sizeof(Cursor.CurrentRecordID));
  Inc(Result);
end; // GetRecNo


//---------------------------------------------------------------------------
// write BLOB field to record buffer
//---------------------------------------------------------------------------
procedure TMYLDBTemporaryTableData.WriteBLOBFieldToRecordBuffer(
          Cursor:     TMYLDBCursor;
          FieldNo:    Integer;
          BLOBStream: TMYLDBStream
          );
var
    WriteSize,WriteBytes:     Integer;
    PartialBLOBDescriptor:    TMYLDBPartialTemporaryBLOBDescriptor;
    DiskOffset:               Int64;
begin
 if (FBLOBFile = nil) then
  raise EMYLDBException.Create(10144,ErrorLNilPointer);
 if (BLOBStream.Modified) then
  begin
   if (BLOBStream.Size = 0) then
    begin
     // empty stream
     SetNullFlag(True,FieldNo,Cursor.CurrentRecordBuffer);
    end
   else
    begin
     PartialBLOBDescriptor.NumBlocks := TMYLDBCompressedBLOBStream(
        TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).BLOBDescriptor.NumBlocks;
     PartialBLOBDescriptor.UncompressedSize := TMYLDBCompressedBLOBStream(
        TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).BLOBDescriptor.UncompressedSize;
     PartialBLOBDescriptor.CompressedSize := TMYLDBCompressedBLOBStream(
        TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).CompressedSize;
     SetStreamPosition(FBLOBFile,FBLOBFile.Size,10422);
     DiskOffset := FBLOBFile.Position;
     // save blob descriptor
     WriteSize := sizeof(PartialBLOBDescriptor);
     WriteBytes := FBLOBFile.Write(PartialBLOBDescriptor,WriteSize);
     if (WriteBytes <> WriteSize) then
      raise EMYLDBException.Create(10145,ErrorLCannotWriteToStream,
        [DiskOffset,FBLOBFile.Size,WriteSize,WriteBytes]);
     // save compressed data to blob file
     TMYLDBStream(TMYLDBCompressedBLOBStream(TMYLDBLocalBLOBStream(BLOBStream).TemporaryStream).
        CompressedStream).SaveToStream(FBLOBFile);
     // store offset of blob descriptor in blob file to record buffer
     Move(DiskOffset,PChar(Cursor.CurrentRecordBuffer +
      FieldManager.FieldDefs[FieldNo].MemoryOffset)^,sizeof(DiskOffset));
     SetNullFlag(False,FieldNo,Cursor.CurrentRecordBuffer);
    end; // not empty stream
  end; // Modified
end; // WriteBLOBFieldToRecordBuffer


//---------------------------------------------------------------------------
// create BLOB stream
//---------------------------------------------------------------------------
function TMYLDBTemporaryTableData.InternalCreateBlobStream(
          Cursor:   TMYLDBCursor;
          ToInsert: Boolean;
          FieldNo:  Integer;
          OpenMode: TMYLDBBLOBOpenMode
          ): TMYLDBStream;
var TempStream:             TMYLDBTemporaryStream;
    CompressedStream:       TMYLDBCompressedBLOBStream;
    Offset:                 Integer;
    DiskOffset,OldPos:      Int64;
    ReadBytes,ReadSize:     Integer;
    BLOBDescriptor:         TMYLDBBLOBDescriptor;
    PartialBLOBDescriptor:  TMYLDBPartialTemporaryBLOBDescriptor;
begin
 if (FBLOBFile = nil) then
  raise EMYLDBException.Create(10140,ErrorLNilPointer);
 BLOBDescriptor.CompressionAlgorithm :=
     Byte(FieldManager.FieldDefs[FieldNo].BLOBCompressionAlgorithm);
 BLOBDescriptor.CompressionMode := FieldManager.FieldDefs[FieldNo].BLOBCompressionMode;
 BLOBDescriptor.BlockSize := FieldManager.FieldDefs[FieldNo].BLOBBlockSize;
 BLOBDescriptor.StartPosition := 0;
 TempStream := TMYLDBTemporaryStream.Create(FDisableTempFiles);
 // create new compressed stream
 if ((ToInsert) or (OpenMode = bomWrite) 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;
   // offset to blob field data
   Move(PChar(Cursor.CurrentRecordBuffer + Offset)^,DiskOffset,Sizeof(DiskOffset));
   OldPos := FBLOBFile.Position;

   // set position in BLOB file
   FBLOBFile.Position := DiskOffset;
   if (FBLOBFile.Position <> DiskOffset) then
     raise EMYLDBException.Create(10141,ErrorLCannotSetPosition,
       [DiskOffset,OldPos,FBLOBFile.Size]);

   // read partial BLOB descriptor
   OldPos := FBLOBFile.Position;
   ReadSize := sizeof(TMYLDBPartialTemporaryBLOBDescriptor);
   ReadBytes := FBLOBFile.Read(PartialBLOBDescriptor,ReadSize);
   if (ReadBytes <> ReadSize) then
    raise EMYLDBException.Create(10142,ErrorLCannotReadFromStream,
      [OldPos,FBLOBFile.Size,ReadSize,ReadBytes]);

   // read compressed blob data
   TempStream.LoadFromStreamWithPosition(FBLOBFile,FBLOBFile.Position,
      PartialBLOBDescriptor.CompressedSize);

   // copy partial blob descriptor
   BLOBDescriptor.NumBlocks := PartialBLOBDescriptor.NumBlocks;
   BLOBDescriptor.UncompressedSize := PartialBLOBDescriptor.UncompressedSize;
   CompressedStream := TMYLDBCompressedBLOBStream.Create(TempStream,
    BLOBDescriptor,False);
   Result := TMYLDBLocalBLOBStream.Create(CompressedStream,Cursor,OpenMode,FieldNo);
  end; // copy value from TableData
end; // InternalCreateBlobStream


//------------------------------------------------------------------------------
// GetDirectBlobData
//------------------------------------------------------------------------------
procedure TMYLDBTemporaryTableData.GetDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar);
var
    Offset:                 Integer;
    DiskOffset,OldPos:      Int64;
    ReadBytes,ReadSize:     Integer;
begin
 if (CheckNullFlag(FieldNo,RecordBuffer)) then
  begin
   // empty stream
   BLOBDescriptor.NumBlocks := 0;
   BLOBDescriptor.UncompressedSize := 0;
   BLOBDescriptor.CompressedSize := 0;
   pBlobData := nil;
  end // empty stream
 else
  begin
   // copy value from TableData
   Offset := FieldManager.FieldDefs[FieldNo].MemoryOffset;
   // offset to blob field data
   Move(PChar(RecordBuffer + Offset)^,DiskOffset,Sizeof(DiskOffset));
   OldPos := FBLOBFile.Position;

   // set position in BLOB file
   FBLOBFile.Position := DiskOffset;
   if (FBLOBFile.Position <> DiskOffset) then
     raise EMYLDBException.Create(10509,ErrorLCannotSetPosition,
       [DiskOffset,OldPos,FBLOBFile.Size]);

   // read partial BLOB descriptor
   OldPos := FBLOBFile.Position;
   ReadSize := sizeof(TMYLDBPartialTemporaryBLOBDescriptor);
   ReadBytes := FBLOBFile.Read(BLOBDescriptor,ReadSize);
   if (ReadBytes <> ReadSize) then
    raise EMYLDBException.Create(10510,ErrorLCannotReadFromStream,
      [OldPos,FBLOBFile.Size,ReadSize,ReadBytes]);

   // read compressed blob data
   pBlobData := MemoryManager.GetMem(BLOBDescriptor.CompressedSize);
   FBLOBFile.ReadBuffer(pBlobData^, BLOBDescriptor.CompressedSize);
   FBLOBFile.Position := OldPos;
  end; // copy value from TableData
end;// GetDirectBlobData


//------------------------------------------------------------------------------
// SetDirectBlobData
//------------------------------------------------------------------------------
procedure TMYLDBTemporaryTableData.SetDirectBlobData(
              Cursor:     TMYLDBCursor;
              FieldNo:    Integer;
              RecordBuffer: TMYLDBRecordBuffer;
              var BLOBDescriptor: TMYLDBPartialTemporaryBLOBDescriptor;
              var pBlobData: PChar);
var
    WriteSize,WriteBytes:     Integer;
    DiskOffset:               Int64;
begin
 if (FBLOBFile = nil) then
  raise EMYLDBException.Create(10506,ErrorLNilPointer);
 if (BLOBDescriptor.UncompressedSize = 0) then
   SetNullFlag(True,FieldNo,Cursor.CurrentRecordBuffer)
 else
    begin
     SetStreamPosition(FBLOBFile,FBLOBFile.Size,10507);
     DiskOffset := FBLOBFile.Position;
     // save blob descriptor
     WriteSize := sizeof(BLOBDescriptor);
     WriteBytes := FBLOBFile.Write(BLOBDescriptor,WriteSize);
     if (WriteBytes <> WriteSize) then
      raise EMYLDBException.Create(10508,ErrorLCannotWriteToStream,
        [DiskOffset,FBLOBFile.Size,WriteSize,WriteBytes]);
     // save compressed data to blob file
     FBLOBFile.WriteBuffer(pBlobData^,BLOBDescriptor.CompressedSize);
     // store offset of blob descriptor in blob file to record buffer
     Move(DiskOffset,PChar(Cursor.CurrentRecordBuffer +
      FieldManager.FieldDefs[FieldNo].MemoryOffset)^,sizeof(DiskOffset));
     SetNullFlag(False,FieldNo,Cursor.CurrentRecordBuffer);
    end;
end;// SetDirectBlobData


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

end.