[CLOSED] InverseReferenceCheck
lazarus / 16-Databases

----------------------------------------------------------------------
julkas · 2019-11-02 13:15

In the old Delphi 6 code I found -
Code: Pascal  [Select][+][-]window.onload = function(){var x1 =
document.getElementById("main_content_section"); if (x1) { var x =
document.getElementsByClassName("geshi");for (var i = 0; i
session.InverseReferenceCheck := False;What does it mean?

----------------------------------------------------------------------
marcov · 2019-11-02 13:17

That would depend on the type of "session" of course.

Please try to provide somewhat more detail with your questions.

----------------------------------------------------------------------
julkas · 2019-11-02 13:23

Quote from: marcov on November 02, 2019, 02:17:35 pmThat would depend
on the type of "session" of course.
Please try to provide somewhat more detail with your questions.
Code: Pascal  [Select][+][-]window.onload = function(){var x1 =
document.getElementById("main_content_section"); if (x1) { var x =
document.getElementsByClassName("geshi");for (var i = 0; i var 
session : TFastDbSession; Code: Pascal  [Select][+][-]window.onload =
function(){var x1 = document.getElementById("main_content_section");
if (x1) { var x = document.getElementsByClassName("geshi");for (var i
= 0; i type  TFastDbSession = class(TComponent) 
Code: Pascal  [Select][+][-]window.onload = function(){var x1 =
document.getElementById("main_content_section"); if (x1) { var x =
document.getElementsByClassName("geshi");for (var i = 0; i  
TFastDbSession = class(TComponent)  private    FLastErrorCode        
: Integer;    FRollbackOnDisconnect  : Boolean;    FUsername         
   : string;    FPassword              : string;    FDatabase        
    : string;    FDatabasePath          : string;    FHost           
     : string;    FPort                  : Integer;   
FMaxConnectRetries     : Integer;    FReconnectTimeout      :
Integer;    FInitDatabaseSize      : Integer;    FInitIndexSize      
 : Integer;    FExtensionQuantum      : Integer;    FFileSizeLimit   
    : Integer;    FAutoCommit            : Boolean;    FOnChange     
       : TDbSessionEvent;    FBeforeLogOn           :
TDbSessionEvent;    FAfterLogOn            : TDbSessionEvent;   
FHandle                : Integer;    FThreadID              : DWord; 
 FThreaded              : Boolean;    FContextList           :
TThreadList;    FReplicationSupport    : Boolean;    FNodeID         
     : Integer;    FNodeNames             : TStrArray;   
FOpenAttributes        : TCliOpenAttributes;   
FTransactionCommitDelay: Integer;    FTraceHandlerThunk     :
TProcedureOfObjectThunk;    FAssignedErrorHandler  : Boolean;   
FOldErrorHandler       : TCliErrorHandler;    FOnSessionError        :
TDbErrorHandler;    FOnTraceEvent          : TDbTraceEvent;   
procedure CheckHandle;    procedure SessionTraceHandler(Msg: PChar);
cdecl;    procedure SetConnected(const Value: Boolean);    procedure
SetLogonUsername(const Value: string);    procedure
SetLogonPassword(const Value: string);    procedure SetDatabase(const
Value: string);    procedure SetPort(const Value: Integer);   
procedure SetAutoCommit(const Value: Boolean);    function
 GetConnected: Boolean;    procedure SetDatabasePath(const Value:
string);    procedure SetHost(const Value: string);    procedure
SetTransactionCommitDelay(const Value: Integer);    procedure
SetMaxConnectRetries(const Value: Integer);    procedure
SetReconnectTimeout(const Value: Integer);    procedure
SetInitDatabaseSize(const Value: Integer);    procedure
InternalOpenDatabase(const AConnectLocal: Boolean);    procedure
SetOnTraceEvent(const Value: TDbTraceEvent);  protected    procedure
Loaded; override;    procedure DoBeforeLogon; virtual;    procedure
DoAfterLogon; virtual;    function  DumpFields(const Fields:
TFieldDescriptors; const LeftOffset: Integer=0): string;  public   
constructor Create(AOwner: TComponent); override;    destructor
 Destroy; override;    procedure OpenDatabase(                   
const AServerHost: string='';                    const AServerPort:
Integer=0;                    const AMaxConnectRetries: Integer=0;   
               const AReconnectTimeout:
Integer=FastDbDefReconnectTimeoutSec);    procedure CreateDatabase(  
                const ADatabaseName: string='';                   
const AFilePath: string='';                    const
AInitDatabaseSize: Integer=FastDbDefaultInitDatabaseSize;            
      const AOpenAttrs: TCliOpenAttributes=[oaReadWrite];            
      const AInitIndexSize: Integer=FastDbDefaultInitIndexSize;      
            const AExtensionQuantum:
Integer=FastDbDefaultExtensionQuantum;                    const
AFileSizeLimit: Integer=0;                    const
ATransactionCommitDelay: Word=0);    procedure
CreateReplicatedDatabase(                    const ANodeID: Integer; 
                 const ANodeNames: TStrArray;                    const
ADatabaseName: string='';                    const AFilePath:
string='';                    const AInitDatabaseSize:
Integer=FastDbDefaultInitDatabaseSize;                    const
AOpenAttrs: TCliOpenAttributes=[oaReadWrite];                    const
AInitIndexSize: Integer=FastDbDefaultInitIndexSize;                  
const AExtensionQuantum: Integer=FastDbDefaultExtensionQuantum;      
            const AFileSizeLimit: Integer=0);    procedure
CloseDatabase(const RaiseError: Boolean=True);    procedure
Commit(const Flush: Boolean);    procedure Rollback;    procedure
ListTables(List: TStringList);    function  TableExists(const Table:
string): Boolean;    function  DescribeTable(const Table: string; var
Fields: TFieldDescriptors; RaiseError: Boolean=True): Integer;
overload; // returns field count    function  DescribeTable(const
Table: string; Fields: TFastDbFields; RaiseError: Boolean=True) :
Integer; overload; // returns field count    function
 CreateTable(const Table: string; var Fields: TFieldDescriptors;
RefCheck: Boolean=False)  : Boolean; overload;    function
 CreateTable(const Table: string; const Fields: TFastDbFields;
RefCheck: Boolean=False)          : Boolean; overload;    procedure
DropTable(Table: string);    procedure AlterIndex(const Table, Field:
string; const NewFlags: TIndexTypes=[]);    function  AlterTable(const
Table: string; var Fields: TFieldDescriptors)  : Boolean; overload;  
function  AlterTable(const Table: string; const Fields: TFastDbFields)
   : Boolean; overload;    function  ExtractTableDDL(const TableName:
string): string;    procedure SaveDDLtoFile(FileName: string);   
function  GetDatabaseState: TCliDatabaseMonitor;  // Obtain database
status record    property  Handle: Integer  read FHandle;    property
 ThreadID: DWord  read FThreadID;   // thread which opened the
database    function  CliCheck(const Code: Integer; Msg: string='';
const RaiseError: Boolean=True): Integer;    function
 ErrorMessage(ErrorCode: Integer): string;    function  ServerVersion:
string;    // Threading support    procedure Attach;    procedure
Detach(ADetachMode: TDetachModes=[dtPreCommit, dtDestroyContext]);   
{$IFDEF GIGABASE}    procedure ClearConnectionPool;    // Close all
released connection in connection pool    {$ENDIF}    // Replication
support properties    property  ReplicationSupport: Boolean read
FReplicationSupport;    property  NodeID: Integer read FNodeID; 
published    property OnChange   : TDbSessionEvent        read
FOnChange          write FOnChange;    property OnSessionError:
TDbErrorHandler     read FOnSessionError    write FOnSessionError;   
property OnTraceEvent: TDbTraceEvent         read FOnTraceEvent    
 write SetOnTraceEvent;    property BeforeLogOn: TDbSessionEvent     
 read FBeforeLogOn       write FBeforeLogOn;    property AfterLogOn :
TDbSessionEvent        read FAfterLogOn        write FAfterLogOn;   
property LogonUsername: string               read FUsername        
 write SetLogonUsername;    property LogonPassword: string           
  read FPassword          write SetLogonPassword;    property
Database: string                    read FDatabase          write
SetDatabase;    property Host: string                        read
FHost              write SetHost;    property Port: Integer          
           read FPort              write SetPort;    property
DatabasePath: string                read FDatabasePath      write
SetDatabasePath;    property MaxConnectRetries: Integer          read
FMaxConnectRetries write SetMaxConnectRetries;    property
ReconnectTimeout: Integer           read FReconnectTimeout  write
SetReconnectTimeout;    property InitDatabaseSize: Integer          
read FInitDatabaseSize  write SetInitDatabaseSize;    property
InitIndexSize: Integer              read FInitIndexSize     write
FInitIndexSize;    property ExtensionQuantum: Integer           read
FExtensionQuantum  write FExtensionQuantum;    property FileSizeLimit:
Integer              read FFileSizeLimit     write FFileSizeLimit;   
property TransactionCommitDelay: Integer     read
FTransactionCommitDelay write SetTransactionCommitDelay;    property
OpenAttributes: TCliOpenAttributes  read FOpenAttributes    write
FOpenAttributes;    property Connected: Boolean                  read
GetConnected       write SetConnected;    property
RollbackOnDisconnect: Boolean       read FRollbackOnDisconnect write
FRollbackOnDisconnect;    property AutoCommit: Boolean               
read FAutoCommit        write SetAutoCommit Stored False;    property
LastErrorCode: Integer              read FLastErrorCode     write
FLastErrorCode;    property Threaded: Boolean                   read
FThreaded          write FThreaded;  end;

----------------------------------------------------------------------
marcov · 2019-11-02 13:34

A search for "Inversereferencecheck delphi" yields no results, and a
grep in my delphi sources dir yields no result either.

If I search for fastdb, I do find this:
http://www.garret.ru/fastdb.html, but there are many differing
archives there.

I suggest you debug the issue.

----------------------------------------------------------------------
julkas · 2019-11-02 13:52

Quote from: marcov on November 02, 2019, 02:34:44 pmA search for
"Inversereferencecheck delphi" yields no results, and a grep in my
delphi sources dir yields no result either.Me too. So I asked
question.

----------------------------------------------------------------------
Thaddy · 2019-11-02 15:19

I also grepped the D5/6/7 rtl/vcl sources: noone found.
Third-party code?

----------------------------------------------------------------------
julkas · 2019-11-02 16:23

Quote from: Thaddy on November 02, 2019, 04:19:31 pmI also grepped the
D5/6/7 rtl/vcl sources: noone found.
Third-party code?
I don't know @Serge (code creator) (I know code origin), but examining
source I think it's Delphi 6/7 property.
Compiling might clear.

----------------------------------------------------------------------
Thaddy · 2019-11-02 17:02

TFastDbSession is not a standard VCL class. That's third party code. I
own D6 (and many more versions) with full rtl/vcl sourcecode.

Note you can also deduce that from its name......Delphi engineers
would never write "fast" because it would mean another version was
lacking in speed.

----------------------------------------------------------------------
julkas · 2019-11-02 17:05

Thanks for replies.  I found  (may be) the answer.