absbaseengine.pas

Absolute Database 是来替代BDE[Borland数据库引擎]的用于Delphi 和 C++ Builder 开发用的数据库引擎. 它小巧, 高速, 健壮, 易于使用. 它能直接编译进

//------------------------------------------------------------------------------
// Set default values to fields
//------------------------------------------------------------------------------
procedure TABSBaseFieldManager.ApplyDefaultValuesToRecordBuffer(Session: TABSBaseSession;
  RecordBuffer: TABSRecordBuffer);
var
  i: Integer;
  value: TABSVariant;
begin
  for i:=0 to FFieldDefs.Count-1 do
    if (not IsBLOBFieldType(FFieldDefs[i].BaseFieldType)) then
      if (not FFieldDefs[i].DefaultValue.IsNull) then
        begin
          if (FFieldDefs[i].DefaultValueExpr <> nil) then
            begin
              value := TABSExpression(FFieldDefs[i].DefaultValueExpr).GetValue;
              value.Cast(FFieldDefs[i].BaseFieldType);
              value.CopyDataToAddress(RecordBuffer + FFieldDefs[i].MemoryOffset);
            end
          else
            FFieldDefs[i].DefaultValue.CopyDataToAddress(RecordBuffer + FFieldDefs[i].MemoryOffset);
          SetNullFlag(false, i, RecordBuffer);
        end;
end;//ApplyDefaultValuesToRecordBuffer


//------------------------------------------------------------------------------
// ApplyAutoincsToRecordBuffer
//------------------------------------------------------------------------------
procedure TABSBaseFieldManager.ApplyAutoincsToRecordBuffer(Session: TABSBaseSession;
  RecordBuffer: TABSRecordBuffer);
var
  i: Integer;
  SequenceValue: TABSSequenceValue;
begin
  for i:=0 to FFieldDefs.Count-1 do
      if (IsAutoincFieldType(FFieldDefs[i].AdvancedFieldType)) then
        if (CheckNullFlag(i, RecordBuffer)) then
          begin
            SequenceValue := GetNextAutoinc(Session, i);
            Move(SequenceValue, (RecordBuffer + FFieldDefs[i].MemoryOffset)^,
                 FFieldDefs[i].MemoryDataSize);
            SetNullFlag(false, i, RecordBuffer);
          end
        else
          begin
            SequenceValue := 0;
            // update auto inc to the inserted value
            Move((RecordBuffer + FFieldDefs[i].MemoryOffset)^, SequenceValue,
                 FFieldDefs[i].MemoryDataSize);
            UpdateLastAutoInc(Session, i, SequenceValue);
          end;
end;//ApplyAutoincsToRecordBuffer


//------------------------------------------------------------------------------
// GetNextAutoinc
//------------------------------------------------------------------------------
function TABSBaseFieldManager.GetNextAutoinc(Session: TABSBaseSession;
  FieldNo: Integer): TABSSequenceValue;
begin
  // Get Next Value
  Result := GetNextAutoincVal(FieldNo);
  // Put Value to Session...
  Session.SetObject(TABSSessionNamedObjectSequenceValue.Create(
                                        FFieldDefs[FieldNo].ObjectID,
                                        Result));
end;//GetNextAutoinc


//------------------------------------------------------------------------------
// GetLastAutoinc
//------------------------------------------------------------------------------
function TABSBaseFieldManager.GetLastAutoinc(Session: TABSBaseSession;
  FieldNo: Integer): TABSSequenceValue;
var
  Value: TABSSessionNamedObjectSequenceValue;
begin
  Value := TABSSessionNamedObjectSequenceValue(
                          Session.GetObjectByID(FFieldDefs[FieldNo].ObjectID));
  if Value = nil then
  begin
    // 5.08, improve GetLastAutoinc
    if Session.MultiUser then
    // end 5.08 fix
      raise EABSException.Create(30012, ErrorGSequenceLastValueFailed,
                                                       [FFieldDefs[FieldNo].Name])
    // 5.08, improve GetLastAutoinc
    else begin

      if (IsAutoincFieldType(FieldDefs.Items[FieldNo].AdvancedFieldType)) then
        Result := FLastAutoIncValues[FieldNo]
      else
        Result := 0;
    // end 5.08 fix
    end;
  end
  else
    Result := Value.Value;
end;//GetLastAutoinc


//------------------------------------------------------------------------------
// UpdateAutoinc
//------------------------------------------------------------------------------
procedure TABSBaseFieldManager.UpdateLastAutoinc(Session: TABSBaseSession;
                                        FieldNo: Integer; InsertedValue: Int64);
begin
  if (InsertedValue > FLastAutoIncValues[FieldNo]) then
    begin
      FLastAutoIncValues[FieldNo] := InsertedValue;
      // Put Value to Session...
      Session.SetObject(TABSSessionNamedObjectSequenceValue.Create(
                                        FFieldDefs[FieldNo].ObjectID,
                                        InsertedValue));
    end;
end;// UpdateLastAutoinc



////////////////////////////////////////////////////////////////////////////////
//
// TABSBaseIndexManager
//
////////////////////////////////////////////////////////////////////////////////


//------------------------------------------------------------------------------
// load from stream
//------------------------------------------------------------------------------
procedure TABSBaseIndexManager.LoadMetadata(Stream: TStream);
begin
  FIndexDefs.LoadFromStream(Stream);
end; // SaveToStream


//------------------------------------------------------------------------------
// save to stream
//------------------------------------------------------------------------------
procedure TABSBaseIndexManager.SaveMetadata(Stream: TStream);
begin
  FIndexDefs.SaveToStream(Stream);
