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;