layer.pas

DBDesigner 4 is a database design system that integrates database design, modelling, creation and ma

      for k:= 0 to self.Columns.Count-1 do
      begin
        tmpCol := SW_Column(columns[k]);
        if (tmpCol.name =  fieldName) then
        begin
          tmpCol.FIsForeignKey := true;
          tmpCol.FfkTablename := TEERTable(rel.SrcTbl).ObjName;
          tmpCol.FfkColname := origKeyname;
          break;
        end;
      end;
    end;
  end;

end;

constructor SW_Table.Create(origTable : TEERTable; model : SW_model);
var i:Integer;
    tmpCol : SW_Column;
begin
  self.origTable := origTable;
  Fname := origTable.ObjName;
  self.model := model;

  self.Fjoin_width := -1;
  self.Fnm_width := -1;

  //set the other member variables
  FprimaryKey := TStringList.Create;
  Fcolumns := TObjectList.Create;

  for i:=0 to origTable.Columns.Count-1 do
  begin
    tmpCol := SW_Column.Create(TEERColumn(origTable.Columns[i]), self);
    columns.Add(tmpCol);
  end;

  InitPrimaryKey();

  //Set a default value for Fjoin_columName
  //the default for the columnname is the name of all key attributes separeted by a comma
  for i:= 0 to FprimaryKey.Count-1 do
    self.Fjoin_columnName := Fjoin_columnName + ','+primaryKey[i];
  Delete(Fjoin_columnName,1,1); //remove the first comma

  FrelatedTables := TStringList.Create;

  InitRelationships();

end;

destructor SW_Table.Destroy;
begin
  relatedTables.Free;
  columns.Free;
  primaryKey.Free;
end;

function SW_Table.HasRelationTo(tableName: String) : Boolean;
var i: Integer;
begin
  HasRelationTo := false;

  for i:=0 to self.relatedTables.Count-1 do
  begin
    if (relatedTables[i] = tableName) then
      HasRelationTo := True;
  end;
end;

function SW_Table.DeepCopy() :SW_Table;
var tmpTable :SW_Table;
    i : Integer;
begin
  assert(IsStillConsistent());

  tmpTable := SW_Table.Create(self.origTable);
  tmpTable.Columns.Clear;
  for i:= 0 to Columns.Count-1 do
    tmpTable.columns.Add(SW_Column(Columns[i]).DeepCopy(tmpTable));

  tmpTable.origTable := origTable;
  tmpTable.Fname := Fname;
  tmpTable.relatedTables.Assign(relatedTables);
  tmpTable.FprimaryKey.Assign(FprimaryKey);
  tmpTable.Fjoin_columnName:= Fjoin_columnName;
  tmpTable.Fjoin_width := Fjoin_width;
  tmpTable.Fnm_width := Fnm_width;

  DeepCopy:= tmpTable;
end;

function SW_Table.GetEERId() : Integer;
begin
  GetEERId := origTable.Obj_id;
end;

function SW_Table.isStillConsistent() : Boolean;
var expectedSize : LongInt;
    realSize : LongInt;
begin
    expectedSize := 40; //found out by debugging

    realSize := self.InstanceSize;
    isStillConsistent := (expectedSize = realSize);
end;





 {
function SW_Column.SaveToString() :String;
var str :String;
begin
  assert(IsStillConsistent());
  
  str:= '(';
  str := str + 'ColId=' + IntToStr(origCol.Obj_id) + delimiter;
  str := str + 'TableId=' + IntToStr(table.GetEERId()) + delimiter;
  str := str + 'FixedWidth=' + IntToStr(FixedWidth) + delimiter;
  str := str + 'TruncateChars=' + IntToStr(truncateChars) + delimiter;
  str := str + 'SelectedForGrid=' + BoolToStr(selectedForGrid) + delimiter;
  str := str + 'SelectedForForm=' + BoolToStr(selectedForForm) + delimiter;
  str := str + 'ShowName=' + GridName + delimiter;
  str := str + 'IsForeignKey=' + BoolToStr(IsForeignKey) + delimiter;
  str := str + 'fkTablename=' + fkTablename + delimiter;
  str := str + 'fkColname=' + fkColname + delimiter;
  str := str + 'FormName=' + FormName + delimiter;
  str := str + 'FormWidth=' + IntToStr(FormWidth) + delimiter;
  str := str + ')';

  SaveToString :=  str;
end;   }

