rm_jvinterpreter_dbtables.pas

这是一个功能强大

procedure TTable_Read_MasterSource(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTable(Args.Obj).MasterSource);
end;

{ property Write MasterSource(Value: TDataSource) }

procedure TTable_Write_MasterSource(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).MasterSource := V2O(Value) as TDataSource;
end;

{ property Read ReadOnly: Boolean }

procedure TTable_Read_ReadOnly(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTable(Args.Obj).ReadOnly;
end;

{ property Write ReadOnly(Value: Boolean) }

procedure TTable_Write_ReadOnly(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).ReadOnly := Value;
end;

{ property Read TableName: TFileName }

procedure TTable_Read_TableName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTable(Args.Obj).TableName;
end;

{ property Write TableName(Value: TFileName) }

procedure TTable_Write_TableName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).TableName := Value;
end;

{ property Read TableType: TTableType }

procedure TTable_Read_TableType(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTable(Args.Obj).TableType;
end;

{ property Write TableType(Value: TTableType) }

procedure TTable_Write_TableType(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).TableType := Value;
end;

{ TBatchMove }

{ constructor Create(AOwner: TComponent) }

procedure TBatchMove_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBatchMove.Create(V2O(Args.Values[0]) as TComponent));
end;

{ procedure Execute; }

procedure TBatchMove_Execute(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).Execute;
end;

{ property Read ChangedCount: Longint }

procedure TBatchMove_Read_ChangedCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).ChangedCount;
end;

{ property Read KeyViolCount: Longint }

procedure TBatchMove_Read_KeyViolCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).KeyViolCount;
end;

{ property Read MovedCount: Longint }

procedure TBatchMove_Read_MovedCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).MovedCount;
end;

{ property Read ProblemCount: Longint }

procedure TBatchMove_Read_ProblemCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).ProblemCount;
end;

{ property Read AbortOnKeyViol: Boolean }

procedure TBatchMove_Read_AbortOnKeyViol(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).AbortOnKeyViol;
end;

{ property Write AbortOnKeyViol(Value: Boolean) }

procedure TBatchMove_Write_AbortOnKeyViol(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).AbortOnKeyViol := Value;
end;

{ property Read AbortOnProblem: Boolean }

procedure TBatchMove_Read_AbortOnProblem(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).AbortOnProblem;
end;

{ property Write AbortOnProblem(Value: Boolean) }

procedure TBatchMove_Write_AbortOnProblem(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).AbortOnProblem := Value;
end;

{ property Read CommitCount: Integer }

procedure TBatchMove_Read_CommitCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).CommitCount;
end;

{ property Write CommitCount(Value: Integer) }

procedure TBatchMove_Write_CommitCount(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).CommitCount := Value;
end;

{ property Read ChangedTableName: TFileName }

procedure TBatchMove_Read_ChangedTableName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).ChangedTableName;
end;

{ property Write ChangedTableName(Value: TFileName) }

procedure TBatchMove_Write_ChangedTableName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).ChangedTableName := Value;
end;

{ property Read Destination: TTable }

procedure TBatchMove_Read_Destination(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBatchMove(Args.Obj).Destination);
end;

{ property Write Destination(Value: TTable) }

procedure TBatchMove_Write_Destination(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).Destination := V2O(Value) as TTable;
end;

{ property Read KeyViolTableName: TFileName }

procedure TBatchMove_Read_KeyViolTableName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).KeyViolTableName;
end;

{ property Write KeyViolTableName(Value: TFileName) }

procedure TBatchMove_Write_KeyViolTableName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).KeyViolTableName := Value;
end;

{ property Read Mappings: TStrings }

procedure TBatchMove_Read_Mappings(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBatchMove(Args.Obj).Mappings);
end;

{ property Write Mappings(Value: TStrings) }

procedure TBatchMove_Write_Mappings(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).Mappings := V2O(Value) as TStrings;
end;

{ property Read Mode: TBatchMode }

procedure TBatchMove_Read_Mode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).Mode;
end;

{ property Write Mode(Value: TBatchMode) }

procedure TBatchMove_Write_Mode(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).Mode := Value;
end;

{ property Read ProblemTableName: TFileName }

procedure TBatchMove_Read_ProblemTableName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).ProblemTableName;
end;

{ property Write ProblemTableName(Value: TFileName) }

procedure TBatchMove_Write_ProblemTableName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).ProblemTableName := Value;
end;

{ property Read RecordCount: Longint }

procedure TBatchMove_Read_RecordCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).RecordCount;
end;

{ property Write RecordCount(Value: Longint) }

procedure TBatchMove_Write_RecordCount(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).RecordCount := Value;
end;

{ property Read Source: TBDEDataSet }

