rm_jvinterpreter_dbtables.pas

这是一个功能强大

  Value := TParam(Args.Obj).AsMemo;
end;

{ property Write AsMemo(Value: string) }

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

{ property Read AsString: string }

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

{ property Write AsString(Value: string) }

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

{ property Read AsTime: TDateTime }

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

{ property Write AsTime(Value: TDateTime) }

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

{ property Read AsWord: Longint }

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

{ property Write AsWord(Value: Longint) }

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

{ property Read Bound: Boolean }

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

{ property Write Bound(Value: Boolean) }

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

{ property Read DataType: TFieldType }

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

{ property Write DataType(Value: TFieldType) }

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

{ property Read IsNull: Boolean }

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

{ property Read Name: string }

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

{ property Write Name(Value: string) }

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

{ property Read ParamType: TParamType }

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

{ property Write ParamType(Value: TParamType) }

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

{ property Read Text: string }

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

{ property Write Text(Value: string) }

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

{ property Read Value: Variant }

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

{ property Write Value(Value: Variant) }

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

{ TParams }

{ constructor Create }

procedure TParams_Create(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TParams.Create);
end;

{ procedure Assign(Source: TPersistent); }

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

{ procedure AssignValues(Value: TParams); }

procedure TParams_AssignValues(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParams(Args.Obj).AssignValues(V2O(Args.Values[0]) as TParams);
end;

{ procedure AddParam(Value: TParam); }

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

{ procedure RemoveParam(Value: TParam); }

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

{ function CreateParam(FldType: TFieldType; const ParamName: string; ParamType: TParamType): TParam; }

procedure TParams_CreateParam(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TParams(Args.Obj).CreateParam(Args.Values[0], Args.Values[1], Args.Values[2]));
end;

{ function Count: Integer; }

procedure TParams_Count(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParams(Args.Obj).Count;
end;

{ procedure Clear; }

procedure TParams_Clear(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParams(Args.Obj).Clear;
end;

{ procedure GetParamList(List: TList; const ParamNames: string); }

procedure TParams_GetParamList(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TParams(Args.Obj).GetParamList(V2O(Args.Values[0]) as TList, Args.Values[1]);
end;

{ function IsEqual(Value: TParams): Boolean; }

procedure TParams_IsEqual(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TParams(Args.Obj).IsEqual(V2O(Args.Values[0]) as TParams);
end;

{ function ParamByName(const Value: string): TParam; }

procedure TParams_ParamByName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TParams(Args.Obj).ParamByName(Args.Values[0]));
end;

{ property Read Items[Word]: TParam }

procedure TParams_Read_Items(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TParams(Args.Obj).Items[Args.Values[0]]);
end;

{ TStoredProc }

{ constructor Create(AOwner: TComponent) }

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

{ procedure CopyParams(Value: TParams); }

procedure TStoredProc_CopyParams(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).CopyParams(V2O(Args.Values[0]) as TParams);
end;

{ function DescriptionsAvailable: Boolean; }

procedure TStoredProc_DescriptionsAvailable(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStoredProc(Args.Obj).DescriptionsAvailable;
end;

{ procedure ExecProc; }

procedure TStoredProc_ExecProc(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).ExecProc;
end;

{ function ParamByName(const Value: string): TParam; }

procedure TStoredProc_ParamByName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStoredProc(Args.Obj).ParamByName(Args.Values[0]));
end;

{ procedure Prepare; }

procedure TStoredProc_Prepare(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).Prepare;
end;

{ procedure GetResults; }

procedure TStoredProc_GetResults(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).GetResults;
end;

{ procedure UnPrepare; }

procedure TStoredProc_UnPrepare(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).UnPrepare;
end;

{ property Read ParamCount: Word }

procedure TStoredProc_Read_ParamCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStoredProc(Args.Obj).ParamCount;
end;

{ property Read StmtHandle: HDBIStmt }

procedure TStoredProc_Read_StmtHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TStoredProc(Args.Obj).StmtHandle);
end;

{ property Read Prepared: Boolean }

procedure TStoredProc_Read_Prepared(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStoredProc(Args.Obj).Prepared;
end;

{ property Write Prepared(Value: Boolean) }

procedure TStoredProc_Write_Prepared(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).Prepared := Value;
end;

{ property Read StoredProcName: string }

procedure TStoredProc_Read_StoredProcName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStoredProc(Args.Obj).StoredProcName;
end;

{ property Write StoredProcName(Value: string) }

procedure TStoredProc_Write_StoredProcName(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).StoredProcName := Value;
end;

{ property Read Overload: Word }

procedure TStoredProc_Read_Overload(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStoredProc(Args.Obj).Overload;
end;

{ property Write Overload(Value: Word) }

procedure TStoredProc_Write_Overload(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).Overload := Value;
end;

{ property Read Params: TParams }

procedure TStoredProc_Read_Params(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TStoredProc(Args.Obj).Params);
end;

{ property Write Params(Value: TParams) }

procedure TStoredProc_Write_Params(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).Params := V2O(Value) as TParams;
end;

{ property Read ParamBindMode: TParamBindMode }

procedure TStoredProc_Read_ParamBindMode(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TStoredProc(Args.Obj).ParamBindMode;
end;

{ property Write ParamBindMode(Value: TParamBindMode) }

procedure TStoredProc_Write_ParamBindMode(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TStoredProc(Args.Obj).ParamBindMode := Value;
end;

{ TQuery }

{ constructor Create(AOwner: TComponent) }

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

{ procedure ExecSQL; }

procedure TQuery_ExecSQL(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TQuery(Args.Obj).ExecSQL;
end;

{ function ParamByName(const Value: string): TParam; }

procedure TQuery_ParamByName(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := O2V(TQuery(Args.Obj).ParamByName(Args.Values[0]));
end;

{ procedure Prepare; }

procedure TQuery_Prepare(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TQuery(Args.Obj).Prepare;
end;

{ procedure UnPrepare; }

procedure TQuery_UnPrepare(var Value: Variant; Args: TJvInterpreterArgs);
begin
  TQuery(Args.Obj).UnPrepare;
end;

{ property Read Prepared: Boolean }

procedure TQuery_Read_Prepared(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TQuery(Args.Obj).Prepared;
end;

{ property Write Prepared(Value: Boolean) }

procedure TQuery_Write_Prepared(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TQuery(Args.Obj).Prepared := Value;
end;

{ property Read ParamCount: Word }

procedure TQuery_Read_ParamCount(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TQuery(Args.Obj).ParamCount;
end;

{ property Read Local: Boolean }

procedure TQuery_Read_Local(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TQuery(Args.Obj).Local;
end;

{ property Read StmtHandle: HDBIStmt }

procedure TQuery_Read_StmtHandle(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := P2V(TQuery(Args.Obj).StmtHandle);
end;

{ property Read Text: string }

procedure TQuery_Read_Text(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TQuery(Args.Obj).Text;
end;

{ property Read RowsAffected: Integer }

procedure TQuery_Read_RowsAffected(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TQuery(Args.Obj).RowsAffected;
end;

{ property Read SQLBinary: PChar }

procedure TQuery_Read_SQLBinary(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := string(TQuery(Args.Obj).SQLBinary);
end;

{ property Write SQLBinary(Value: PChar) }

procedure TQuery_Write_SQLBinary(const Value: Variant; Args: TJvInterpreterArgs);
begin
  TQuery(Args.Obj).SQLBinary := PChar(string(Value));
end;

{ property Read Constrained: Boolean }

procedure TQuery_Read_Constrained(var Value: Variant; Args: TJvInterpreterArgs);
begin
  Value := TQuery(Arg