daovalueobjectunit.pas

Delphi最新三层源码(1.0),对delphi有帮助

//------------------------------------------------------------------------------
//                           DAO数据存储基类
//1.所有的数据库操作，只有通过DAO类进行存取。
//2.不允许其他模块进行数据存取操作。
//
//------------------------------------------------------------------------------


unit DAOValueObjectUnit;

interface

uses
  Classes, SysUtils, Windows, Dialogs, DB, Variants, ValueObjectUnit, IDAOValueObjectUnit,
  TValueObjectListUnit, SQLAnalyzeServiceUnit;

type

  TDAOValueObject= class(TPersistent, IDAOValueObject)
    private
      sSQLSelect: String;
      sSQLMax: String;
      sSQLCount: String;
      sSQLInsert: String;
      sSQLUpdate: String;
      sSQLDelete: String;

      sSQL: String;
      sSQLCode: WideString;

      VOClass: TClass;
      VOListClass: TClass;
      VO: TValueObject;
      VOList: TValueObjectList;
      sqlAnySrvObj: TSQLAnalyzeService;

      function getSQL: WideString;
      procedure setSQL(tmpSql: WideString);
      function getSQLSelect: WideString;
      procedure setSQLSelect(tmpSql: WideString);
      function getSQLMax: WideString;
      procedure setSQLMax(tmpSql: WideString);
      function getSQLCount: WideString;
      procedure setSQLCount(tmpSql: WideString);
      function getSQLInsert: WideString;
      procedure setSQLInsert(tmpSql: WideString);
      function getSQLUpdate: WideString;
      procedure setSQLUpdate(tmpSql: WideString);
      function getSQLDelete: WideString;
      procedure setSQLDelete(tmpSql: WideString);
      procedure setVOClass(sClass :TClass);
      function getVOClass: TClass;
      procedure setVOListClass(sClass :TClass);
      function getVOListClass: TClass;
      function getVO: TValueObject;
      function getVOList: TValueObjectList;
      procedure setVOList(tmpVOList: TValueObjectList);

    protected
      FRefCount: Integer;
      function QueryInterface(const IID: TGUID; out Obj): HResult; stdcall;
      function _AddRef: Integer; stdcall;
      function _Release: Integer; stdcall;
      
      procedure setSQLCode(const pServiceName: WideString;  vKey: OleVariant);
      function getSQLCode: WideString;
      property PVO: TValueObject read getVO;
      procedure CreateDSAndVOList(tmpDS: TDataSet); virtual;

    published
      property PVOClass: TClass read getVOClass write setVOClass;
      property PVOListClass: TClass read getVOListClass write setVOListClass;
      property PVOList: TValueObjectList read getVOList write setVOList;
      property PSQL: WideString read getSQL write setSQL;
      property PSQLSelect: WideString read getSQLSelect write setSQLSelect;
      property PSQLMax: WideString read getSQLMax write setSQLMax;
      property PSQLCount: WideString read getSQLCount write setSQLCount;
      property PSQLInsert: WideString read getSQLInsert write setSQLInsert;
      property PSQLUpdate: WideString read getSQLUpdate write setSQLUpdate;
      property PSQLDelete: WideString read getSQLDelete write setSQLDelete;

    public
      constructor Create(VoListClass: TClass; VOClass: TClass); overload;
      function getDAOValueList: OleVariant;  overload;
      function getDAOValueList(sSQL: String): OleVariant;  overload;
      procedure setDAOValueList(const tmpOle: OleVariant); virtual;

      procedure InitDAOValueList(sSQL: String); virtual;
      function getPrimaryKey(const sSQLMax: String; sSQLCount: String):String;  virtual;
      function createDAOValue: TValueObject; virtual;
      function insertDAOValue(pValueObject: TValueObject): Integer; virtual;
      function updateDAOValue(pValueObject: TValueObject): Integer; virtual;
      function deleteDAOValue(pValueObject: TValueObject): Integer; virtual;
      //function findByPrimaryKey(const pServiceName: WideString;  vKey: OleVariant): TValueObject; virtual; abstract;
      property pSQLCode: WideString read getSQLCode;
  end;

implementation
  uses ServerFrm;

function TDAOValueObject.QueryInterface(const IID: TGUID; out Obj): HResult;
begin
  if GetInterface(IID, Obj) then
    Result := 0
  else
    Result := E_NOINTERFACE;
end;

function TDAOValueObject._AddRef: Integer;
begin
  Result := InterlockedIncrement(FRefCount);
end;

function TDAOValueObject._Release: Integer;
begin
  Result := InterlockedDecrement(FRefCount);
  if Result = 0 then
    Destroy;
end;

function TDAOValueObject.getSQL: WideString;
begin
  Result := sSQL;
end;

procedure TDAOValueObject.setSQL(tmpSql: WideString);
begin
  sSQL := tmpSql;
end;

function TDAOValueObject.getSQLSelect: WideString;
begin
  Result := sSQLSelect;
end;

procedure TDAOValueObject.setSQLSelect(tmpSql: WideString);
begin
  sSQLSelect := tmpSql;
end;