end; // SaveToStream


//------------------------------------------------------------------------------
// create
//------------------------------------------------------------------------------
constructor TABSBaseIndexManager.Create(aTableData: TABSTableData; TempPageManager: TABSPageManager);
begin
 FOpenIndexList := TList.Create; // list of TABSIndex objects
 FIndexDefs := TABSIndexDefs.Create;
 FTableData := aTableData;
 FPageManager := FTableData.PageManager;
 FTemporaryPageManager := TempPageManager;
 FSynchronizingTemporaryIndexes := False;
end;// Create


//------------------------------------------------------------------------------
// destroy
//------------------------------------------------------------------------------
destructor TABSBaseIndexManager.Destroy;
begin
 while (FOpenIndexList.Count > 0) do
   CloseIndex(TABSIndex(FOpenIndexList.Items[0]).IndexDef.ObjectID);
 FOpenIndexList.Free;
 FIndexDefs.Free;
end;// Destroy


//------------------------------------------------------------------------------
// return PageManager for index
//------------------------------------------------------------------------------
function TABSBaseIndexManager.GetPageManager(Index: TABSIndex): TABSPageManager;
begin
  if (Index.IndexDef.Temporary) then
    Result := FTemporaryPageManager
  else
    Result := FPageManager;
end; // GetPageManager


//------------------------------------------------------------------------------
// DropTemporaryIndexes
//------------------------------------------------------------------------------
procedure TABSBaseIndexManager.DropTemporaryIndexes(SessionID: TABSSessionID);
var i: Integer;
begin
  i := 0;
  while (i < IndexDefs.Count) do
   begin
    if (IndexDefs[i].Temporary) then
     DropIndex(SessionID, IndexDefs[i].ObjectID)
    else
     Inc(i);
   end;
end;// DropTemporaryIndexes


//------------------------------------------------------------------------------
// return true if coresponding index was found
//------------------------------------------------------------------------------
function TABSBaseIndexManager.IsIndexExists(FieldNames, AscDescList, CaseSensitivityList: TStringList;
                                     SessionID: TABSSessionID; FieldDefs: TABSFieldDefs): Boolean;
begin
  Result := FIndexDefs.IsIndexExists(FieldNames,AscDescList,CaseSensitivityList,SessionID,FieldDefs);
end; // IsIndexExists


//------------------------------------------------------------------------------
// return IndexID if coresponding index was found
//------------------------------------------------------------------------------
function TABSBaseIndexManager.FindIndex(FieldNames, AscDescList, CaseSensitivityList: TStringList;
                              SessionID: TABSSessionID; FieldDefs: TABSFieldDefs): TABSObjectID;
begin
  Result := FIndexDefs.FindIndex(FieldNames,AscDescList,CaseSensitivityList, SessionID, FieldDefs);
end; // FindIndex


//------------------------------------------------------------------------------
// create temporary index
//------------------------------------------------------------------------------
function TABSBaseIndexManager.CreateTemporaryIndex(
          Cursor: TABSCursor;
          FieldNamesList, AscDescList, CaseSensitivityList: TStringList
                                                  ): TABSObjectID;
var IndexDef: TABSIndexDef;
begin
  IndexDef := TABSIndexDef.Create;
  try
   repeat
     IndexDef.Name := GetTemporaryName('TEMPORARY_INDEX_');
   until (IndexDefs.GetDefNumberByName(IndexDef.Name) = -1); 
   IndexDef.Temporary := True;
   IndexDef.IndexType := itBTree;
   IndexDef.Unique := False;
   IndexDef.Primary := False;
   IndexDef.AssignByNames(FieldNamesList,AscDescList,CaseSensitivityList);
   IndexDef.SessionID := Cursor.Session.SessionID;
   IndexDef.TableState := FTableData.RecordManager.TableState;
   Result := CreateIndex(Cursor, IndexDef);
  finally
   IndexDef.Free;
  end;
end; // CreateTemporaryIndex


//------------------------------------------------------------------------------
// find or create temporary index
//------------------------------------------------------------------------------
function TABSBaseIndexManager.FindOrCreateIndex(Cursor: TABSCursor;
                FieldNamesList, AscDescList, CaseSensitivityList: TStringList; var IsCreated: Boolean): TABSObjectID;
begin
  Result := FindIndex(FieldNamesList,AscDescList,CaseSensitivityList,
                      Cursor.Session.SessionID, Cursor.FieldDefs);
  if (Result = INVALID_OBJECT_ID) then
    begin
      Result := CreateTemporaryIndex(Cursor, FieldNamesList,AscDescList,CaseSensitivityList);
      IsCreated := True;
    end
  else
    IsCreated := False;
end; // FindOrCreateIndex


//------------------------------------------------------------------------------
// create index definitions list
//------------------------------------------------------------------------------
procedure TABSBaseIndexManager.CreateIndexDefs(aIndexDefs: TABSIndexDefs);
begin
  FIndexDefs.Assign(aIndexDefs);
end;// CreateIndexDefs


//------------------------------------------------------------------------------
// CreateIndexesByIndexDefs
//------------------------------------------------------------------------------
procedure TABSBaseIndexManager.CreateIndexesByIndexDefs(Cursor: TABSCursor);
var
  i: Integer;
begin
  for i := 0 to IndexDefs.Count-1 do
   InternalCreateIndex(Cursor, IndexDefs.Items[i]);
end;// CreateIndexesByIndexDefs


//-------------------------------------------------