procedure SW_Column.SaveToXMLNode(node :IXMLSWF_ColumnType);
begin
  node.OrigCol := self.origCol.Obj_id;
  node.GridName := GridName;
  node.FormName := FormName;
  node.SelectedForGrid := SelectedForGrid;
  node.SelectedForForm := SelectedForForm;
  node.FixedWidth := FixedWidth;
  node.TruncateChars := TruncateChars;
  node.IsForeignKey := IsForeignKey;
  node.FkTablename := FkTablename;
  node.FkColname := FkColname;
  node.FormWidth := FormWidth;
end;

class function SW_Column.LoadFromXMLNode(node :IXMLSWF_ColumnType; father:SW_Table) :SW_Column;
var origCol : TEERColumn;
    c : SW_Column;
begin
  origCol := father.origTable.GetColumnByID(node.OrigCol);
  if (origCol = nil) then
    raise EColumnDoesntExistException.Create('This column is not in the model any longer.');

  c := SW_Column.Create(origCol, father);

  c.FGridName := node.GridName;
  c.FFormName := node.FormName;
  c.FselectedForGrid := node.SelectedForGrid;
  c.FselectedForForm := node.SelectedForForm;
  c.FFixedWidth := node.FixedWidth;
  c.FTruncateChars := node.TruncateChars;
  c.FFormWidth := node.FormWidth;

  //we don't have to do this since these values will be overwritten
  //in InitRelationships anyways
  c.FIsForeignKey := node.IsForeignKey;
  c.FfkTablename := node.FkTablename;
  c.FfkColname := node.FkColname;


  LoadFromXMLNode := c;
end;
  {
class function SW_Column.LoadFromString(s: String; father:SW_Table) :SW_Column;
var table: SW_Table;
    origCol : TEERColumn;
    stringList :TStringList;
    tmpCol: Sw_Column;
begin
  stringList := TSTringList.Create;
  Delete(s,1,1);
  Delete(s,Length(s),1);

  IntelligentSplit(s, delimiter,stringList);

  table := father;
  origCol := table.origTable.GetColumnByID(StrToInt(stringList.Values['ColId']));

  tmpCol := SW_Column.Create(origCol,table);

  tmpCol.GridName := stringList.Values['ShowName'];
  tmpCol.fixedWidth := StrToInt(stringList.Values['FixedWidth']);
  tmpCol.truncateChars := StrToInt(stringList.Values['TruncateChars']);
  tmpCol.selectedForGrid := StrToBool(stringList.Values['SelectedForGrid']);
  tmpCol.SelectedForForm := StrToBool(stringList.Values['SelectedForForm']);
  tmpCol.FIsForeignKey := StrToBool(stringList.Values['IsForeignKey']);
  tmpCol.FfkTablename := stringList.Values['fkTablename'];
  tmpCol.FfkColname := stringList.Values['fkColname'];

  if (stringList.Values['FormName'] <> '') then
    tmpCol.FFormname := stringList.Values['FormName']
  else
    tmpCol.FFormname := tmpCol.FName;
    
  tmpCol.FFormWidth := -1;
  if (stringList.Values['FormWidth'] <> '') then
    tmpCol.FFormWidth := StrToInt(stringList.Values['FormWidth']);

  LoadFromString := tmpCol;
end;
         }