function TDAOValueObject.getSQLMax: WideString;
begin
  Result := sSQLMax; 
end;

procedure TDAOValueObject.setSQLMax(tmpSql: WideString);
begin
  sSQLMax := tmpSql;
end;

function TDAOValueObject.getSQLCount: WideString;
begin
  Result := sSQLCount;
end;

procedure TDAOValueObject.setSQLCount(tmpSql: WideString);
begin
  sSQLCount := tmpSql;
end;

function TDAOValueObject.getSQLInsert: WideString;
begin
  Result := sSQLInsert;
end;

procedure TDAOValueObject.setSQLInsert(tmpSql: WideString);
begin
  sSQLInsert := tmpSql;
end;

function TDAOValueObject.getSQLUpdate: WideString;
begin
  Result := sSQLUpdate;
end;

procedure TDAOValueObject.setSQLUpdate(tmpSql: WideString);
begin
  sSQLUpdate := tmpSql;
end;

function TDAOValueObject.getSQLDelete: WideString;
begin
  Result := sSQLDelete;
end;

procedure TDAOValueObject.setSQLDelete(tmpSql: WideString);
begin
  sSQLDelete := tmpSql;
end;

procedure TDAOValueObject.setVOClass(sClass :TClass);
begin
  VOClass := sClass;
end;

function TDAOValueObject.getVOClass: TClass;
begin
  Result :=VOClass;
end;

procedure TDAOValueObject.setVOListClass(sClass :TClass);
begin
  VOListClass := sClass;
end;

function TDAOValueObject.getVOListClass: TClass;
begin
  Result := VOListClass;
end;

function TDAOValueObject.getVO: TValueObject;
begin
  Result := VO;
end;

function TDAOValueObject.getVOList: TValueObjectList;
begin
  Result := VOList;
end;

procedure TDAOValueObject.setVOList(tmpVOList: TValueObjectList);
begin
  VOList := tmpVOList;
end;

procedure TDAOValueObject.setSQLCode(const pServiceName: WideString;  vKey: OleVariant);
begin
  sSQLCode := sqlAnySrvObj.getSQLCode(pServiceName, vKey);
end;

function TDAOValueObject.getSQLCode: WideString;
begin
  Result := sSQLCode;
end;

function TDAOValueObject.getDAOValueList: OleVariant;
begin
  if PVOList.pDataSet.IsEmpty then
    InitDAOValueList(PSQL);
  Result := PVOList.POLEDataList;
end;

function TDAOValueObject.getDAOValueList(sSQL: String): OleVariant;
begin
  if PVOList.pDataSet.IsEmpty then
    InitDAOValueList(PSQL);
  Result := PVOList.POLEDataList;
end;

procedure TDAOValueObject.setDAOValueList(const tmpOle: OleVariant);
begin
  PVOList.POLEDataList := tmpOle;
end;

constructor TDAOValueObject.Create(VoListClass: TClass; VOClass: TClass);
begin
  inherited Create;
  PVOClass := VOClass;
  PVOListClass := VOListClass;
  
  sqlAnySrvObj := TSQLAnalyzeService.Create;
  if not assigned(VOList) then
    VOList := TValueObjectList(VoListClass.Create);
  VOList.pVOClassName := VOClass;

end;

procedure TDAOValueObject.InitDAOValueList(sSQL: String);
var
  tmpDS: TDataSet;
  wsPrv: WideString;
begin
  with  frmServer.pLdmDataSet do
  begin
    try
      tmpDS := SelectLDMDS(PSQLSelect, wsPrv);
      PVOList.prepareTable(tmpDS);
    except
      tmpDS := nil;
      ShowMessage('数据存取失败！');
    end;

    CreateDSAndVOList(tmpDS);
    tmpDS.close;
  end;

end;

procedure TDAOValueObject.CreateDSAndVOList(tmpDS: TDataSet);
var
  i_i, i_j : integer;
  voParam: Olevariant;
  voFlag: OleVariant;
  voObj: OleVariant;
  procedure InitDataSet(tmpDS: TDataSet);
  begin
    if tmpDS.Fields[i_j].Value = null then
    begin
      tmpDS.Edit;
      if tmpDS.Fields[i_j].DataType in [ftSmallint, ftInteger, ftWord, ftFloat, ftBytes, ftLargeint] then
        tmpDS.Fields[i_j].Value := 0;
      if tmpDS.Fields[i_j].DataType in [ftString, ftWideString] then
        tmpDS.Fields[i_j].Value := '';
      if tmpDS.Fields[i_j].DataType in [ftBoolean] then
        tmpDS.Fields[i_j].Value := false;
      if tmpDS.Fields[i_j].DataType in [ftDate] then
        tmpDS.Fields[i_j].Value := Date;
      if tmpDS.Fields[i_j].DataType in [ftTime] then
        tmpDS.Fields[i_j].Value := time;
      if tmpDS.Fields[i_j].DataType in [ftDateTime] then
        tmpDS.Fields[i_j].Value := Date;
    end;
  end;

