anchor.diff:  var
     I: Integer;
   begin
  -  Result := Create;
  +  Result := Self.New;
     for I := 0 to Origin.Count -1 do
       with Origin[I] do
         Result.Add(FieldName, DataType, Value);
  
positive.code:     function Size: Int64;
    end;
  
    TDataResult = class sealed(TInterfacedObject, IDataResult)
    private
      FValue: Variant;
      FMessage: string;
    public
      constructor Create(Value: Variant; const Message: string);
      class function New(Value: Variant; const Message: string): IDataResult;
      function Value: Variant;
      function AsBoolean: Boolean;
      function Message: string;
    end;
  
    TDataParams = class(TInterfacedObject, IDataParams)
    private
      FParams: TParams;
    public
      constructor Create;
      class function New: IDataParams; overload;
      class function New(Origin: TFields): IDataParams; overload;
      destructor Destroy; override;
      function Add(Param: TParam): IDataParams; overload;
      function Add(const ParamName: string; DataType: TFieldType; Value: Variant): IDataParams; overload;
      function Param(Index: Integer): TParam; overload;
      function Param(const ParamName: string): TParam; overload;
      function Count: Integer;
      function AsString(const SeparatorChar: string): string; overload;
      function AsString: string; overload;
    end;
  
  implementation
  
  { TDataStream }
  
negative.code:   Result := FOrigin.Size;
  end;
  
  { TDataInformation }
  
  constructor TDataInformation.Create(const Id, Text, Metadata: string);
  begin
    inherited Create;
    FId := Id;
    FText := Text;
    FMetadata := Metadata;
  end;
  
  class function TDataInformation.New(const Id, Text, Metadata: string): IDataInformation;
  begin
    Result := Create(Id, Text, Metadata);
  end;
  
  class function TDataInformation.New(const Id, Text: string): IDataInformation;
  begin
    Result := Create(Id, Text, Text);
  end;
  
  class function TDataInformation.New(const Id: string): IDataInformation;
  begin
    Result := New(Id, '');
  end;
  
  function TDataInformation.Id: string;
  begin
    Result := FId;
  end;
  
  function TDataInformation.Text: string;
  begin
    Result := FText;
  end;
  
  function TDataInformation.Metadata: string;
  begin
    Result := FMetadata;
  end;
  
  { TDataInformations }
  
  constructor TDataInformations.Create;
  begin
    inherited Create;
    FList := TInterfaceList.Create;
  end;
  
  class function TDataInformations.New: IDataInformations;
  begin
    Result := Create;
  end;
  
  function TDataInformations.Add(Info: IDataInformation): IDataInformations;
  begin
    Result := Self;
    FList.Add(Info);
  end;
  
  function TDataInformations.Add(Infos: IDataInformations): IDataInformations;
  var
    I: Integer;
  begin
    Result := Self;
    for I := 0 to Infos.Count -1 do
      Add(Infos.Get(I));
  end;
  
  function TDataInformations.Get(Index: Integer): IDataInformation;
  begin
    Result := FList.Items[Index] as IDataInformation;
  end;
  
  function TDataInformations.Count: Integer;
  begin
    Result := FList.Count;
  end;
  
  function TDataInformations.Text: string;
  var
    I: Integer;
    Info: IDataInformation;
  begin
    Result := '';
    for I := 0 to Count -1 do
    begin
      Info := Get(I);
      Result := Result + Info.Id + ': ' + Info.Text + #13;
    end;
  end;
  
  { TDataParam }
  
  constructor TDataParam.Create(const Name: string; DataType: TFieldType; Value: Variant);
  begin
    inherited Create;
    FParam := TParam.Create(nil);
    FParam.Name := Name;
    FParam.DataType := DataType;
    FParam.Value := Value;
  end;
  
  class function TDataParam.New(const Name: string; DataType: TFieldType; Value: Variant): IDataParam;
  begin
    Result := Create(Name, DataType, Value);
  end;
  
  destructor TDataParam.Destroy;
  begin
    FParam.Free;
    inherited;
  end;
  
  function TDataParam.Name: string;
  begin
    Result := FParam.Name;
  end;
  
  function TDataParam.Value: Variant;
  begin
    Result := FParam.Value;
  end;
  
  function TDataParam.IsNull: Boolean;
  begin
    Result := FParam.IsNull;
  end;
  
  function TDataParam.AsParam: TParam;
  begin
    Result := FParam;
  end;
  
  function TDataParam.AsBCD: Currency;
  begin
    Result := FParam.AsBCD;
  end;
  
  function TDataParam.AsBlob: TBlobData;
  begin
    Result := FParam.AsBlob;
  end;
  
  function TDataParam.AsBoolean: Boolean;
  begin
    Result := FParam.AsBoolean;
  end;
  
  function TDataParam.AsCurrency: Currency;
  begin
    Result := FParam.AsCurrency;
  end;
  
  function TDataParam.AsDate: TDateTime;
  begin
    Result := FParam.AsDate;
  end;
  
  function TDataParam.AsDateTime: TDateTime;
  begin
    Result := FParam.AsDateTime;
  end;
  
  function TDataParam.AsFloat: Double;
  begin
    Result := FParam.AsFloat;
  end;
  
  function TDataParam.AsInteger: LongInt;
  begin
    Result := FParam.AsInteger;
  end;
  
  function TDataParam.AsSmallInt: LongInt;
  begin
    Result := FParam.AsSmallInt;
  end;
  
  function TDataParam.AsMemo: string;
  begin
    Result := FParam.AsMemo;
  end;
  
  function TDataParam.AsString: string;
  begin
    Result := FParam.AsString;
  end;
  
  function TDataParam.AsTime: TDateTime;
  begin
    Result := FParam.AsTime;
  end;
  
  function TDataParam.AsWord: LongInt;
  begin
    Result := FParam.AsWord;
  end;
  
  { TDataParams }
  