home *** CD-ROM | disk | FTP | other *** search
/ Prima Shareware 3 / DuCom_Prima-Shareware-3_cd1.bin / PROGRAMO / delphi / ODA10 / _SETUP.1 / DAOClass.inc < prev    next >
Encoding:
Text File  |  1996-03-21  |  33.2 KB  |  828 lines
  1. {---------------------- forward declarations }
  2.  
  3. DAOBase = class;
  4. DAOCollection = class;
  5. DAODynaCollection = class;
  6. DAOEngine = class;
  7. DAOErrors = class;
  8. DAOError = class;
  9. DAOWorkspaces = class;
  10. DAOWorkspace = class;
  11. DAODatabases = class;
  12. DAODatabase = class;
  13. DAOTableDefs = class;
  14. DAOTableDef = class;
  15. DAOQueryDefs = class;
  16. DAOQueryDef = class;
  17. DAORecordsets = class;
  18. DAORecordset = class;
  19. DAOFields = class;
  20. DAOField = class;
  21. DAOIndexes = class;
  22. DAOIndex = class;
  23. DAOIndexFields = class;
  24. DAOParameters = class;
  25. DAOParameter = class;
  26. DAOUsers = class;
  27. DAOUser = class;
  28. DAOGroups = class;
  29. DAOGroup = class;
  30. DAORelations = class;
  31. DAORelation = class;
  32. DAOProperties = class;
  33. DAOProperty = class;
  34. DAOContainers = class;
  35. DAOContainer = class;
  36. DAODocuments = class;
  37. DAODocument = class;
  38.  
  39. {---------------------- DAOBase }
  40.  
  41. DAOBase = class(DAOObject)
  42. private {access methods}
  43.   function GetProperties{}: DAOBase;
  44. public {properties}
  45.   property Properties: DAOBase read GetProperties;
  46. public {methods}
  47. end {DAOBase};
  48.  
  49. {---------------------- DAOCollection }
  50.  
  51. DAOCollection = class(DAOObject)
  52. private {access methods}
  53.   function GetCount{}: smallint;
  54. public {properties}
  55.   property Count: smallint read GetCount;
  56. public {methods}
  57.   function _NewEnum{}: DAOObject;
  58.   procedure Refresh{};
  59. end {DAOCollection};
  60.  
  61. {---------------------- DAODynaCollection }
  62.  
  63. DAODynaCollection = class(DAOCollection)
  64. public {methods}
  65.   procedure Append( const obj: DAOObject );
  66.   procedure Delete( const name: string );
  67. end {DAODynaCollection};
  68.  
  69. {---------------------- DAOEngine }
  70.  
  71. DAOEngine = class(DAOBase)
  72. private {access methods}
  73.   function GetVersion{}: string;
  74.   function GetIniPath{}: string;
  75.   procedure SetIniPath( const path: string );
  76.   procedure SetDefaultUser( const user: string );
  77.   procedure SetDefaultPassword( const pwd: string );
  78.   function GetLoginTimeout{}: smallint;
  79.   procedure SetLoginTimeout( const timeout: smallint );
  80.   function GetWorkspaces{}: DAOWorkspaces;
  81.   function GetErrors{}: DAOErrors;
  82.   function GetSystemDB{}: string;
  83.   procedure SetSystemDB( const path: string );
  84. public {properties}
  85.   property Version: string read GetVersion;
  86.   property IniPath: string read GetIniPath write SetIniPath;
  87.   property DefaultUser: string write SetDefaultUser;
  88.   property DefaultPassword: string write SetDefaultPassword;
  89.   property LoginTimeout: smallint read GetLoginTimeout write SetLoginTimeout;
  90.   property Workspaces: DAOWorkspaces read GetWorkspaces;
  91.   property Errors: DAOErrors read GetErrors;
  92.   property SystemDB: string read GetSystemDB write SetSystemDB;
  93. public {methods}
  94.   procedure Idle( const action: Variant );
  95.   procedure CompactDatabase( const src: string; const dst: string; const dstConnect: Variant; const options: Variant; const srcConnect: Variant );
  96.   procedure RepairDatabase( const name: string );
  97.   procedure RegisterDatabase( const dsn: string; const driver: string; const silent: VariantBool; const attribs: string );
  98.   function CreateWorkspace( const name: string; const user: string; const pwd: string ): DAOWorkspace;
  99.   function OpenDatabase( const name: string; const excl: Variant; const readOnly: Variant; const connect: Variant ): DAODatabase;
  100.   function CreateDatabase( const name: string; const connect: string; const option: Variant ): DAODatabase;
  101.   procedure FreeLocks{};
  102.   procedure BeginTrans{};
  103.   procedure CommitTrans{};
  104.   procedure Rollback{};
  105.   procedure SetDefaultWorkspace( const name: string; const pwd: string );
  106.   procedure SetDataAccessOption( const option: smallint; const value: Variant );
  107.   function ISAMStats( const statNum: longint; const reset: Variant ): longint;
  108. end {DAOEngine};
  109.  
  110. {---------------------- DAOErrors }
  111.  
  112. DAOErrors = class(DAOCollection)
  113. private {access methods}
  114.   function GetItem( const idx: Variant ): DAOError;
  115. public {properties}
  116.   property Item[const idx: Variant]: DAOError read GetItem; default;
  117. public {methods}
  118. end {DAOErrors};
  119.  
  120. {---------------------- DAOError }
  121.  
  122. DAOError = class(DAOObject)
  123. private {access methods}
  124.   function GetNumber{}: longint;
  125.   function GetSource{}: string;
  126.   function GetDescription{}: string;
  127.   function GetHelpFile{}: string;
  128.   function GetHelpContext{}: longint;
  129. public {properties}
  130.   property Number: longint read GetNumber;
  131.   property Source: string read GetSource;
  132.   property Description: string read GetDescription;
  133.   property HelpFile: string read GetHelpFile;
  134.   property HelpContext: longint read GetHelpContext;
  135. public {methods}
  136. end {DAOError};
  137.  
  138. {---------------------- DAOWorkspaces }
  139.  
  140. DAOWorkspaces = class(DAODynaCollection)
  141. private {access methods}
  142.   function GetItem( const idx: Variant ): DAOWorkspace;
  143. public {properties}
  144.   property Item[const idx: Variant]: DAOWorkspace read GetItem; default;
  145. public {methods}
  146. end {DAOWorkspaces};
  147.  
  148. {---------------------- DAOWorkspace }
  149.  
  150. DAOWorkspace = class(DAOBase)
  151. private {access methods}
  152.   function GetName{}: string;
  153.   procedure SetName( const name: string );
  154.   function GetUserName{}: string;
  155.   procedure SetUserName( const name: string );
  156.   procedure SetPassword( const pwd: string );
  157.   function GetIsolateODBCTrans{}: smallint;
  158.   procedure SetIsolateODBCTrans( const value: smallint );
  159.   function GetDatabases{}: DAODatabases;
  160.   function GetUsers{}: DAOUsers;
  161.   function GetGroups{}: DAOGroups;
  162. public {properties}
  163.   property Name: string read GetName write SetName;
  164.   property UserName: string read GetUserName write SetUserName;
  165.   property Password: string write SetPassword;
  166.   property IsolateODBCTrans: smallint read GetIsolateODBCTrans write SetIsolateODBCTrans;
  167.   property Databases: DAODatabases read GetDatabases;
  168.   property Users: DAOUsers read GetUsers;
  169.   property Groups: DAOGroups read GetGroups;
  170. public {methods}
  171.   procedure BeginTrans{};
  172.   procedure CommitTrans{};
  173.   procedure Close{};
  174.   procedure Rollback{};
  175.   function OpenDatabase( const name: string; const excl: Variant; const readOnly: Variant; const connect: Variant ): DAODatabase;
  176.   function CreateDatabase( const name: string; const connect: string; const option: Variant ): DAODatabase;
  177.   function CreateUser( const name: Variant; const pid: Variant; const pwd: Variant ): DAOUser;
  178.   function CreateGroup( const name: Variant; const pid: Variant ): DAOGroup;
  179. end {DAOWorkspace};
  180.  
  181. {---------------------- DAODatabases }
  182.  
  183. DAODatabases = class(DAOCollection)
  184. private {access methods}
  185.   function GetItem( const idx: Variant ): DAODatabase;
  186. public {properties}
  187.   property Item[const idx: Variant]: DAODatabase read GetItem; default;
  188. public {methods}
  189. end {DAODatabases};
  190.  
  191. {---------------------- DAODatabase }
  192.  
  193. DAODatabase = class(DAOBase)
  194. private {access methods}
  195.   function GetCollatingOrder{}: longint;
  196.   function GetConnect{}: string;
  197.   function GetName{}: string;
  198.   function GetQueryTimeout{}: smallint;
  199.   procedure SetQueryTimeout( const value: smallint );
  200.   function GetTransactions{}: VariantBool;
  201.   function GetUpdatable{}: VariantBool;
  202.   function GetVersion{}: string;
  203.   function GetRecordsAffected{}: longint;
  204.   function GetTableDefs{}: DAOTableDefs;
  205.   function GetQueryDefs{}: DAOQueryDefs;
  206.   function GetRelations{}: DAORelations;
  207.   function GetContainers{}: DAOContainers;
  208.   function GetRecordsets{}: DAORecordsets;
  209.   function GetReplicaID{}: string;
  210.   function GetDesignMasterID{}: string;
  211.   procedure SetDesignMasterID( const id: string );
  212.   procedure SetConnect( const odbcConnect: string );
  213. public {properties}
  214.   property CollatingOrder: longint read GetCollatingOrder;
  215.   property Connect: string read GetConnect write SetConnect;
  216.   property Name: string read GetName;
  217.   property QueryTimeout: smallint read GetQueryTimeout write SetQueryTimeout;
  218.   property Transactions: VariantBool read GetTransactions;
  219.   property Updatable: VariantBool read GetUpdatable;
  220.   property Version: string read GetVersion;
  221.   property RecordsAffected: longint read GetRecordsAffected;
  222.   property TableDefs: DAOTableDefs read GetTableDefs;
  223.   property QueryDefs: DAOQueryDefs read GetQueryDefs;
  224.   property Relations: DAORelations read GetRelations;
  225.   property Containers: DAOContainers read GetContainers;
  226.   property Recordsets: DAORecordsets read GetRecordsets;
  227.   property ReplicaID: string read GetReplicaID;
  228.   property DesignMasterID: string read GetDesignMasterID write SetDesignMasterID;
  229. public {methods}
  230.   procedure Close{};
  231.   procedure Execute( const query: string; const options: Variant );
  232.   function OpenRecordset( const name: string; const ofType: Variant; const options: Variant ): DAORecordset;
  233.   function CreateProperty( const name: Variant; const typ: Variant; const value: Variant; const ddl: Variant ): DAOProperty;
  234.   function CreateRelation( const name: Variant; const table: Variant; const foreignTable: Variant; const attribs: Variant ): DAORelation;
  235.   function CreateTableDef( const name: Variant; const attribs: Variant; const srcName: Variant; const srcConnect: Variant ): DAOTableDef;
  236.   procedure BeginTrans{};
  237.   procedure CommitTrans{};
  238.   procedure Rollback{};
  239.   function CreateDynaset( const name: string; const options: Variant; const inconsistent: Variant ): DAORecordset;
  240.   function CreateQueryDef( const name: Variant; const sql: Variant ): DAOQueryDef;
  241.   function CreateSnapshot( const src: string; const options: Variant ): DAORecordset;
  242.   procedure DeleteQueryDef( const name: string );
  243.   function ExecuteSQL( const sql: string ): longint;
  244.   function ListFields( const tblName: string ): DAORecordset;
  245.   function ListTables{}: DAORecordset;
  246.   function OpenQueryDef( const name: string ): DAOBase;
  247.   function OpenTable( const name: string; const options: Variant ): DAORecordset;
  248.   procedure Synchronize( const dbPathName: string; const xchgType: Variant );
  249.   procedure MakeReplica( const pathName: string; const descript: string; const options: Variant );
  250.   procedure NewPassword( const old: string; const new: string );
  251. end {DAODatabase};
  252.  
  253. {---------------------- DAOTableDefs }
  254.  
  255. DAOTableDefs = class(DAODynaCollection)
  256. private {access methods}
  257.   function GetItem( const idx: Variant ): DAOTableDef;
  258. public {properties}
  259.   property Item[const idx: Variant]: DAOTableDef read GetItem; default;
  260. public {methods}
  261. end {DAOTableDefs};
  262.  
  263. {---------------------- DAOTableDef }
  264.  
  265. DAOTableDef = class(DAOBase)
  266. private {access methods}
  267.   function GetAttributes{}: longint;
  268.   procedure SetAttributes( const value: longint );
  269.   function GetConnect{}: string;
  270.   procedure SetConnect( const value: string );
  271.   function GetDateCreated{}: Variant;
  272.   function GetLastUpdated{}: Variant;
  273.   function GetName{}: string;
  274.   procedure SetName( const value: string );
  275.   function GetSourceTableName{}: string;
  276.   procedure SetSourceTableName( const value: string );
  277.   function GetUpdatable{}: VariantBool;
  278.   function GetValidationText{}: string;
  279.   procedure SetValidationText( const value: string );
  280.   function GetValidationRule{}: string;
  281.   procedure SetValidationRule( const value: string );
  282.   function GetRecordCount{}: longint;
  283.   function GetFields{}: DAOFields;
  284.   function GetIndexes{}: DAOIndexes;
  285.   function GetConflictTable{}: string;
  286. public {properties}
  287.   property Attributes: longint read GetAttributes write SetAttributes;
  288.   property Connect: string read GetConnect write SetConnect;
  289.   property DateCreated: Variant read GetDateCreated;
  290.   property LastUpdated: Variant read GetLastUpdated;
  291.   property Name: string read GetName write SetName;
  292.   property SourceTableName: string read GetSourceTableName write SetSourceTableName;
  293.   property Updatable: VariantBool read GetUpdatable;
  294.   property ValidationText: string read GetValidationText write SetValidationText;
  295.   property ValidationRule: string read GetValidationRule write SetValidationRule;
  296.   property RecordCount: longint read GetRecordCount;
  297.   property Fields: DAOFields read GetFields;
  298.   property Indexes: DAOIndexes read GetIndexes;
  299.   property ConflictTable: string read GetConflictTable;
  300. public {methods}
  301.   function OpenRecordset( const typ: Variant; const options: Variant ): DAORecordset;
  302.   procedure RefreshLink{};
  303.   function CreateField( const name: Variant; const typ: Variant; const size: Variant ): DAOField;
  304.   function CreateIndex( const name: Variant ): DAOIndex;
  305.   function CreateProperty( const name: Variant; const typ: Variant; const value: Variant; const ddl: Variant ): DAOProperty;
  306. end {DAOTableDef};
  307.  
  308. {---------------------- DAOQueryDefs }
  309.  
  310. DAOQueryDefs = class(DAODynaCollection)
  311. private {access methods}
  312.   function GetItem( const idx: Variant ): DAOQueryDef;
  313. public {properties}
  314.   property Item[const idx: Variant]: DAOQueryDef read GetItem; default;
  315. public {methods}
  316. end {DAOQueryDefs};
  317.  
  318. {---------------------- DAOQueryDef }
  319.  
  320. DAOQueryDef = class(DAOBase)
  321. private {access methods}
  322.   function GetDateCreated{}: Variant;
  323.   function GetLastUpdated{}: Variant;
  324.   function GetName{}: string;
  325.   procedure SetName( const value: string );
  326.   function GetODBCTimeout{}: smallint;
  327.   procedure SetODBCTimeout( const value: smallint );
  328.   function Get_Type{}: smallint;
  329.   function GetSQL{}: string;
  330.   procedure SetSQL( const value: string );
  331.   function GetUpdatable{}: VariantBool;
  332.   function GetConnect{}: string;
  333.   procedure SetConnect( const value: string );
  334.   function GetReturnsRecords{}: VariantBool;
  335.   procedure SetReturnsRecords( const value: VariantBool );
  336.   function GetRecordsAffected{}: longint;
  337.   function GetFields{}: DAOFields;
  338.   function GetParameters{}: DAOParameters;
  339. public {properties}
  340.   property DateCreated: Variant read GetDateCreated;
  341.   property LastUpdated: Variant read GetLastUpdated;
  342.   property Name: string read GetName write SetName;
  343.   property ODBCTimeout: smallint read GetODBCTimeout write SetODBCTimeout;
  344.   property _Type: smallint read Get_Type;
  345.   property SQL: string read GetSQL write SetSQL;
  346.   property Updatable: VariantBool read GetUpdatable;
  347.   property Connect: string read GetConnect write SetConnect;
  348.   property ReturnsRecords: VariantBool read GetReturnsRecords write SetReturnsRecords;
  349.   property RecordsAffected: longint read GetRecordsAffected;
  350.   property Fields: DAOFields read GetFields;
  351.   property Parameters: DAOParameters read GetParameters;
  352. public {methods}
  353.   procedure Close{};
  354.   function OpenRecordset( const typ: Variant; const options: Variant ): DAORecordset;
  355.   function _OpenRecordset( const typ: Variant; const options: Variant ): DAORecordset;
  356.   function _Copy{}: DAOQueryDef;
  357.   procedure Execute( const options: Variant );
  358.   function Compare( const qdef: DAOQueryDef ): smallint;
  359.   function CreateDynaset( const options: Variant; const inconsistent: Variant ): DAORecordset;
  360.   function CreateSnapshot( const options: Variant ): DAORecordset;
  361.   function ListParameters{}: DAORecordset;
  362.   function CreateProperty( const name: Variant; const typ: Variant; const value: Variant; const ddl: Variant ): DAOProperty;
  363. end {DAOQueryDef};
  364.  
  365. {---------------------- DAORecordsets }
  366.  
  367. DAORecordsets = class(DAOCollection)
  368. private {access methods}
  369.   function GetItem( const idx: Variant ): DAORecordset;
  370. public {properties}
  371.   property Item[const idx: Variant]: DAORecordset read GetItem; default;
  372. public {methods}
  373. end {DAORecordsets};
  374.  
  375. {---------------------- DAORecordset }
  376.  
  377. DAORecordset = class(DAOBase)
  378. private {access methods}
  379.   function GetBOF{}: VariantBool;
  380.   function GetBookmark{}: TBookmark;
  381.   procedure SetBookmark( const value: TBookmark );
  382.   function GetBookmarkable{}: VariantBool;
  383.   function GetDateCreated{}: Variant;
  384.   function GetEOF{}: VariantBool;
  385.   function GetFilter{}: string;
  386.   procedure SetFilter( const value: string );
  387.   function GetIndex{}: string;
  388.   procedure SetIndex( const value: string );
  389.   function GetLastModified{}: TBookmark;
  390.   function GetLastUpdated{}: TBookmark;
  391.   function GetLockEdits{}: VariantBool;
  392.   procedure SetLockEdits( const value: VariantBool );
  393.   function GetName{}: string;
  394.   function GetNoMatch{}: VariantBool;
  395.   function GetSort{}: string;
  396.   procedure SetSort( const value: string );
  397.   function GetTransactions{}: VariantBool;
  398.   function Get_Type{}: smallint;
  399.   function GetRecordCount{}: longint;
  400.   function GetUpdatable{}: VariantBool;
  401.   function GetRestartable{}: VariantBool;
  402.   function GetValidationText{}: string;
  403.   function GetValidationRule{}: string;
  404.   function GetCacheStart{}: TBookmark;
  405.   procedure SetCacheStart( const value: TBookmark );
  406.   function GetCacheSize{}: longint;
  407.   procedure SetCacheSize( const value: longint );
  408.   function GetPercentPosition{}: real;
  409.   procedure SetPercentPosition( const value: real );
  410.   function GetAbsolutePosition{}: longint;
  411.   procedure SetAbsolutePosition( const value: longint );
  412.   function GetEditMode{}: smallint;
  413.   function GetODBCFetchCount{}: longint;
  414.   function GetODBCFetchDelay{}: longint;
  415.   function GetParent{}: DAODatabase;
  416.   function GetFields{}: DAOFields;
  417.   function GetIndexes{}: DAOIndexes;
  418.   function GetCollect( const idx: Variant ): Variant;
  419.   procedure SetCollect( const idx: Variant; const value: Variant );
  420. public {properties}
  421.   property BOF: VariantBool read GetBOF;
  422.   property Bookmark: TBookmark read GetBookmark write SetBookmark;
  423.   property Bookmarkable: VariantBool read GetBookmarkable;
  424.   property DateCreated: Variant read GetDateCreated;
  425.   property EOF: VariantBool read GetEOF;
  426.   property Filter: string read GetFilter write SetFilter;
  427.   property Index: string read GetIndex write SetIndex;
  428.   property LastModified: TBookmark read GetLastModified;
  429.   property LastUpdated: TBookmark read GetLastUpdated;
  430.   property LockEdits: VariantBool read GetLockEdits write SetLockEdits;
  431.   property Name: string read GetName;
  432.   property NoMatch: VariantBool read GetNoMatch;
  433.   property Sort: string read GetSort write SetSort;
  434.   property Transactions: VariantBool read GetTransactions;
  435.   property _Type: smallint read Get_Type;
  436.   property RecordCount: longint read GetRecordCount;
  437.   property Updatable: VariantBool read GetUpdatable;
  438.   property Restartable: VariantBool read GetRestartable;
  439.   property ValidationText: string read GetValidationText;
  440.   property ValidationRule: string read GetValidationRule;
  441.   property CacheStart: TBookmark read GetCacheStart write SetCacheStart;
  442.   property CacheSize: longint read GetCacheSize write SetCacheSize;
  443.   property PercentPosition: real read GetPercentPosition write SetPercentPosition;
  444.   property AbsolutePosition: longint read GetAbsolutePosition write SetAbsolutePosition;
  445.   property EditMode: smallint read GetEditMode;
  446.   property ODBCFetchCount: longint read GetODBCFetchCount;
  447.   property ODBCFetchDelay: longint read GetODBCFetchDelay;
  448.   property Parent: DAODatabase read GetParent;
  449.   property Fields: DAOFields read GetFields;
  450.   property Indexes: DAOIndexes read GetIndexes;
  451.   property Collect[const idx: Variant]: Variant read GetCollect write SetCollect;
  452. public {methods}
  453.   procedure CancelUpdate{};
  454.   procedure AddNew{};
  455.   procedure Close{};
  456.   function OpenRecordset( const typ: Variant; const options: Variant ): DAORecordset;
  457.   procedure Delete{};
  458.   procedure Edit{};
  459.   procedure FindFirst( const crit: string );
  460.   procedure FindLast( const crit: string );
  461.   procedure FindNext( const crit: string );
  462.   procedure FindPrevious( const crit: string );
  463.   procedure MoveFirst{};
  464.   procedure MoveLast{};
  465.   procedure MoveNext{};
  466.   procedure MovePrevious{};
  467.   procedure Seek13( const comp: string; const key1: Variant; const key2: Variant; const key3: Variant; const key4: Variant; const key5: Variant; const key6: Variant; const key7: Variant; const key8: Variant; const key9: Variant; const key10: Variant; const key11: Variant; const key12: Variant; const key13: Variant );
  468.   procedure Update{};
  469.   function Clone{}: DAORecordset;
  470.   procedure Requery( const newQueryDef: Variant );
  471.   procedure Move( const rows: longint; const startBookmark: Variant );
  472.   procedure FillCache( const rows: longint; const startBookmark: Variant );
  473.   function CreateDynaset( const options: Variant; const inconsistent: Variant ): DAORecordset;
  474.   function CreateSnapshot( const options: Variant ): DAORecordset;
  475.   procedure CopyQueryDef( const qdef: DAOQueryDef );
  476.   function ListFields{}: DAORecordset;
  477.   function ListIndexes{}: DAORecordset;
  478.   function GetRows( const rowCnt: Variant ): Variant;
  479.   // later additions
  480.   procedure Seek( const comp: string; const key1: Variant );
  481.   procedure Seek2( const comp: string; const key1, key2: Variant );
  482.   procedure Seek3( const comp: string; const key1, key2, key3: Variant );
  483.   procedure Seek4( const comp: string; const key1, key2, key3, key4: Variant );
  484. end {DAORecordset};
  485.  
  486. {---------------------- DAOFields }
  487.  
  488. DAOFields = class(DAODynaCollection)
  489. private {access methods}
  490.   function GetItem( const idx: Variant ): DAOField;
  491. public {properties}
  492.   property Item[const idx: Variant]: DAOField read GetItem; default;
  493. public {methods}
  494. end {DAOFields};
  495.  
  496. {---------------------- DAOField }
  497.  
  498. DAOField = class(DAOBase)
  499. private {access methods}
  500.   function GetCollatingOrder{}: longint;
  501.   function Get_Type{}: smallint;
  502.   procedure Set_Type( const value: smallint );
  503.   function GetName{}: string;
  504.   procedure SetName( const value: string );
  505.   function GetSize{}: longint;
  506.   procedure SetSize( const value: longint );
  507.   function GetSourceField{}: string;
  508.   function GetSourceTable{}: string;
  509.   function GetValue{}: Variant;
  510.   procedure SetValue( const value: Variant );
  511.   function GetAttributes{}: longint;
  512.   procedure SetAttributes( const value: longint );
  513.   function GetOrdinalPosition{}: smallint;
  514.   procedure SetOrdinalPosition( const value: smallint );
  515.   function GetValidationText{}: string;
  516.   procedure SetValidationText( const value: string );
  517.   function GetValidationOnSet{}: VariantBool;
  518.   procedure SetValidationOnSet( const value: VariantBool );
  519.   function GetValidationRule{}: string;
  520.   procedure SetValidationRule( const value: string );
  521.   function GetDefaultValue{}: string;
  522.   procedure SetDefaultValue( const value: string );
  523.   function GetRequired{}: VariantBool;
  524.   procedure SetRequired( const value: VariantBool );
  525.   function GetAllowZeroLength{}: VariantBool;
  526.   procedure SetAllowZeroLength( const value: VariantBool );
  527.   function GetDataUpdatable{}: VariantBool;
  528.   function GetForeignName{}: string;
  529.   procedure SetForeignName( const value: string );
  530.   function GetCollectionIndex{}: smallint;
  531. public {properties}
  532.   property CollatingOrder: longint read GetCollatingOrder;
  533.   property _Type: smallint read Get_Type write Set_Type;
  534.   property Name: string read GetName write SetName;
  535.   property Size: longint read GetSize write SetSize;
  536.   property SourceField: string read GetSourceField;
  537.   property SourceTable: string read GetSourceTable;
  538.   property Value: Variant read GetValue write SetValue;
  539.   property Attributes: longint read GetAttributes write SetAttributes;
  540.   property OrdinalPosition: smallint read GetOrdinalPosition write SetOrdinalPosition;
  541.   property ValidationText: string read GetValidationText write SetValidationText;
  542.   property ValidationOnSet: VariantBool read GetValidationOnSet write SetValidationOnSet;
  543.   property ValidationRule: string read GetValidationRule write SetValidationRule;
  544.   property DefaultValue: string read GetDefaultValue write SetDefaultValue;
  545.   property Required: VariantBool read GetRequired write SetRequired;
  546.   property AllowZeroLength: VariantBool read GetAllowZeroLength write SetAllowZeroLength;
  547.   property DataUpdatable: VariantBool read GetDataUpdatable;
  548.   property ForeignName: string read GetForeignName write SetForeignName;
  549.   property CollectionIndex: smallint read GetCollectionIndex;
  550. public {methods}
  551.   procedure AppendChunk( const value: Variant );
  552.   function GetChunk( const ofs: longint; const bytes: longint ): Variant;
  553.   function FieldSize{}: longint;
  554.   function CreateProperty( const name: Variant; const typ: Variant; const value: Variant; const ddl: Variant ): DAOProperty;
  555. end {DAOField};
  556.  
  557. {---------------------- DAOIndexes }
  558.  
  559. DAOIndexes = class(DAODynaCollection)
  560. private {access methods}
  561.   function GetItem( const idx: Variant ): DAOIndex;
  562. public {properties}
  563.   property Item[const idx: Variant]: DAOIndex read GetItem; default;
  564. public {methods}
  565. end {DAOIndexes};
  566.  
  567. {---------------------- DAOIndex }
  568.  
  569. DAOIndex = class(DAOBase)
  570. private {access methods}
  571.   function GetName{}: string;
  572.   procedure SetName( const value: string );
  573.   function GetForeign{}: VariantBool;
  574.   function GetUnique{}: VariantBool;
  575.   procedure SetUnique( const value: VariantBool );
  576.   function GetClustered{}: VariantBool;
  577.   procedure SetClustered( const value: VariantBool );
  578.   function GetRequired{}: VariantBool;
  579.   procedure SetRequired( const value: VariantBool );
  580.   function GetIgnoreNulls{}: VariantBool;
  581.   procedure SetIgnoreNulls( const value: VariantBool );
  582.   function GetPrimary{}: VariantBool;
  583.   procedure SetPrimary( const value: VariantBool );
  584.   function GetDistinctCount{}: longint;
  585.   function GetFields{}: DAOIndexFields;
  586.   procedure SetFieldNames( const value: Variant );
  587. public {properties}
  588.   property Name: string read GetName write SetName;
  589.   property Foreign: VariantBool read GetForeign;
  590.   property Unique: VariantBool read GetUnique write SetUnique;
  591.   property Clustered: VariantBool read GetClustered write SetClustered;
  592.   property Required: VariantBool read GetRequired write SetRequired;
  593.   property IgnoreNulls: VariantBool read GetIgnoreNulls write SetIgnoreNulls;
  594.   property Primary: VariantBool read GetPrimary write SetPrimary;
  595.   property DistinctCount: longint read GetDistinctCount;
  596.   property Fields: DAOIndexFields read GetFields;
  597.   property FieldNames: Variant write SetFieldNames;
  598. public {methods}
  599.   function CreateField( const name: Variant; const typ: Variant; const size: Variant ): DAOField;
  600.   function CreateProperty( const name: Variant; const typ: Variant; const value: Variant; const ddl: Variant ): DAOProperty;
  601. end {DAOIndex};
  602.  
  603. {---------------------- DAOIndexFields }
  604.  
  605. DAOIndexFields = class(DAODynaCollection)
  606. private {access methods}
  607.   function GetItem( const idx: Variant ): DAOField;
  608. public {properties}
  609.   property Item[const idx: Variant]: DAOField read GetItem; default;
  610. public {methods}
  611. end {DAOIndexFields};
  612.  
  613. {---------------------- DAOParameters }
  614.  
  615. DAOParameters = class(DAOCollection)
  616. private {access methods}
  617.   function GetItem( const idx: Variant ): DAOParameter;
  618. public {properties}
  619.   property Item[const idx: Variant]: DAOParameter read GetItem; default;
  620. public {methods}
  621. end {DAOParameters};
  622.  
  623. {---------------------- DAOParameter }
  624.  
  625. DAOParameter = class(DAOBase)
  626. private {access methods}
  627.   function GetName{}: string;
  628.   function GetValue{}: Variant;
  629.   procedure SetValue( const value: Variant );
  630.   function Get_Type{}: smallint;
  631. public {properties}
  632.   property Name: string read GetName;
  633.   property Value: Variant read GetValue write SetValue;
  634.   property _Type: smallint read Get_Type;
  635. public {methods}
  636. end {DAOParameter};
  637.  
  638. {---------------------- DAOUsers }
  639.  
  640. DAOUsers = class(DAODynaCollection)
  641. private {access methods}
  642.   function GetItem( const idx: Variant ): DAOUser;
  643. public {properties}
  644.   property Item[const idx: Variant]: DAOUser read GetItem; default;
  645. public {methods}
  646. end {DAOUsers};
  647.  
  648. {---------------------- DAOUser }
  649.  
  650. DAOUser = class(DAOBase)
  651. private {access methods}
  652.   function GetName{}: string;
  653.   procedure SetName( const value: string );
  654.   procedure SetPID( const value: string );
  655.   procedure SetPassword( const value: string );
  656.   function GetGroups{}: DAOGroups;
  657. public {properties}
  658.   property Name: string read GetName write SetName;
  659.   property PID: string write SetPID;
  660.   property Password: string write SetPassword;
  661.   property Groups: DAOGroups read GetGroups;
  662. public {methods}
  663.   procedure NewPassword( const old: string; const new: string );
  664.   function CreateGroup( const name: Variant; const pid: Variant ): DAOGroup;
  665. end {DAOUser};
  666.  
  667. {---------------------- DAOGroups }
  668.  
  669. DAOGroups = class(DAODynaCollection)
  670. private {access methods}
  671.   function GetItem( const idx: Variant ): DAOGroup;
  672. public {properties}
  673.   property Item[const idx: Variant]: DAOGroup read GetItem; default;
  674. public {methods}
  675. end {DAOGroups};
  676.  
  677. {---------------------- DAOGroup }
  678.  
  679. DAOGroup = class(DAOBase)
  680. private {access methods}
  681.   function GetName{}: string;
  682.   procedure SetName( const value: string );
  683.   procedure SetPID( const value: string );
  684.   function GetUsers{}: DAOUsers;
  685. public {properties}
  686.   property Name: string read GetName write SetName;
  687.   property PID: string write SetPID;
  688.   property Users: DAOUsers read GetUsers;
  689. public {methods}
  690.   function CreateUser( const name: Variant; const pid: Variant; const pwd: Variant ): DAOUser;
  691. end {DAOGroup};
  692.  
  693. {---------------------- DAORelations }
  694.  
  695. DAORelations = class(DAODynaCollection)
  696. private {access methods}
  697.   function GetItem( const idx: Variant ): DAORelation;
  698. public {properties}
  699.   property Item[const idx: Variant]: DAORelation read GetItem; default;
  700. public {methods}
  701. end {DAORelations};
  702.  
  703. {---------------------- DAORelation }
  704.  
  705. DAORelation = class(DAOBase)
  706. private {access methods}
  707.   function GetName{}: string;
  708.   procedure SetName( const value: string );
  709.   function GetTable{}: string;
  710.   procedure SetTable( const value: string );
  711.   function GetForeignTable{}: string;
  712.   procedure SetForeignTable( const value: string );
  713.   function GetAttributes{}: longint;
  714.   procedure SetAttributes( const value: longint );
  715.   function GetFields{}: DAOFields;
  716. public {properties}
  717.   property Name: string read GetName write SetName;
  718.   property Table: string read GetTable write SetTable;
  719.   property ForeignTable: string read GetForeignTable write SetForeignTable;
  720.   property Attributes: longint read GetAttributes write SetAttributes;
  721.   property Fields: DAOFields read GetFields;
  722. public {methods}
  723.   function CreateField( const name: Variant; const typ: Variant; const size: Variant ): DAOField;
  724. end {DAORelation};
  725.  
  726. {---------------------- DAOProperties }
  727.  
  728. DAOProperties = class(DAODynaCollection)
  729. private {access methods}
  730.   function GetItem( const idx: Variant ): DAOProperty;
  731. public {properties}
  732.   property Item[const idx: Variant]: DAOProperty read GetItem; default;
  733. public {methods}
  734. end {DAOProperties};
  735.  
  736. {---------------------- DAOProperty }
  737.  
  738. DAOProperty = class(DAOBase)
  739. private {access methods}
  740.   function GetValue{}: Variant;
  741.   procedure SetValue( const value: Variant );
  742.   function GetName{}: string;
  743.   procedure SetName( const value: string );
  744.   function Get_Type{}: smallint;
  745.   procedure Set_Type( const value: smallint );
  746.   function Get_Inherited{}: VariantBool;
  747. public {properties}
  748.   property Value: Variant read GetValue write SetValue;
  749.   property Name: string read GetName write SetName;
  750.   property _Type: smallint read Get_Type write Set_Type;
  751.   property _Inherited: VariantBool read Get_Inherited;
  752. public {methods}
  753. end {DAOProperty};
  754.  
  755. {---------------------- DAOContainers }
  756.  
  757. DAOContainers = class(DAOCollection)
  758. private {access methods}
  759.   function GetItem( const idx: Variant ): DAOContainer;
  760. public {properties}
  761.   property Item[const idx: Variant]: DAOContainer read GetItem; default;
  762. public {methods}
  763. end {DAOContainers};
  764.  
  765. {---------------------- DAOContainer }
  766.  
  767. DAOContainer = class(DAOBase)
  768. private {access methods}
  769.   function GetName{}: string;
  770.   function GetOwner{}: string;
  771.   procedure SetOwner( const value: string );
  772.   function GetUserName{}: string;
  773.   procedure SetUserName( const value: string );
  774.   function GetPermissions{}: longint;
  775.   procedure SetPermissions( const value: longint );
  776.   function GetInherit{}: VariantBool;
  777.   procedure SetInherit( const value: VariantBool );
  778.   function GetDocuments{}: DAODocuments;
  779.   function GetAllPermissions{}: longint;
  780. public {properties}
  781.   property Name: string read GetName;
  782.   property Owner: string read GetOwner write SetOwner;
  783.   property UserName: string read GetUserName write SetUserName;
  784.   property Permissions: longint read GetPermissions write SetPermissions;
  785.   property Inherit: VariantBool read GetInherit write SetInherit;
  786.   property Documents: DAODocuments read GetDocuments;
  787.   property AllPermissions: longint read GetAllPermissions;
  788. public {methods}
  789. end {DAOContainer};
  790.  
  791. {---------------------- DAODocuments }
  792.  
  793. DAODocuments = class(DAOCollection)
  794. private {access methods}
  795.   function GetItem( const idx: Variant ): DAODocument;
  796. public {properties}
  797.   property Item[const idx: Variant]: DAODocument read GetItem; default;
  798. public {methods}
  799. end {DAODocuments};
  800.  
  801. {---------------------- DAODocument }
  802.  
  803. DAODocument = class(DAOBase)
  804. private {access methods}
  805.   function GetName{}: string;
  806.   function GetOwner{}: string;
  807.   procedure SetOwner( const value: string );
  808.   function GetContainer{}: DAOContainer;
  809.   function GetUserName{}: string;
  810.   procedure SetUserName( const value: string );
  811.   function GetPermissions{}: longint;
  812.   procedure SetPermissions( const value: longint );
  813.   function GetDateCreated{}: Variant;
  814.   function GetLastUpdated{}: Variant;
  815.   function GetAllPermissions{}: longint;
  816. public {properties}
  817.   property Name: string read GetName;
  818.   property Owner: string read GetOwner write SetOwner;
  819.   property Container: DAOContainer read GetContainer;
  820.   property UserName: string read GetUserName write SetUserName;
  821.   property Permissions: longint read GetPermissions write SetPermissions;
  822.   property DateCreated: Variant read GetDateCreated;
  823.   property LastUpdated: Variant read GetLastUpdated;
  824.   property AllPermissions: longint read GetAllPermissions;
  825. public {methods}
  826.   function CreateProperty( var name: Variant; var typ: Variant; var value: Variant; var ddl: Variant ): DAOProperty;
  827. end {DAODocument};
  828.