rm_jvinterpreter_dbtables.pas

这是一个功能强大

{ property Read Locale: TLocale }

procedure TBDEDataSet_Read_Locale(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TBDEDataSet(Args.Obj).Locale);
end;

{ property Read UpdateObject: TDataSetUpdateObject }

procedure TBDEDataSet_Read_UpdateObject(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TBDEDataSet(Args.Obj).UpdateObject);
end;

{ property Write UpdateObject(Value: TDataSetUpdateObject) }

procedure TBDEDataSet_Write_UpdateObject(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBDEDataSet(Args.Obj).UpdateObject := V2O(Value) as TDataSetUpdateObject;
end;

{ property Read UpdatesPending: Boolean }

procedure TBDEDataSet_Read_UpdatesPending(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBDEDataSet(Args.Obj).UpdatesPending;
end;

{ property Read UpdateRecordTypes: TUpdateRecordTypes }

procedure TBDEDataSet_Read_UpdateRecordTypes(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := S2V(Byte(TBDEDataSet(Args.Obj).UpdateRecordTypes));
end;

{ property Write UpdateRecordTypes(Value: TUpdateRecordTypes) }

procedure TBDEDataSet_Write_UpdateRecordTypes(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBDEDataSet(Args.Obj).UpdateRecordTypes := TUpdateRecordTypes(Byte(V2S(Value)));
end;

{ property Read CachedUpdates: Boolean }

procedure TBDEDataSet_Read_CachedUpdates(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TBDEDataSet(Args.Obj).CachedUpdates;
end;

{ property Write CachedUpdates(Value: Boolean) }

procedure TBDEDataSet_Write_CachedUpdates(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TBDEDataSet(Args.Obj).CachedUpdates := Value;
end;

{ TDBDataSet }

{ function CheckOpen(Status: DBIResult): Boolean; }

procedure TDBDataSet_CheckOpen(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDBDataSet(Args.Obj).CheckOpen(Args.Values[0]);
end;

{ procedure CloseDatabase(Database: TDatabase); }

procedure TDBDataSet_CloseDatabase(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TDBDataSet(Args.Obj).CloseDatabase(V2O(Args.Values[0]) as TDatabase);
end;

{ function OpenDatabase: TDatabase; }

procedure TDBDataSet_OpenDatabase(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDBDataSet(Args.Obj).OpenDatabase);
end;

{ property Read Database: TDatabase }

procedure TDBDataSet_Read_Database(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDBDataSet(Args.Obj).Database);
end;

{ property Read DBHandle: HDBIDB }

procedure TDBDataSet_Read_DBHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := Longint(TDBDataSet(Args.Obj).DBHandle);
end;

{ property Read DBLocale: TLocale }

procedure TDBDataSet_Read_DBLocale(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TDBDataSet(Args.Obj).DBLocale);
end;

{ property Read DBSession: TSession }

procedure TDBDataSet_Read_DBSession(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TDBDataSet(Args.Obj).DBSession);
end;

{ property Read DatabaseName: string }

procedure TDBDataSet_Read_DatabaseName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDBDataSet(Args.Obj).DatabaseName;
end;

{ property Write DatabaseName(Value: string) }

procedure TDBDataSet_Write_DatabaseName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDBDataSet(Args.Obj).DatabaseName := Value;
end;

{ property Read SessionName: string }

procedure TDBDataSet_Read_SessionName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TDBDataSet(Args.Obj).SessionName;
end;

{ property Write SessionName(Value: string) }

procedure TDBDataSet_Write_SessionName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TDBDataSet(Args.Obj).SessionName := Value;
end;

{ TTable }

{ constructor Create(AOwner: TComponent) }

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

{ function BatchMove(ASource: TBDEDataSet; AMode: TBatchMode): Longint; }

procedure TTable_BatchMove(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TTable(Args.Obj).BatchMove(V2O(Args.Values[0]) as TBDEDataSet, Args.Values[1]);
end;

{ procedure AddIndex(const Name, Fields: string; Options: TIndexOptions); }

procedure TTable_AddIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).AddIndex(Args.Values[0], Args.Values[1], TIndexOptions(Byte(V2S(Args.Values[2]))));
end;

{ procedure ApplyRange; }

procedure TTable_ApplyRange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).ApplyRange;
end;

{ procedure CancelRange; }

procedure TTable_CancelRange(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).CancelRange;
end;

{ procedure CloseIndexFile(const IndexFileName: string); }

procedure TTable_CloseIndexFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).CloseIndexFile(Args.Values[0]);
end;

{ procedure CreateTable; }

procedure TTable_CreateTable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).CreateTable;
end;

{ procedure DeleteIndex(const Name: string); }

procedure TTable_DeleteIndex(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).DeleteIndex(Args.Values[0]);
end;

{ procedure DeleteTable; }

procedure TTable_DeleteTable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).DeleteTable;
end;

{ procedure EditKey; }

procedure TTable_EditKey(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).EditKey;
end;

{ procedure EditRangeEnd; }

procedure TTable_EditRangeEnd(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).EditRangeEnd;
end;

{ procedure EditRangeStart; }

procedure TTable_EditRangeStart(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).EditRangeStart;
end;

{ procedure EmptyTable; }

procedure TTable_EmptyTable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).EmptyTable;
end;

{ function FindKey(const KeyValues: array of const): Boolean; }

procedure TTable_FindKey(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Args.OpenArray(0);
  Value := TTable(Args.Obj).FindKey(Slice(Args.OA^, Args.OAS));
end;

{ procedure FindNearest(const KeyValues: array of const); }

procedure TTable_FindNearest(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Args.OpenArray(0);
  TTable(Args.Obj).FindNearest(Slice(Args.OA^, Args.OAS));
end;

{ procedure GetIndexNames(List: TStrings); }

procedure TTable_GetIndexNames(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).GetIndexNames(V2O(Args.Values[0]) as TStrings);
end;

{ procedure GotoCurrent(Table: TTable); }

procedure TTable_GotoCurrent(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).GotoCurrent(V2O(Args.Values[0]) as TTable);
end;

{ function GotoKey: Boolean; }

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

{ procedure GotoNearest; }

procedure TTable_GotoNearest(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).GotoNearest;
end;

{ procedure LockTable(LockType: TLockType); }

procedure TTable_LockTable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).LockTable(Args.Values[0]);
end;

{ procedure OpenIndexFile(const IndexName: string); }

procedure TTable_OpenIndexFile(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).OpenIndexFile(Args.Values[0]);
end;

{ procedure RenameTable(const NewTableName: string); }

procedure TTable_RenameTable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).RenameTable(Args.Values[0]);
end;

{ procedure SetKey; }

procedure TTable_SetKey(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).SetKey;
end;

{ procedure SetRange(const StartValues, EndValues: array of const); }

procedure TTable_SetRange(var Value: Variant; Args: TJvInterpreterArgs);
var
  OA: TOpenArray;
  OAV: TValueArray;
  OAS: Integer;
begin
  Args.OpenArray(0);
  V2OA(Args.Values[1], OA, OAV, OAS);
  TTable(Args.Obj).SetRange(Slice(Args.OA^, Args.OAS), OA);
end;

{ procedure SetRangeEnd; }

procedure TTable_SetRangeEnd(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).SetRangeEnd;
end;

{ procedure SetRangeStart; }

procedure TTable_SetRangeStart(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).SetRangeStart;
end;

{ procedure UnlockTable(LockType: TLockType); }

procedure TTable_UnlockTable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).UnlockTable(Args.Values[0]);
end;

{ property Read IndexDefs: TIndexDefs }

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

{ property Read IndexFieldCount: Integer }

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

{ property Read IndexFields[Integer]: TField }

procedure TTable_Read_IndexFields(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TTable(Args.Obj).IndexFields[Args.Values[0]]);
end;

{ property Write IndexFields[Integer]: TField }

procedure TTable_Write_IndexFields(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).IndexFields[Args.Values[0]] := V2O(Value) as TField;
end;

{ property Read KeyExclusive: Boolean }

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

{ property Write KeyExclusive(Value: Boolean) }

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

{ property Read KeyFieldCount: Integer }

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

{ property Write KeyFieldCount(Value: Integer) }

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

{ property Read TableLevel: Integer }

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

{ property Write TableLevel(Value: Integer) }

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

{ property Read Exclusive: Boolean }

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

{ property Write Exclusive(Value: Boolean) }

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

{ property Read IndexFieldNames: string }

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

{ property Write IndexFieldNames(Value: string) }

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

{ property Read IndexFiles: TStrings }

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

{ property Write IndexFiles(Value: TStrings) }

procedure TTable_Write_IndexFiles(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TTable(Args.Obj).IndexFiles := V2O(Value) as TStrings;
end;

{ property Read IndexName: string }

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

{ property Write IndexName(Value: string) }

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

{ property Read MasterFields: string }

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

{ property Write MasterFields(Value: string) }

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

{ property Read MasterSource: TDataSource }