unit CDSSuppl;
 
interface
 
uses
  SysUtils, DB, DBClient;
 
type
  TCDSSuppl = class
  private
    class procedure DefaultReconcileError(DataSet: TCustomClientDataSet;
      E: EReconcileError; UpdateKind: TUpdateKind;
      var Action: TReconcileAction);
  public
    class procedure PostIfNeed(ClientDataSet: TClientDataSet);
    class procedure ApplyUpdates(ClientDataSet: TClientDataSet;
      MaxErrors: integer = 0);
    class procedure CopyDataSet(Source: TClientDataSet;
      var Target: TClientDataSet; AllRecords: boolean = True);
    class procedure CopyDataSetStruct(Source: TClientDataSet;
      var Target: TClientDataSet);
    class procedure CopyDataSetRecord(Source, Target: TClientDataSet);
    class procedure InsertRecordFromDataSet(Source, Target: TClientDataSet);
    class procedure InsertAllRecordsFromDataSet(Source, Target: TClientDataSet);
    class function SaveRunTimeIndexes(ClientDataSet: TClientDataSet)
      : TIndexDefs;
    class procedure RestoreRunTimeIndexes(ClientDataSet: TClientDataSet;
      AIndexDefs: TIndexDefs; AFreeIndexDefs: boolean = True);
  end;
 
implementation
 
{ TCDSSuppl }
 
var
  FErrorMsg: string;
 
const
  StrUpdtKind: array [TUpdateKind] of string = ('Modificação', 'Inserção',
    'Exclusão');
 
class procedure TCDSSuppl.ApplyUpdates(ClientDataSet: TClientDataSet;
  MaxErrors: integer = 0);
begin
  if not assigned(ClientDataSet.OnReconcileError) then
    ClientDataSet.OnReconcileError := TCDSSuppl.DefaultReconcileError;
  if ClientDataSet.ApplyUpdates(MaxErrors) <> 0 then
    Raise Exception.Create(FErrorMsg);
end;
 
class procedure TCDSSuppl.CopyDataSet(Source: TClientDataSet;
  var Target: TClientDataSet; AllRecords: boolean = True);
var
{$IFDEF _2010}
  bm: TBookmark;
{$ELSE}
  bm: TBookmarkStr;
{$ENDIF}
begin
  CopyDataSetStruct(Source, Target);
 
  if not AllRecords then
  begin
    CopyDataSetRecord(Source, Target);
    exit;
  end;
 
  Target.DisableControls;
 
  Source.DisableControls;
 
  bm := Source.Bookmark;
  Source.First;
  while not Source.Eof do
  begin
    CopyDataSetRecord(Source, Target);
    Source.Next;
  end;
  Source.Bookmark := bm;
  Source.EnableControls;
 
  Target.EnableControls;
end;
 
class procedure TCDSSuppl.CopyDataSetStruct(Source: TClientDataSet;
  var Target: TClientDataSet);
var
  indxField: integer;
begin
  if not assigned(Target) then
    Target := TClientDataSet.Create(nil);
 
  if Target.Active then
    Target.Close;
 
  Target.FieldDefs.BeginUpdate;
  Target.FieldDefs.Clear;
 
  with Source do
    for indxField := 0 to FieldCount - 1 do
      with Fields[indxField] do
        if (DataType = ftString) then
          Target.FieldDefs.Add(FieldName, DataType, DataSize, False)
        else if (DataType = ftFMTBcd) then
          Target.FieldDefs.Add(FieldName, DataType,
            TFMTBCDField(Fields[indxField]).Size, False)
        else
          Target.FieldDefs.Add(FieldName, DataType, 0, False);
 
  Target.FieldDefs.EndUpdate;
 
  Target.CreateDataSet;
end;
 
class procedure TCDSSuppl.CopyDataSetRecord(Source, Target: TClientDataSet);
var
  I: integer;
  Field: TField;
  InEditMode: boolean;
begin
  InEditMode := Target.State in [dsInsert, dsEdit];
 
  if not InEditMode then
    Target.Append;
 
  with Target do
  begin
    for I := 0 to FieldCount - 1 do
    begin
      Field := Source.FindField(Fields[I].FieldName);
      if assigned(Field) then
        Fields[I].Assign(Field);
    end;
  end;
 
  if not InEditMode then
    Target.Post;
end;
 
class procedure TCDSSuppl.DefaultReconcileError(DataSet: TCustomClientDataSet;
  E: EReconcileError; UpdateKind: TUpdateKind; var Action: TReconcileAction);
begin
  FErrorMsg := StrUpdtKind[UpdateKind];
  FErrorMsg := FErrorMsg + #13#10 + E.Message;
  FErrorMsg := FErrorMsg + #13#10 + intToStr(E.ErrorCode);
 
  if E.Context <> '' then
    FErrorMsg := FErrorMsg + #13#10 + 'Contexto: ' + E.Context;
 
  FErrorMsg := FErrorMsg + #13#10 + DataSet.Name;
 
  if UpdateKind = ukDelete then
    Action := raCancel
  else
    Action := raAbort;
end;
 
class procedure TCDSSuppl.InsertAllRecordsFromDataSet(Source,
  Target: TClientDataSet);
begin
  with Source do
  begin
    DisableControls;
    First;
    while not Eof do
    begin
      InsertRecordFromDataSet(Source, Target);
      Next;
    end;
    First;
    EnableControls;
  end;
end;
 
class procedure TCDSSuppl.InsertRecordFromDataSet(Source,
  Target: TClientDataSet);
begin
  Target.Insert;
  CopyDataSetRecord(Source, Target);
  Target.Post;
end;
 
class procedure TCDSSuppl.PostIfNeed(ClientDataSet: TClientDataSet);
begin
  if ClientDataSet.State in [dsInsert, dsEdit] then
    ClientDataSet.Post;
end;
 
class function TCDSSuppl.SaveRunTimeIndexes(ClientDataSet: TClientDataSet)
  : TIndexDefs;
var
  x: integer;
begin
  Result := TIndexDefs.Create(nil);
 
  if ClientDataSet.Active then
  begin
    ClientDataSet.IndexDefs.Update;
    for x := 0 to ClientDataSet.IndexDefs.Count - 1 do
      if (ixNonMaintained in ClientDataSet.IndexDefs[x].Options) then
        Result.AddIndexDef.Assign(ClientDataSet.IndexDefs[x]);
  end;
end;
 
class procedure TCDSSuppl.RestoreRunTimeIndexes(ClientDataSet: TClientDataSet;
  AIndexDefs: TIndexDefs; AFreeIndexDefs: boolean);
var
  x: integer;
begin
  if assigned(AIndexDefs) then
  begin
    for x := 0 to AIndexDefs.Count - 1 do
      with ClientDataSet.IndexDefs.AddIndexDef do
        Assign(AIndexDefs[x]);
    AIndexDefs.Update;
    if AFreeIndexDefs then
      AIndexDefs.Free;
  end;
end;
 
end.

procedure TForm1.BtnSalvarClick(Sender: TObject);
begin
  TCDSSuppl.PostIfNeed(ClientDataSet1);
  TCDSSuppl.ApplyUpdates(ClientDataSet1, 0);
end;