begin

  //VO原始数据:
  voFlag := VarArrayCreate([0,2], varVariant);
  voFlag[0] := false;
  voFlag[1] := false;
  voFlag[2] := false;

  //VO字段数据：
  voParam := VarArrayCreate([0,tmpDS.FieldCount-1],varVariant);
  //真正的VO:
  voObj := VarArrayCreate([0,1],varVariant);

  for i_i := 1 to tmpDS.RecordCount do
  begin
    VO := TValueObject(PVOList.pVOClassName.Create);

    with PVOList.pDataSet do
    begin
      Append;
      for i_j :=0 to FieldCount-1 do
      begin
        //数据预处理：
        InitDataSet(tmpDS);
        voParam[i_j] := tmpDS.Fields[i_j].Value;
      end;

      voObj[0] := voFlag;
      voObj[1] := voParam;
        
      VO.POLEData := voObj;

      post;
    end;

    VOList.AddItem(1, VO);
    tmpDS.Next;
  end;
end;

function TDAOValueObject.getPrimaryKey(const sSQLMax: String; sSQLCount: String): String;
var
  tmpDS: TDataSet;
  wsPrv: WideString;
begin
  tmpDS := nil;
  sSQLCode := sqlAnySrvObj.getSQLCode(sSQLMax);
  with  frmServer.pLdmDataSet do
  begin
    try
      tmpDS := SelectLDMDS(pSQLCode, wsPrv);
    except
      ShowMessage('数据存取失败！');
    end;
    if not tmpDS.IsEmpty then
      PVOList.pMaxKey := tmpDS.Fields[0].Value;
    tmpDS.Close;
  end;


  sSQLCode := sqlAnySrvObj.getSQLCode(sSQLCount);
  with  frmServer.pLdmDataSet do
  begin
    try
      tmpDS := SelectLDMDS(pSQLCode, wsPrv);
    except
      ShowMessage('数据存取失败！');
    end;

    if not tmpDS.IsEmpty then
      PVOList.pCountKey := tmpDS.Fields[0].Value;
    tmpDS.Close;
  end;

  with PVOList do
  begin
    if pMaxKey > pCountKey then
      pRealKey := pMaxKey
    else
      pRealKey := pCountKey;
  end;

end;

function TDAOValueObject.createDAOValue: TValueObject;
var
  tmpVO: TValueObject;
begin
  tmpVO := TValueObject(PVOClass.Create);
  tmpVO.pPrimarykey := IntTOStr(PVOList.pRealKey+1);
  tmpVO.pRowVersion := 0;
  Result := tmpVO;
end;

function TDAOValueObject.insertDAOValue(pValueObject: TValueObject): Integer;
var
  tmpOle: OleVariant;
  oParam: OleVariant;
  i_i: INteger;
begin
  tmpOle := pValueObject.POLEData;
  if not VarArrayHighBound(tmpOle,1)>0 then
    exit
  else
    oParam:= tmpOle[1];

  sSQLCode := sqlAnySrvObj.getSQLCode(PSQLInsert, oParam);
  with  frmServer.pLdmDataSet do
  begin
    try
      Result := InsertLDMDS(pSQLCode);
      getPrimaryKey(PSQLMax, PSQLCount);
    except
      Result := -1;
      ShowMessage('数据存取失败！');
    end;
  end;
end;

function TDAOValueObject.updateDAOValue(pValueObject: TValueObject): Integer;
var
  tmpOle, oParam, pVO: OleVariant;
  i_i: Integer;
begin
  tmpOle := pValueObject.POLEData;
  if not VarArrayHighBound(tmpOle,1)>0 then
    exit
  else
    oParam:= tmpOle[1];

  pVO := VarArrayCreate([0, VarArrayHighBound(oParam,1)], varVariant);
  for i_i:=1 to VarArrayHighBound(oParam,1)-1 do
    pVO[i_i-1] := oParam[i_i];

  pVO[VarArrayHighBound(oParam,1)-1] := oParam[0];
  pVO[VarArrayHighBound(oParam,1)] := oParam[VarArrayHighBound(oParam,1)];

  sSQLCode := sqlAnySrvObj.getSQLCode(PSQLUpdate, pVO);
  with  frmServer.pLdmDataSet do
  begin
    try
      Result := UpdateLDMDS(pSQLCode);
    except
      Result := -1;
      ShowMessage('数据存取失败！');
    end;
  end;

end;

function TDAOValueObject.deleteDAOValue(pValueObject: TValueObject): Integer; 
var
  tmpOle, pVO, oParam: OleVariant;
begin
  tmpOle := pValueObject.POLEData;
  if not VarArrayHighBound(tmpOle,1)>0 then
    exit
  else
    oParam:= tmpOle[1];

  pVO := VarArrayCreate([0, 1], varVariant);
  pVO[0] := oParam[0];
  pVO[1] := oParam[VarArrayHighBound(oParam,1)];

  sSQLCode := sqlAnySrvObj.getSQLCode(PSQLDelete, pVO);
  with  frmServer.pLdmDataSet do
  begin
    try
      Result := DeleteLDMDS(pSQLCode);
      getPrimaryKey(PSQLMax, PSQLCount);
    except
      Result := -1;
      ShowMessage('数据存取失败！');
    end;
  end;

end;

end.