procedure TBatchMove_Read_Source(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBatchMove(Args.Obj).Source);
end;

{ property Write Source(Value: TBDEDataSet) }

procedure TBatchMove_Write_Source(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).Source := V2O(Value) as TBDEDataSet;
end;

{ property Read Transliterate: Boolean }

procedure TBatchMove_Read_Transliterate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBatchMove(Args.Obj).Transliterate;
end;

{ property Write Transliterate(Value: Boolean) }

procedure TBatchMove_Write_Transliterate(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBatchMove(Args.Obj).Transliterate := Value;
end;

{ TParam }

{ constructor Create(AParamList: TParams; AParamType: TParamType) }

procedure TParam_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TParam.Create(V2O(Args.Values[0]) as TParams, Args.Values[1]));
end;

{ procedure Assign(Source: TPersistent); }

procedure TParam_Assign(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).Assign(V2O(Args.Values[0]) as TParam);
end;

{ procedure AssignField(Field: TField); }

procedure TParam_AssignField(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AssignField(V2O(Args.Values[0]) as TField);
end;

{ procedure AssignFieldValue(Field: TField; const Value: Variant); }

procedure TParam_AssignFieldValue(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AssignFieldValue(V2O(Args.Values[0]) as TField, Args.Values[1]);
end;

{ procedure Clear; }

procedure TParam_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).Clear;
end;

{ procedure GetData(Buffer: Pointer); }

procedure TParam_GetData(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).GetData(V2P(Args.Values[0]));
end;

{ function GetDataSize: Integer; }

procedure TParam_GetDataSize(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).GetDataSize;
end;

{ procedure LoadFromFile(const FileName: string; BlobType: TBlobType); }

procedure TParam_LoadFromFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).LoadFromFile(Args.Values[0], Args.Values[1]);
end;

{ procedure LoadFromStream(Stream: TStream; BlobType: TBlobType); }

procedure TParam_LoadFromStream(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).LoadFromStream(V2O(Args.Values[0]) as TStream, Args.Values[1]);
end;

{ procedure SetBlobData(Buffer: Pointer; Size: Integer); }

procedure TParam_SetBlobData(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).SetBlobData(V2P(Args.Values[0]), Args.Values[1]);
end;

{ procedure SetData(Buffer: Pointer); }

procedure TParam_SetData(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).SetData(V2P(Args.Values[0]));
end;

{ property Read AsBCD: Currency }

procedure TParam_Read_AsBCD(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsBCD;
end;

{ property Write AsBCD(Value: Currency) }

procedure TParam_Write_AsBCD(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsBCD := Value;
end;

{ property Read AsBlob: TBlobData }

procedure TParam_Read_AsBlob(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsBlob;
end;

{ property Write AsBlob(Value: TBlobData) }

procedure TParam_Write_AsBlob(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsBlob := Value;
end;

{ property Read AsBoolean: Boolean }

procedure TParam_Read_AsBoolean(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsBoolean;
end;

{ property Write AsBoolean(Value: Boolean) }

procedure TParam_Write_AsBoolean(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsBoolean := Value;
end;

{ property Read AsCurrency: Double }

procedure TParam_Read_AsCurrency(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsCurrency;
end;

{ property Write AsCurrency(Value: Double) }

procedure TParam_Write_AsCurrency(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsCurrency := Value;
end;

{ property Read AsDate: TDateTime }

procedure TParam_Read_AsDate(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsDate;
end;

{ property Write AsDate(Value: TDateTime) }

procedure TParam_Write_AsDate(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsDate := Value;
end;

{ property Read AsDateTime: TDateTime }

procedure TParam_Read_AsDateTime(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsDateTime;
end;

{ property Write AsDateTime(Value: TDateTime) }

procedure TParam_Write_AsDateTime(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsDateTime := Value;
end;

{ property Read AsFloat: Double }

procedure TParam_Read_AsFloat(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsFloat;
end;

{ property Write AsFloat(Value: Double) }

procedure TParam_Write_AsFloat(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsFloat := Value;
end;

{ property Read AsInteger: Longint }

procedure TParam_Read_AsInteger(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsInteger;
end;

{ property Write AsInteger(Value: Longint) }

procedure TParam_Write_AsInteger(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsInteger := Value;
end;

{ property Read AsSmallInt: Longint }

procedure TParam_Read_AsSmallInt(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParam(Args.Obj).AsSmallInt;
end;

{ property Write AsSmallInt(Value: Longint) }

procedure TParam_Write_AsSmallInt(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TParam(Args.Obj).AsSmallInt := Value;
end;

{ property Read AsMemo: string }

procedure TParam_Read_AsMemo(var Value: Variant; Args: TJvInterpreterArgs);
begin