constructor SW_Column.Create(origCol :TEERColumn; table : SW_Table);
begin
  self.origCol := origCol;
  Ftable := table;
  Fname := origCol.ColName;
  selectedForGrid := true;
  selectedForForm := true;
  FIsForeignKey := false;

  self.FDataTypeParams := origCol.DatatypeParams;
  self.fgridName := name;
  self.fixedWidth := -1;
  self.truncateChars := -1;

  //when the program starts, one model object of type Sw_Model is created
  //this single instance has a list of all tables and columns available in the model
  //anyway the global variable model is still nil when the model is being created
  if (table.model <> nil) then
    self.FDataTypeName := table.model.GetDataTypeName(origCol.idDataType)
  else
    self.FDataTypeName := model.GetDataTypeName(origCol.idDataType);
  FFormName := origCol.ColName;
  FFormWidth := -1;
end;

destructor SW_Column.Destroy;
begin
  inherited Destroy;
end;

procedure SW_Column.ToggleGridSelected;
begin
  selectedForGrid := NOT selectedForGrid;
end;

procedure SW_Column.ToggleFormSelected;
begin
  selectedForForm := NOT selectedForForm;
end;



function SW_Column.DeepCopy(father: SW_Table) :SW_Column;
var tmpCol :SW_Column;
begin
  //assert(isStillConsistent());
  assert(father <> nil); //every column must be part of a table;

  tmpCol := SW_Column.Create(origCol,self.Ftable);

  tmpCol.origCol := self.origCol;
  tmpCol.FName := self.FName;
  tmpCol.FGridName := self.FGridName;
  tmpCol.FDataTypeName := self.FDataTypeName;
  tmpCol.Ftable := father;
  tmpCol.FselectedForGrid := self.FselectedForGrid;
  tmpCol.FselectedForForm := self.FselectedForForm;
  tmpCol.FfixedWidth := self.FfixedWidth;
  tmpCol.TruncateChars := self.TruncateChars;
  tmpCol.FIsForeignKey := self.FIsForeignKey;
  tmpCol.FfkTablename := self.FfkTablename;
  tmpCol.FfkColname := self.FfkColname;
  tmpCol.FFormName := self.FFormName;
  tmpCol.FFormWidth := self.FFormWidth;

  DeepCopy := tmpCol;
end;

function SW_Column.isStillConsistent() : Boolean;
var expectedSize : LongInt;
    realSize : LongInt;
begin
    expectedSize := 56; //found out by debugging
    {expectedSize := expectedSize + sizeof(origCol);          //object
    expectedSize := expectedSize + sizeof(@FName);           //string
    expectedSize := expectedSize + sizeof(@FshowName);       //string
    expectedSize := expectedSize + sizeof(@FDataTypeName);   //string
    expectedSize := expectedSize + sizeof(Ftable);           //object
    expectedSize := expectedSize + sizeof(FselectedForGrid); //boolean
    expectedSize := expectedSize + sizeof(FselectedForForm); //boolean
    expectedSize := expectedSize + sizeof(FFixedWidth);      //integer
    expectedSize := expectedSize + sizeof(FTruncateChars);   //integer
    expectedSize := expectedSize + sizeof(FIsForeignKey);    //boolean
    expectedSize := expectedSize + sizeof(@FfkTablename);    //string
    expectedSize := expectedSize + sizeof(@FfkColname);      //string
    expectedSize := expectedSize + sizeof(@FFormName);       //string
    expectedSize := expectedSize + sizeof(FFormWidth);       //integer
    }
    realSize := self.InstanceSize;
    isStillConsistent := (expectedSize = realSize);
end;

function SW_Column.IsPrimaryKey() : Boolean;
begin
  IsPrimaryKey := origCol.PrimaryKey;
end;

function SW_Column.getDefaultValue() : String;
begin
  GetDefaultValue := origCol.defaultValue;
end;

function SW_Column.getNotNull() : Boolean;
begin
  GetNotNull := origCol.NotNull;
end;

function SW_Column.getObj_Id() : Integer;
begin
  getObj_Id := origCol.Obj_id;
end;

end.