Click here to Skip to main content
Click here to Skip to main content
Articles » Database » Database » Databases » Downloads
 
Add your own
alternative version

Object-Oriented database design with the DatabaseObjects library

, 31 Jan 2007
Demonstrates creating object-oriented database systems with the DatabaseObjects library.
databaseobjects_demo_net.zip
VB.NET
demo
source
Northwind
NorthwindDB
bin
Northwind.vbproj.user
AxInterop.SHDocVw.dll
DatabaseObjects.dll
Interop.SHDocVw.dll
Northwind.exe
NorthwindDatabase.dll
NorthwindDatabase.vbproj.user
Attributes
bin
Database
DatabaseObjects.vbproj.user
Misc
SQL
DatabaseObjects.dll
Data
mysql_northwind.zip
Documentation
DatabaseObjects.chm
databaseobjects_demo_vb6.zip
VB6
demo
regsvr32.exe
source
Northwind
Northwind.vbg
NorthwindDB
ControlAnchor.cls
frmMain.frm
frmMain.frx
frmOrder.frm
frmOrder.frx
frmProducts.frm
frmProducts.frx
frmProductSearch.frm
frmProductSearch.frx
frmProductSearchExtended.frm
frmProductSearchExtended.frx
frmSuppliers.frm
frmSuppliers.frx
Northwind.exe
northwind.RES
Northwind.vbp
Categories.cls
Category.cls
Data.bas
LateBoundObject.cls
NorthwindDatabase.cls
NorthwindDatabase.OBJ
NorthwindDB.dll
NorthwindDB.vbp
Order.cls
OrderDetail.cls
OrderDetails.cls
Orders.cls
Product.cls
Products.cls
ProductSearch.cls
Supplier.cls
Suppliers.cls
bin
Database.cls
DBO.vbp
GlobalDatabase.cls
GlobalDatabaseObjects.cls
IDatabaseObject.cls
IDatabaseObjects.cls
IGlobalDatabaseObjects.cls
ISQLStatement.cls
modMisc.bas
SQLAlterTable.cls
SQLAutoIncrementValue.cls
SQLCondition.cls
SQLConditionFieldCompare.cls
SQLConditionInSelect.cls
SQLConditions.cls
SQLConditionSelect.cls
SQLCreateIndex.cls
SQLCreateTable.cls
SQLDelete.cls
SQLDropIndex.cls
SQLDropTable.cls
SQLFieldValue.cls
SQLFieldValues.cls
SQLIndexExists.cls
SQLIndexField.cls
SQLIndexFields.cls
SQLInsert.cls
SQLSelect.cls
SQLSelectField.cls
SQLSelectFields.cls
SQLSelectGroupByField.cls
SQLSelectGroupByFields.cls
SQLSelectOrderByField.cls
SQLSelectOrderByFields.cls
SQLSelectTable.cls
SQLSelectTableJoin.cls
SQLSelectTableJoinCondition.cls
SQLSelectTableJoinConditions.cls
SQLSelectTableJoins.cls
SQLSelectTables.cls
SQLTableExists.cls
SQLTableField.cls
SQLTableFields.cls
SQLUpdate.cls
SQLUpdateCopyField.cls
SQLUpdateCopyFields.cls
DatabaseObjects_vb6.dll
mysql_northwind.zip
images
templates
databaseobjects_classdiagram.jpg
logo.jpg
databaseobjects_src_net.zip
DatabaseObjects.vbproj.user
DatabaseObjects.dll
databaseobjects_src_vb6.zip
Database.cls
DBO.vbp
GlobalDatabase.cls
GlobalDatabaseObjects.cls
IDatabaseObject.cls
IDatabaseObjects.cls
IGlobalDatabaseObjects.cls
ISQLStatement.cls
modMisc.bas
SQLAlterTable.cls
SQLAutoIncrementValue.cls
SQLCondition.cls
SQLConditionFieldCompare.cls
SQLConditionInSelect.cls
SQLConditions.cls
SQLConditionSelect.cls
SQLCreateIndex.cls
SQLCreateTable.cls
SQLDelete.cls
SQLDropIndex.cls
SQLDropTable.cls
SQLFieldValue.cls
SQLFieldValues.cls
SQLIndexExists.cls
SQLIndexField.cls
SQLIndexFields.cls
SQLInsert.cls
SQLSelect.cls
SQLSelectField.cls
SQLSelectFields.cls
SQLSelectGroupByField.cls
SQLSelectGroupByFields.cls
SQLSelectOrderByField.cls
SQLSelectOrderByFields.cls
SQLSelectTable.cls
SQLSelectTableJoin.cls
SQLSelectTableJoinCondition.cls
SQLSelectTableJoinConditions.cls
SQLSelectTableJoins.cls
SQLSelectTables.cls
SQLTableExists.cls
SQLTableField.cls
SQLTableFields.cls
SQLUpdate.cls
SQLUpdateCopyField.cls
SQLUpdateCopyFields.cls
DatabaseObjects_vb6.dll
<?xml version="1.0" encoding="us-ascii"?>
<doc>
  <assembly>
    <name>DatabaseObjects</name>
    <version>1.2.0.0</version>
    <fullname>DatabaseObjects, Version=1.2.0.0, Culture=neutral, PublicKeyToken=null</fullname>
  </assembly>
  <members>
    <member name="M:DatabaseObjects.FieldMappingAttribute.#ctor(System.String)">
      <param name="strFieldName">
 The name of the database field associated with this property or field. 
 </param>
    </member>
    <member name="T:DatabaseObjects.Database">
      <summary>
 Represents a database connection and provides a set of functions that work 
 in conjunction with classes implementing IDatabaseObjects and IDatabaseObject. 
 The Database class automatically generates and executes the required SQL 
 statements to perform common database operations such as saving, deleting 
 searching etc. based on the values returned via the IDatabaseObjects and 
 IDatabaseObject interfaces. 
 Typically, this class is only used when explicitly implementing the IDatabaseObjects 
 and IDatabaseObject interfaces rather than inheriting from DatabaseObjects (or 
 DatabaseObjectsEnumerable) and DatabaseObject. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.Database.#ctor(System.String,DatabaseObjects.Database.ConnectionType)">
      <summary>
 Creates a new Database instance specifying the database to connect to and SQL 
 syntax to use with the database. Each function call of the Database class opens 
 and closes a connection. Therefore, connection pooling should be enabled 
 for optimal performance. 
 </summary>
 
 <param name="strConnectionString">
 A database connection string to either a Microsoft Access, SQLServer, or MySQL 
 database. For example, 'Provider=Microsoft.Jet.OLEDB.4.0;Data 
 Source=northwind.mdb;Jet OLEDB:Database Password=;'. 
 </param>
 
 <param name="eConnectionType">
 Indicates the SQL syntax to generate for the database specified in strConnectionString. 
 </param></member>
    <member name="M:DatabaseObjects.Database.Object(DatabaseObjects.IDatabaseObjects,System.Object)">
      <summary>
 Returns an instance of an object from the collection using a distinct value (see 
 IDatabaseObjects.DistinctFieldName). If the collection has implemented the 
 IDatabaseObjects.Subset function then the objDistinctValue need only be unique 
 within the collection's subset, not the entire database table. 
 </summary>
 
 <param name="objCollection">
 The collection that contains the object. 
 </param>
 
 <param name="objDistinctValue">
 The value that uniquely identifies the object within the collection. This is the value 
 of the field defined by the collection's IDatabaseObjects.DistinctFieldName function. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example> Loads a product using a product ID of 123 
 <code>
 objProduct = objDatabase.Object(NorthwindDB.Products, 123) 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectSave(DatabaseObjects.IDatabaseObjects,DatabaseObjects.IDatabaseObject)">
      <summary>
 Extracts the fields to save to the database from the objItem.SaveFields function. 
 The fields are then written to the database using either an SQL INSERT or UPDATE 
 depending on whether the object has already been saved. If the collection has 
 implemented IDatabaseObjects.KeyFieldName then objItem's key is also validated to 
 ensure it is not null and unique within the collection. If objCollection has 
 implemented IDatabaseObjects.Subset then objItem should exist within objCollection. 
 If not, a duplicate key error may occur if the obItem's key is being used in 
 another subset in the same table. If a record is being amended 
 (IDatabaseObject.IsSaved returns true) then the function will "AND" the collection's 
 IDatabaseObjects.Subset conditions and the objItem's IDatabaseObject.DistinctValue 
 value to create the WHERE clause in the UPDATE statement. Therefore, the 
 combination of the IDatabaseObjects.Subset and IDatabaseObject.DistinctValue 
 conditions MUST identify only one record in the table. Otherwise multiple records 
 will be updated with the same data. If data is only inserted and not amended 
 (usually a rare occurance) then this requirement is unnecessary. 
 </summary>
 
 <param name="objCollection">
 The collection which contains or will contain the object to save. 
 </param>
 
 <param name="objItem">
 The object to save to the database. The values saved to the database are extracted from the 
 SQLFieldValues object returned from IDatabaseObject.SaveFields. 
 </param>
 
 <example> Saves a product object (Me) to the database. 
 <code>
 Public Sub Save() 
 
     objDatabase.ObjectSave(NorthwindDB.Products, Me) 
 
 End Sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectByKey(DatabaseObjects.IDatabaseObjects,System.Object)">
      <summary>
 Returns an object from the collection using a unique key value. 
 The key must be unique within the collection. If the collection's 
 IDatabaseObjects.Subset has been implemented then the key need only be unique 
 within the subset specified, not the entire database table. 
 </summary>
 
 <param name="objCollection">
 The collection which contains the object. 
 </param>
 
 <param name="objKey">
 The key that identifies the object with the collection. The key is the value of 
 the field defined by the collection's IDatabaseObjects.KeyFieldName. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example>
 <code>
 Default Public ReadOnly Property Item(ByVal strProductCode As String) As Product 
     Get 
 
         Return objDatabase.ObjectByKey(Me, strProductCode) 
 
     End Get 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectByOrdinalFirst(DatabaseObjects.IDatabaseObjects)">
      <summary>
 ObjectByOrdinalFirst returns the first object in the collection respectively 
 filtered and sorted by the collection's IDatabaseObjects.Subset and 
 IDatabaseObjects.OrderBy values. It differs from ObjectByOrdinal in that it only 
 loads the first record from the database table not the entire table. 
 </summary>
 
 <param name="objCollection">
 The collection which contains the object. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example>
 <code>
 'Ideal for loading default objects 
 Dim objDefaultSupplier As Supplier = objDatabase.ObjectByOrdinalFirst(objGlobalSuppliersInstance) 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectByOrdinal(DatabaseObjects.IDatabaseObjects,System.Int32)">
      <summary>
 ObjectByOrdinal returns an object from the collection at a specific ordinal 
 position. The ordinal position is related to the collection's 
 IDatabaseObjects.Subset and IDatabaseObjects.OrderBy values. 
 Typically, this function is used to enumerate through a collection of objects. 
 ObjectByOrdinal will load the collection's entire recordset on the first call 
 and on subsequent calls the preloaded objects are returned. 
 Avoid making alternate calls to ObjectByOrdinal for different tables, as the 
 entire recordset will be reloaded on each call. 
 To load the first object in a table without loading the entire table, use the 
 ObjectByOrdinalFirst function. 
 </summary>
 
 <param name="objCollection">
 The collection that contains the object at the specified ordinal position. 
 </param>
 
 <param name="intIndex">
 The ordinal position of the object. The ordinal position depends on the collection's 
 IDatabaseObjects.Subset and IDatabaseObjects.OrderBy values 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example>
 <code>
 Default Public ReadOnly Property Item(ByVal intIndex As Integer) As Product 
     Get 
 
         Return objDatabase.ObjectByOrdinal(Me, intIndex) 
 
     End Get 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectsCount(DatabaseObjects.IDatabaseObjects)">
      <summary>
 Returns the number of items in the collection. If the collection's 
 IDatabaseObjects.Subset has been implemented then this function returns the 
 number of records within the subset, not the entire table. 
 </summary>
 
 <param name="objCollection">
 The object for which the number of records are returned. 
 </param>
 
 <returns><see cref="Int32" />	(System.Int32)</returns>
 
 <example>
 <code>
 'Return the number of items in this collection. 
 Public ReadOnly Property Count() As Integer 
     Get 
 
         Return objDatabase.ObjectsCount(Me) 
 
     End Get 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectExists(DatabaseObjects.IDatabaseObjects,System.Object)">
      <summary>
 Returns whether the key exists within the collection. If the collection's 
 IDatabaseObjects.Subset has been set then only the subset is searched not the 
 entire table. 
 </summary>
 
 <param name="objCollection">
 The collection to search within. 
 </param>
 
 <param name="objKey">
 The key value to search by. 
 </param>
 
 <returns><see cref="Boolean" />	(System.Boolean)</returns>
 
 <example>
 <code>
 Public Function Exists(ByVal strProductCode As String) As Boolean 
 
     Return objDatabase.ObjectExists(Me, strProductCode) 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectDelete(DatabaseObjects.IDatabaseObjects,DatabaseObjects.IDatabaseObject@)">
      <summary>
 Deletes an object's database record. If the collection's IDatabaseObjects.Subset 
 has been implemented then the object must exist within the subset, otherwise the 
 object will not be deleted. If the object has not been saved to the database the 
 function will exit without executing an SQL DELETE command. After deleting the 
 database record the object is set to Nothing. The calling function should receive 
 the object ByRef for this to have any affect. Setting the object to Nothing 
 minimises the possibility of the deleted object being used in code after 
 ObjectDelete has been called. 
 </summary>
 
 <param name="objCollection">
 The collection that contains the object to delete. If the item does not exist 
 within the collection then the object will not be deleted. 
 </param>
 
 <param name="objItem">
 The object to delete. The calling function should receive this object ByRef 
 as the object is set to Nothing after deletion. 
 Reference Type: <see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject) 
 </param>
 
 <example>
 <code>
 Public Sub Delete(ByRef objProduct As Product) 
 
     objDatabase.ObjectDelete(Me, objProduct) 
     'objProduct will now be Nothing 
 
 End Sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectsDeleteAll(DatabaseObjects.IDatabaseObjects)">
      <summary>
 Deletes all of the objects in the collection. If IDatabaseObjects.Subset 
 has been implemented then only the objects within the subset are deleted, not 
 the table's entire contents. 
 </summary>
 
 <param name="objCollection">
 The collection from which all objects are to be deleted. 
 </param></member>
    <member name="M:DatabaseObjects.Database.ObjectsList(DatabaseObjects.IDatabaseObjects)">
      <summary>
 Returns an IList object containing all of the collection's associated child 
 objects. This function is useful when loading a set of objects for a subset or 
 for use with the IEnumerable interface. 
 </summary>
 
 <param name="objCollection">
 The collection which contains the objects to load. 
 </param>
 
 <returns><see cref="Collections.IList" />	(System.Collections.IList)</returns>
 
 <example>
 <code>
 'Can be used to provide an enumerator for use with the "For Each" clause 
 Private Function GetEnumerator() As System.Collections.IEnumerator Implements System.Collections.IEnumerable.GetEnumerator 
 
     Return objDatabase.ObjectsList(objGlobalProductsInstance).GetEnumerator 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectsDictionary(DatabaseObjects.IDatabaseObjects)">
      <summary>
 Returns an IDictionary object. Each key/value pair contains a key and 
 the object associated with the key. 
 </summary>
 
 <param name="objCollection">
 The collection which specifies the objects to load. 
 </param>
 
 <returns><see cref="Collections.IDictionary" />	(System.Collections.IDictionary)</returns></member>
    <member name="M:DatabaseObjects.Database.ObjectsDictionaryByDistinctValue(DatabaseObjects.IDatabaseObjects)">
      <summary>
 Returns an IDictionary object. Each key/value pair contains a distinct 
 value and the object associated with the distinct value. 
 </summary>
 
 <param name="objCollection">
 The collection which specifies the objects to load. 
 </param>
 
 <returns><see cref="Collections.IDictionary" />	(System.Collections.IDictionary)</returns></member>
    <member name="M:DatabaseObjects.Database.ObjectsSearch(DatabaseObjects.IDatabaseObjects,DatabaseObjects.SQL.SQLConditions)">
      <summary>
 Returns a collection of objects that match the specified search criteria. 
 This function utilises any subsets, ordering or table joins specified in the 
 collection. To add a set of conditions to the objSearchCriteria object with 
 higher precendance use the "Add(SQLConditions)" overloaded function as this will 
 wrap the conditions within parentheses. 
 </summary>
 
 <param name="objCollection">
 The collection to search within. 
 </param>
 
 <param name="objSearchCriteria">
 The criteria to search for within the collection. To add a set of conditions with 
 with higher precendance use the "Add(SQLConditions)" overloaded function as this 
 will wrap the conditions within parentheses. 
 </param>
 
 <returns><see cref="Collections.IList" />	(System.Collections.IList)</returns>
 
 <remarks>
 The following wildcard characters are used when using the LIKE operator (extract 
 from Microsoft Transact-SQL Reference) 
 
 
 <font size="1">
 <table width="659" border="1" cellspacing="1" cellpadding="4">
   <tr>
     <th width="16%" height="20">Wildcard character</th>
     <th width="22%">Description</th>
     <th width="62%">Example</th>
   </tr>
   <tr>
     <td>%</td>
     <td>Any string of zero or more characters.</td>
     <td>WHERE title LIKE '%computer%' finds all book titles with the word 
         'computer' anywhere in the book title.</td>
   </tr>
   <tr>
     <td>_ (underscore)</td>
     <td>Any single character.</td>
     <td>WHERE au_fname LIKE '_ean' finds all four-letter first names that end 
       with ean (Dean, Sean, and so on).</td>
   </tr>
 </table>
 </font>
 </remarks>
 
 <example>
 <code>
 Public Function Search(ByVal objSearchCriteria As Object, ByVal eType As SearchType) As IList 
 
     Dim objConditions As SQL.SQLConditions = New SQL.SQLConditions 
 
     Select Case eType 
         Case SearchType.DescriptionPrefix 
             objConditions.Add("ProductName", SQL.ComparisonOperator.Like, objSearchCriteria &amp; "%") 
         Case SearchType.Description 
             objConditions.Add("ProductName", SQL.ComparisonOperator.Like, "%" &amp; objSearchCriteria &amp; "%") 
     End Select 
 
     Return objDatabase.ObjectsSearch(objGlobalProductsInstance, objConditions) 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.ObjectFromDataReader(DatabaseObjects.IDatabaseObjects,System.Data.IDataReader)">
      <summary>
 Loads an object from the current record of an IDataReader object. 
 </summary>
 
 <param name="objCollection">
 The collection associated with the IDataReader object. 
 </param>
 
 <param name="objReader">
 The data to be copied into a new IDatabaseObject object. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns></member>
    <member name="M:DatabaseObjects.Database.ObjectFromFieldValues(DatabaseObjects.IDatabaseObjects,DatabaseObjects.SQL.SQLFieldValues)">
      <summary>
 Loads an object from the values contained in an SQLFieldValues object. 
 This function is generally used from within an IDatabaseObject.Load function when 
 the IDatabaseObjects.TableJoins function has been implemented. 
 </summary>
 
 <param name="objCollection">
 The collection associated with the field values. 
 </param>
 
 <param name="objFieldValues">
 The data container from which to load a new object. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns></member>
    <member name="T:DatabaseObjects.Database.TransactionsClass">
      <summary>
 Provides a mechanism for starting beginning, commiting and rolling back transactions. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.Database.TransactionsClass.Begin">
      <summary>
 Notifies that a transaction has begun and that all modifications to the database 
 are only committed after a call to Commit. Alternatively, if 
 Rollback is called then all changes are aborted. To execute other 
 statements for the transaction call the Execute and ExecuteNonQuery functions. 
 Because all changes to the database must be executed on the same connection 
 DatabaseObjects maintains an open connection until the Commit or Rollback functions 
 are called. When transactions are not being used connections are opened and closed 
 for each SQL statement executed i.e. (INSERT/UPDATE/SELECT...). 
 </summary>
 
 <example>
 <code>
 Public Sub Shadows Save() 
 
     Mybase.ParentDatabase.Transactions.Begin() 
 
     MyBase.Save 
     Me.Details.Save 
 
     'Execute any other statements here via 
     'MyBase.ParentDatabase.Transactions.Execute()... 
 
     Mybase.ParentDatabase.Transactions.Commit() 
 
 End sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.TransactionsClass.Commit">
      <summary>
 Commits all statements that have been executed after the Begin() call. 
 The database connection is closed after the transaction has been committed. 
 </summary>
 
 <example>
 <code>
 Public Sub Shadows Save() 
 
     Mybase.ParentDatabase.Transactions.Begin() 
 
     MyBase.Save 
     Me.Details.Save 
 
     'Execute any other statements here via 
     'MyBase.ParentDatabase.Transactions.Execute()... 
 
     Mybase.ParentDatabase.Transactions.Commit() 
 
 End sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.Database.TransactionsClass.Rollback">
      <summary>
 Rollsback all statements that have been executed after the Begin() call. 
 The database connection is closed after the transaction has been rolled back. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.Database.TransactionsClass.ExecuteNonQuery(DatabaseObjects.SQL.ISQLStatement)">
      <summary>
 Allows an SQL statement to be executed on the current transaction connection. 
 If a transaction is not in progress and exception will occur. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.Database.TransactionsClass.Execute(DatabaseObjects.SQL.ISQLStatement)">
      <summary>
 Allows an SQL statement to be executed on the current transaction connection. 
 If a transaction is not in progress and exception will occur. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.DatabaseObject">
      <summary>
 This class can be used in conjunction with the DatabaseObjects class to simplify 
 the process of using the DatabaseObjects library. This class implements the 
 IDatabaseObject interface and provides the basic "plumbing" code required by the 
 interface. For this reason, inheriting from this class is preferable to 
 implementing the IDatabaseObject interface directly. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObject.#ctor(DatabaseObjects.DatabaseObjects)">
      <summary>
 Initializes a new DatabaseObject with the parent collection that this object is 
 associated with. 
 </summary>
 
 <example>
 <code>
 'Code from a class that has inherited from DatabaseObjects 
 'So that this object has a reference to the parent 
 Protected Overrides Function ItemInstance() As DatabaseObjects.IDatabaseObject 
 
     Return New Product(Me) 
 
 End Function 
 </code>
 </example></member>
    <member name="P:DatabaseObjects.DatabaseObject.ParentCollection">
      <summary>
 Returns the parent collection (DatabaseObjects instance) that this object is 
 associated with. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObject.ParentDatabase">
      <summary>
 Returns the database associated with this object. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObject.Save">
      <summary>
 Extracts the fields to save to the database from the objItem.SaveFields function. 
 The fields are then written to the database using either an SQL INSERT or UPDATE 
 depending on whether the object has already been saved. If the collection has 
 implemented IDatabaseObjects.KeyFieldName then objItem's key is also validated to 
 ensure it is not null and unique within the collection. 
 If the parent collection has implemented Subset then this object should exist 
 within the parent collection. If not, a duplicate key error may occur if the key 
 is being used in another subset in the same table. If a record is being amended 
 (MyBase.IsSaved is True) then the function will "AND" the parent collection's 
 Subset conditions and the DistinctValue value to create the WHERE clause in the 
 UPDATE statement. Therefore, the combination of the IDatabaseObjects.Subset and 
 IDatabaseObject.DistinctValue conditions MUST identify only one record in the 
 table. Otherwise multiple records will be updated with the same data. If data is 
 only inserted and not amended (usually a rare occurance) then this requirement 
 is unnecessary. 
 </summary>
 
 <example>
 <code>
 'Make the inherited "Protected Sub Save" public 
 Public Overrides Sub Save() 
 
     MyBase.Save() 
 
 End Sub 
 </code>
 </example></member>
    <member name="P:DatabaseObjects.DatabaseObject.DistinctValue">
      <summary>
 Returns the distinct value that uniquely identifies this object in the 
 database. If a new object is saved or an existing object is loaded then this 
 property is automatically set by the library. 
 Typically, this is the value of an identity or auto increment database field. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObject.IsSaved">
      <summary>
 Returns whether this object has been saved to the database. If a new object is 
 saved (which uses an auto increment field) or an existing object is loaded then 
 this property is automatically set to true by the library. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObject.LoadFields(DatabaseObjects.SQL.SQLFieldValues)">
      <summary>
 Should copy the database fields from objFields to this object's variables. 
 objFields is populated with all of the fields from the associated record. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Sub LoadFields(ByVal objFields As DatabaseObjects.SQL.SQLFieldValues) 
 
     pstrCode = objFields("ProductCode").Value 
     pstrDescription = objFields("ProductDescription").Value 
 
 End Sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObject.SaveFields">
      <summary>
 Should return an SQLFieldValues object populated with the 
 fields to be written to the database. The first argument of the 
 SQLFieldValues.Add function is the database field name, the second is the 
 field's value. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function SaveFields() As DatabaseObjects.SQL.SQLFieldValues 
 
     SaveFields = New SQL.SQLFieldValues 
     SaveFields.Add("ProductCode", pstrCode) 
     SaveFields.Add("ProductDescription", pstrDescription) 
 
 End Function 
 </code>
 </example></member>
    <member name="T:DatabaseObjects.DatabaseObjectLockable">
      <summary>
 Extends the capabilities of the DatabaseObject by providing a set of routines 
 that lock and unlock this object for exclusive access for a particular user. 
 When Lock() is called a record is written to the lock table which includes the 
 object's associated table name, the object's distinct value and the user ID 
 specified in the DatabaseObjectLockController. When Unlock() is called this 
 record is deleted. If another or the current user has locked the object then the 
 IsLocked property will return true. 
 The DatabseObjects library does not inhibit the loading and/or saving of any 
 locked objects. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectLockable.#ctor(DatabaseObjects.DatabaseObjects,DatabaseObjects.DatabaseObjectLockController)">
      <summary>
 Initializes a new DatabaseObject with the parent collection that this object is 
 associated with and the lock controller to be used with this object. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectLockable.IsLocked">
      <summary>
 Indicates whether the current object is Locked either by the current user or 
 another user. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectLockable.LockedByUserID">
      <summary>
 Returns the user identifier that currently has the object locked. Throws an 
 exception if the object is not locked by a user. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectLockable.Lock">
      <summary>
 Locks the current object. Throws an exception if the object is already locked. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectLockable.UnLock">
      <summary>
 UnLocks the current object. Throws an exception if the object is not locked. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectLockable.IsLockedByCurrentUser">
      <summary>
 Returns whether the current user has the object locked. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.DatabaseObjectLockController">
      <summary>
 This is the controller class that initializes the lock table and the user 
 ID that is to be associated with all locking operations. In most situations, 
 only one instance of this class is ever created and this instance is passed into 
 the constructor for all DatabaseObjectLockable and DatabaseObjectUsingAttributesLockable 
 instances. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectLockController.UnlockAll">
      <summary>
 Provides a means by which to ensure all locks have been removed for this user 
 in situations where an unexpected exception occurs and/or the user logs out of 
 system. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.DatabaseObjects">
      <summary>
 This class can be used in conjunction with the DatabaseObject class to simplify 
 the process of using the DatabaseObjects library. This class implements the 
 IDatabaseObjects interface and provides the basic "plumbing" code required by 
 the interface. For this reason, inheriting from this class is preferable to 
 implementing the IDatabaseObjects interface directly. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjects.#ctor(DatabaseObjects.Database)">
      <summary>
 Initializes a new DatabaseObjects with it's associated database. 
 </summary>
 
 <param name="objDatabase">
 The database that this collection is associated with. 
 </param></member>
    <member name="M:DatabaseObjects.DatabaseObjects.Object(System.Object)">
      <summary>
 Returns an instance of an object from this collection using a distinct value as 
 specified by DistinctFieldName. If Subset has been implemented then the objDistinctValue 
 need only be unique within the subset specified, not the entire database table. 
 </summary>
 
 <param name="objDistinctValue">
 The value that uniquely identifies the object within this collection. This is the value 
 of the field defined by this collection's DistinctFieldName function. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example> Loads a product using a product ID of 123 
 <code>
 Dim objProduct As Product = MyBase.Object(123) 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectByKey(System.Object)">
      <summary>
 Returns an object using a unique key value. 
 The key must be unique within this collection. If the collection's DatabaseObjects.Subset 
 has been implemented then the key need only be unique within the subset specified, not the 
 entire database table. 
 </summary>
 
 <param name="objKey">
 The key that identifies the object with this collection. The key is the value of the field 
 defined by this collection's KeyFieldName. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example>
 <code>
 Default Public ReadOnly Property Item(ByVal strProductCode As String) As Product 
     Get 
 
         Return MyBase.ObjectByKey(strProductCode) 
 
     End Get 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectByOrdinal(System.Int32)">
      <summary>
 Returns an object from this collection at a specific ordinal/index position. 
 The ordinal position is related to this collection' Subset and OrderBy values. 
 Typically, this function is used to enumerate through a collection of objects. 
 ObjectByOrdinal will load the collection's entire recordset on the first call 
 and on subsequent calls the preloaded objects are returned. 
 Avoid making alternate calls to ObjectByOrdinal for different tables, as the 
 entire recordset will be reloaded on each call. 
 To load the first object in a table without loading the entire table, use the 
 ObjectByOrdinalFirst function. 
 </summary>
 
 <param name="intIndex">
 The ordinal position of the object. The ordinal position depends on this collection's 
 Subset and OrderBy values 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example>
 <code>
 Default Public ReadOnly Property Item(ByVal intIndex As Integer) As Product 
     Get 
 
         Return MyBase.ObjectByOrdinal(intIndex) 
 
     End Get 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectByOrdinalFirst">
      <summary>
 ObjectByOrdinalFirst returns the first object in the collection respectively 
 filtered and sorted by the collection's Subset and OrderBy values. It differs 
 from ObjectByOrdinal in that it only loads the first record from the database 
 table not the entire table. 
 </summary>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns>
 
 <example>
 <code>
 'Assuming this class is the Suppliers class 
 
 'Ideal for loading default objects 
 Dim objDefaultSupplier As Supplier = MyBase.ObjectByOrdinalFirst 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectDelete(DatabaseObjects.IDatabaseObject@)">
      <summary>
 Deletes an object's database record. If this collection's Subset has been 
 implemented then the object must exist within the subset, otherwise the object 
 will not be deleted. If the object has not been saved to the database the function 
 will exit without executing an SQL DELETE command. After deleting the database 
 record the object is set to Nothing. The calling function should receive the 
 object ByRef for this to have any affect. Setting the object to Nothing 
 minimises the possibility of the deleted object being used in code after 
 ObjectDelete has been called. 
 </summary>
 
 <param name="objItem">
 The object to delete. The calling function should receive this object ByRef 
 as the object is set to Nothing after deletion. 
 </param>
 
 <example>
 <code>
 Public Sub Delete(ByRef objProduct As Product) 
 
     MyBase.ObjectDelete(objProduct) 
 
 End Sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectExists(System.Object)">
      <summary>
 Returns whether the key exists within the collection. If this collection's Subset 
 has been set then only the subset is searched not the entire table. 
 </summary>
 
 <param name="objKey">
 The key value to search by. 
 </param>
 
 <returns><see cref="Boolean" />	(System.Boolean)</returns>
 
 <example>
 <code>
 Public Function Exists(ByVal strProductCode As String) As Boolean 
 
     Return MyBase.ObjectExists(strProductCode) 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectFromDataReader(System.Data.IDataReader)">
      <summary>
 Loads an object from the current record of an IDataReader object. 
 </summary>
 
 <param name="objReader">
 The data to be copied into a new DatabaseObject object. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectFromFieldValues(DatabaseObjects.SQL.SQLFieldValues)">
      <summary>
 Loads an object from the values contained in an SQLFieldValues object. 
 This function is generally used from within an DatabaseObject.Load function when 
 the TableJoins function has been implemented. 
 </summary>
 
 <param name="objFieldValues">
 The data container from which to load a new object. 
 </param>
 
 <returns><see cref="IDatabaseObject" />	(DatabaseObjects.IDatabaseObject)</returns></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectsList">
      <summary>
 Returns an IList object containing all of this collection's objects. This 
 function is useful when loading a set of objects for a subset or for use with 
 the IEnumerable interface. 
 </summary>
 
 <returns><see cref="Collections.IList" />	(System.Collections.IList)</returns>
 
 <example>
 <code>
 'Alternatively, the DatabaseObjectsEnumerable class can be used which 
 'automatically incorporates an enumerator 
 Private Function GetEnumerator() As System.Collections.IEnumerator Implements System.Collections.IEnumerable.GetEnumerator 
 
     Return MyBase.ObjectsList.GetEnumerator 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectsDictionary">
      <summary>
 Returns an IDictionary object. Each key/value pair contains a key and 
 the object associated with the key. 
 </summary>
 
 <returns><see cref="Collections.IDictionary" />	(System.Collections.IDictionary)</returns></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectsDictionaryByDistinctValue">
      <summary>
 Returns an IDictionary object. Each key/value pair contains a distinct 
 value and the object associated with the distinct value. 
 </summary>
 
 <returns><see cref="Collections.IDictionary" />	(System.Collections.IDictionary)</returns></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectsCount">
      <summary>
 Returns the number of items in this collection. If this collection's Subset 
 has been implemented then this function returns the number of records within the 
 subset, not the entire table. 
 </summary>
 
 <returns><see cref="Int32" />	(System.Int32)</returns>
 
 <example>
 <code>
 'Return the number of items in this collection. 
 Public ReadOnly Property Count() As Integer 
     Get 
 
         Return MyBase.ObjectsCount 
 
     End Get 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectsDeleteAll">
      <summary>
 Deletes all of the objects in this collection. If Subset has been implemented 
 then only the objects within the subset are deleted, not the table's entire 
 contents. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjects.ObjectsSearch(DatabaseObjects.SQL.SQLConditions)">
      <summary>
 Returns a collection of objects that match the specified search criteria. 
 This function utilises any subsets, ordering or table joins specified in this 
 collection. To add a set of conditions to the objSearchCriteria object with 
 higher precendance use the "Add(SQLConditions)" overloaded as this will wrap 
 the conditions within parentheses. 
 </summary>
 
 <param name="objSearchCriteria">
 The criteria to search for within this collection. To add set a of conditions with 
 with higher precendance use the "Add(SQLConditions)" overloaded function as this 
 will wrap the conditions within parentheses. 
 </param>
 
 <returns><see cref="Collections.IList" />	(System.Collections.IList)</returns>
 
 <remarks>
 The following wildcard characters are used when using the LIKE operator (extract 
 from Microsoft Transact-SQL Reference): 
 
 <table width="659" border="1" cellspacing="1" cellpadding="4">
   <tr>
     <th width="16%" height="20">Wildcard character</th>
     <th width="22%">Description</th>
     <th width="62%">Example</th>
   </tr>
   <tr>
     <td>%</td>
     <td>Any string of zero or more characters.</td>
     <td>WHERE title LIKE '%computer%' finds all book titles with the word 
         'computer' anywhere in the book title.</td>
   </tr>
   <tr>
     <td>_ (underscore)</td>
     <td>Any single character.</td>
     <td>WHERE au_fname LIKE '_ean' finds all four-letter first names that end 
       with ean (Dean, Sean, and so on).</td>
   </tr>
 </table>
 </remarks>
 
 <example>
 <code>
 Public Function Search(ByVal objSearchCriteria As Object, ByVal eType As SearchType) As IList 
 
     Dim objConditions As SQL.SQLConditions = New SQL.SQLConditions 
 
     Select Case eType 
         Case SearchType.DescriptionPrefix 
             objConditions.Add("ProductName", SQL.ComparisonOperator.Like, objSearchCriteria &amp; "%") 
         Case SearchType.Description 
             objConditions.Add("ProductName", SQL.ComparisonOperator.Like, "%" &amp; objSearchCriteria &amp; "%") 
     End Select 
 
     Return MyBase.ObjectsSearch(objConditions) 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.DistinctFieldAutoIncrements">
      <summary>
 Should return whether the Distinct field as specified in the 
 associated collection's DatabaseObject.DistinctField is an identity (SQL Server) 
 or auto number (Microsoft Access) field. If set to true, then the 
 DatabaseObject.DistinctValue value is set when a new object is saved. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function DistinctFieldAutoIncrements() As Boolean 
 
     Return True 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.DistinctFieldName">
      <summary>
 Should return the field name that uniquely identifies each object 
 within the collection. Typically, this is the field name of an identity or auto 
 increment field. If the DatabaseObjects.SubSet function has been implemented 
 then the DistinctFieldName need only be unique within the subset not the 
 entire table. The DistinctFieldName and KeyFieldName can be identical. This 
 function should almost always be implemented. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function DistinctFieldName() As String 
 
     Return "ProductID" 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.ItemInstance">
      <summary>
 Should return an instance of the class that is associated with this 
 collection of objects. The associated class must implement the IDatabaseObject 
 interface. Typically, a DatabaseObject (implements IDatabaseObject) instance is 
 returned from this function. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function ItemInstance() As IDatabaseObject 
 
     Return New Product 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.KeyFieldName">
      <summary>
 This property should return the field name that uniquely identifies each object 
 within the collection. As opposed to the ordinal/index position, the key field 
 provides another method of accessing a particular object within the collection. 
 The key field must be unique within the collection. If the DatabaseObjects.Subset 
 function has been implemented then the key field only needs to be unique within 
 the specified subset, not the entire table. Implementing this function is optional. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function KeyFieldName() As String 
 
     Return "ProductCode" 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.OrderBy">
      <summary>
 Should return an SQLSelectOrderByFields object containing the list 
 of fields the collection will be sorted by. Just as with an SQL statement, the 
 order of the fields added to the collection indicates the group sorting. If 
 DatabaseObjects.TableJoins has been implemented then fields from the adjoining 
 table or tables can be utilized. The sort order is used by the ObjectByOrdinal, 
 ObjectByOrdinalFirst and ObjectsSearch functions. Implementing this function is 
 optional. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function OrderBy() As SQL.SQLSelectOrderByFields 
 
     OrderBy = New SQL.SQLSelectOrderByFields 
     OrderBy.Add("ProductCode", SQL.OrderBy.Ascending) 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.Subset">
      <summary>
 Should return the conditions that define the collection's subset. 
 If the collection should include the entire table then this function should be 
 left blank. Implementing this function is optional. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function Subset() As SQL.SQLConditions 
 
     Dim objConditions As New SQL.SQLConditions 
 
     'Only include products that are in group ID 1234 
     objConditions.Add("GroupID", SQL.ComparisonOperator.EqualTo, 1234) 
 
     Return objConditions 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.TableJoins(DatabaseObjects.SQL.SQLSelectTable,DatabaseObjects.SQL.SQLSelectTables)">
      <summary>
 Should return an SQLSelectTableJoins object containing the table 
 or tables to be joined to the primary table. This function is useful in 
 optimising database loading speeds by allowing multiple tables to be joined into 
 one data set. The resultant data set can then be used to load 
 objects from the associated tables avoiding subsequent SQL calls. For a complete 
 example, see the demonstration program. Implementing this function is optional. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function TableJoins(ByVal objPrimaryTable As SQL.SQLSelectTable, ByVal objTables As SQL.SQLSelectTables) As SQL.SQLSelectTableJoins 
 
     'Implementing this function is optional, but is useful when attempting to optimise loading speeds. 
     'This function is used by the ObjectsList, Object, ObjectByKey, ObjectOrdinal and ObjectSearch functions. 
     'If this function has been implemented Search can also search fields in the joined table(s). 
     'In this example, the Products table will always be joined with the Supplier table. We could also join the Products 
     'table to the Category table, however the Product.Category property is not used often enough to warrant 
     'always joining the category table whenever loading a product. Of course, you can always join different 
     'tables in different situations, for example you might want join to other tables when searching and to 
     'not join other tables in normal circumstances. 
 
     Dim objTableJoins As SQL.SQLSelectTableJoins = New SQL.SQLSelectTableJoins 
 
     With objTableJoins.Add(objPrimaryTable, SQL.SQLSelectTableJoin.Type.Inner, objTables.Add("Suppliers")) 
         .Where.Add("SupplierID", SQL.ComparisonOperator.EqualTo, "SupplierID") 
     End With 
 
     With objTableJoins.Add(objPrimaryTable, SQL.SQLSelectTableJoin.Type.Inner, objTables.Add("Categories")) 
         .Where.Add("CategoryID", SQL.ComparisonOperator.EqualTo, "CategoryID") 
     End With 
 
     Return objTableJoins 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjects.TableName">
      <summary>
 Should return the name of the table associated with this collection. 
 This function should almost always be implemented. 
 </summary>
 
 <example>
 <code>
 Protected Overrides Function TableName() As String 
 
     Return "Products" 
 
 End Function 
 </code>
 </example></member>
    <member name="T:DatabaseObjects.DatabaseObjectsEnumerable">
      <summary>
 This class is identical to DatabaseObjects except that it implements the 
 IEnumerable interface, therefore providing support for the "For Each" construct. 
 If IEnumerable is not required then inherit from DatabaseObjects. Generally, 
 inheriting from DatabaseObjectsEnumerable is preferable to DatabaseObjects as it 
 generates simpler and more readable code. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.DatabaseObjectsVolatile">
      <summary>
 This class extends DatabaseObjects by storing all objects associated with this 
 DatabaseObjects collection in memory. Any objects added via VolatileObjectAdd 
 or VolatileObjectDelete only affect the memory list until VolatileObjectsSave() is 
 called. VolatileObjectsSave will actually delete all objects in the database 
 and then save all objects in the memory list to the database. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectsVolatile.#ctor(DatabaseObjects.Database)">
      <summary>
 Initializes a new DatabaseObjects with it's associated database. 
 </summary>
 
 <param name="objDatabase">
 The database that this collection is associated with. 
 </param></member>
    <member name="M:DatabaseObjects.DatabaseObjectsVolatile.#ctor(DatabaseObjects.Database,System.Object)">
      <summary>
 Initializes a new DatabaseObjects with it's associated database. 
 </summary>
 
 <param name="objDatabase">
 The database that this collection is associated with. 
 </param>
 
 <param name="objParent">
 The parent collection that this collection is associated with. This is often 
 useful so that the SubSet property can use the Parent to filter 
 by a particular value pertinent to the parent object. Using the object 
 is optional. 
 </param></member>
    <member name="P:DatabaseObjects.DatabaseObjectsVolatile.Parent">
      <summary>
 Returns the parent object that this collection is associated with. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectsVolatile.VolatileObjectAdd(DatabaseObjects.IDatabaseObject)">
      <summary>
 Adds an item to the in-memory list, and flags the item to be saved to the database 
 when VolatileObjectsSave() is called. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectsVolatile.VolatileObjectByOrdinal(System.Int32)">
      <summary>
 Returns an item at the specific index in the in-memory list. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectsVolatile.VolatileObjectDelete(DatabaseObjects.IDatabaseObject)">
      <summary>
 Removes the item from the in-memory list, and flags the item to be deleted when 
 VolatileObjectsSave() is called. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectsVolatile.VolatileObjectsSave">
      <summary>
 Firstly, all items flagged for deletion (via VolatileObjectDelete) are deleted 
 in the database. 
 Secondly, all items that have been added to the in-memory list (via VolatileObjectAdd) 
 are added/saved to the database. 
 </summary>
 
 <example>
 <code>
 Friend Sub SaveAll() 
 
     Mybase.VolatileObjectsSave() 
 
 End Sub 
 </code>
 </example></member>
    <member name="P:DatabaseObjects.DatabaseObjectsVolatile.VolatileObjectsCount">
      <summary>
 Returns the number of items in the in-memory list. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectsVolatile.VolatileObjectsEnumerator">
      <summary>
 Returns the enumerator for all objects currently in the in-memory list. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.DatabaseObjectUsingAttributes">
      <summary>
 This class is identical to DatabaseObject except that rather than using the 
 LoadFields and SaveFields the properties are automatically set and retrieved 
 using the FieldMappingAttribute attribute. If necessary, the LoadFields and 
 SaveFields functions can still be overridden and the MyBase.LoadFields and 
 MyBase.SaveFields functions explicity called to load the database fields 
 that have been marked with the FieldMappingAttribute attribute. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectUsingAttributes.#ctor(DatabaseObjects.DatabaseObjects)">
      <summary>
 Initializes a new DatabaseObject with the parent collection that this object is 
 associated with. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectUsingAttributes.LoadFields(DatabaseObjects.SQL.SQLFieldValues)">
      <summary>
 Sets the properties and fields marked with the FieldMappingAttribute with the 
 values from the database record. Properties or fields that are an enum data 
 type are automatically converted from the database integer value to the equivalent 
 enum. For properties and fields marked with the FieldMappingObjectHookAttribute 
 the property's or field's object is also traversed for properties or fields marked 
 with the FieldMappingAttribute. 
 </summary>
 <example>
 <code>
 
 &lt;DatabaseObjects.FieldMapping("Name")&gt; _ 
 Private pstrName As String 
 
 OR 
 
 &lt;DatabaseObjects.FieldMapping("Name")&gt; _ 
 Public Property Name() As String 
     Get 
 
         Return pstrName 
 
     End Get 
 
     Set(ByVal Value As String) 
 
         pstrName = Value 
 
     End Set 
 
 End Property 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.DatabaseObjectUsingAttributes.SaveFields">
      <summary>
 Gets the values from the properties and fields marked with the FieldMappingAttribute 
 to be saved to the database. Properties or fields that return an enum data type are 
 automatically converted from the enum to the equivalent integer value for database 
 storage. For properties and fields marked with the FieldMappingObjectHookAttribute 
 the property's or field's object is also traversed for properties or fields marked 
 with the FieldMappingAttribute. 
 </summary>
 <example>
 <code>
 
 &lt;DatabaseObjects.FieldMapping("Name")&gt; _ 
 Private pstrName As String 
 
 OR 
 
 &lt;DatabaseObjects.FieldMapping("Name")&gt; _ 
 Public Property Name() As String 
     Get 
 
         Return pstrName 
 
     End Get 
 
     Set(ByVal Value As String) 
 
         pstrName = Value 
 
     End Set 
 
 End Property 
 </code>
 </example></member>
    <member name="T:DatabaseObjects.DatabaseObjectUsingAttributesLockable">
      <summary>
 Extends the capabilities of the DatabaseObjectUsingAttributes by providing a set of routines 
 that lock and unlock this object for exclusive access for a particular user. 
 When Lock() is called a record is written to the lock table which includes the 
 object's associated table name, the object's distinct value and the user ID 
 specified in the DatabaseObjectLockController. When Unlock() is called this 
 record is deleted. If another or the current user has locked the object then the 
 IsLocked property will return true. 
 The DatabseObjects library does not inhibit the loading and/or saving of any 
 locked objects. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectUsingAttributesLockable.IsLocked">
      <summary>
 Indicates whether the current object is Locked either by the current user or 
 another user. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectUsingAttributesLockable.LockedByUserID">
      <summary>
 Returns the user identifier that currently has the object locked. Throws an 
 exception if the object is not locked by a user. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectUsingAttributesLockable.Lock">
      <summary>
 Locks the current object. Throws an exception if the object is already locked. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.DatabaseObjectUsingAttributesLockable.UnLock">
      <summary>
 UnLocks the current object. Throws an exception if the object is not locked. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.DatabaseObjectUsingAttributesLockable.IsLockedByCurrentUser">
      <summary>
 Returns whether the current user has the object locked. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.IDatabaseObject">
      <summary>
 An IDatabaseObject object represents a single record in a database table. The 
 Database class provides the facility for classes implementing IDatabaseObject to 
 copy data to and from the associated database record. Rather than directly 
 implementing IDatabaseObject inherit from DatabaseObject as the DatabaseObject 
 class provides the basic "plumbing" code required by IDatabaseObjects. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.IDatabaseObject.IsSaved">
      <summary>
 Should return whether the object has been saved to the database. Generally, 
 this is implemented using a private variable that stores the object's saved state. 
 If a new object is saved or an existing object is loaded then this property 
 is automatically set to true by the library. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.IDatabaseObject.DistinctValue">
      <summary>
 Should return the distinct value that uniquely identifies this 
 object in the database. If a new object is saved (which uses an auto increment 
 field) or an existing object is loaded then this property is automatically 
 set by the library. 
 Typically, this is the value of an identity or auto increment database field. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.IDatabaseObject.LoadFields(DatabaseObjects.SQL.SQLFieldValues)">
      <summary>
 This subroutine should copy the database fields from objFields to the object's 
 variables. objFields is populated with all of the fields from the associated record. 
 </summary>
 
 <example>
 <code>
 Protected Sub LoadFields(ByVal objFields As SQL.SQLFieldValues) Implements IDatabaseObject.LoadFields 
 
     pstrCode = objFields("ProductCode").Value 
     pstrDescription = objFields("ProductDescription").Value 
 
 End Sub 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObject.SaveFields">
      <summary>
 Should return an SQLFieldValues object populated with the 
 fields to be written to the database. The first argument of the SQLFieldValues.Add 
 function is the database field name, the second is the field's value. 
 </summary>
 
 <example>
 <code>
 Protected Function SaveFields() As SQL.SQLFieldValues Implements IDatabaseObject.SaveFields 
 
     SaveFields = New SQL.SQLFieldValues 
     SaveFields.Add("ProductCode", pstrCode) 
     SaveFields.Add("ProductDescription", pstrDescription) 
 
 End Function 
 </code>
 </example></member>
    <member name="T:DatabaseObjects.IDatabaseObjects">
      <summary>
 An IDatabaseObjects object represents either a database table or a sub set of a 
 database table. The Database class provides the facility for classes implementing 
 IDatabaseObjects to specify the database table the class is bound to, how to 
 identify each unique record within the table (or subset), how the table should 
 be sorted and table joins (in order to improve performance). Rather than 
 directly implementing IDatabaseObjects inherit from DatabaseObjects 
 as the DatabaseObjects class provides the basic "plumbing" code required by 
 IDatabaseObjects. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.IDatabaseObjects.ItemInstance">
      <summary>
 Should return an instance of the class that is associated with this 
 collection of objects. The associated class must implement the IDatabaseObject interface. 
 </summary>
 
 <example>
 <code>
 Protected Function ItemInstance() As IDatabaseObject Implements IDatabaseObjects.ItemInstance 
 
     Return New Product 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.Subset">
      <summary>
 Should return the conditions that define the collection's subset. 
 If the collection should include the entire table then this function should be 
 left blank. Implementing this function is optional. 
 </summary>
 
 <example>
 <code>
 Protected Function Subset() As SQL.SQLConditions Implements IDatabaseObjects.Subset 
 
     Dim objConditions As New SQL.SQLConditions 
 
     'Only include products that are in group ID 1234 
     objConditions.Add("GroupID", SQL.ComparisonOperator.EqualTo, 1234) 
 
     Return objConditions 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.TableName">
      <summary>
 Should return the name of the table associated with this collection. 
 This function should almost always be implemented. 
 </summary>
 
 <example>
 <code>
 Protected Function TableName() As String Implements IDatabaseObjects.TableName 
 
     Return "Products" 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.KeyFieldName">
      <summary>
 This property should return the field name that uniquely identifies each object 
 within the collection. As opposed to the ordinal/index position, the key field 
 provides another method of accessing a particular object within the collection. 
 The key field must be unique within the collection. If the IDatabaseObjects.Subset 
 function has been implemented then the key field only needs to be unique within 
 the specified subset, not the entire table. Implementing this function is optional. 
 </summary>
 
 <example>
 <code>
 Protected Function KeyFieldName() As String Implements IDatabaseObjects.KeyFieldName 
 
     Return "ProductCode" 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.DistinctFieldName">
      <summary>
 Should return the field name that uniquely identifies each object 
 within the collection. Typically, this is the field name of an identity or auto 
 increment field. If the IDatabaseObjects.SubSet function has been implemented 
 then the DistinctFieldName need only be unique within the subset not the 
 entire table. The DistinctFieldName and KeyFieldName can be identical. This 
 function should almost always be implemented. 
 </summary>
 
 <example>
 <code>
 Protected Function DistinctFieldName() As String Implements IDatabaseObjects.DistinctFieldName 
 
     Return "ProductID" 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.DistinctFieldAutoIncrements">
      <summary>
 Should return whether the Distinct field as specified in the 
 associated collection's IDatabaseObject.DistinctField is an identity (SQL Server) 
 or autonumber (Microsoft Access) field. If set to true, then the 
 IDatabaseObject.DistinctValue value is set when a new object is saved. 
 </summary>
 
 <example>
 <code>
 Protected Function DistinctFieldAutoIncrements() As Boolean Implements IDatabaseObjects.DistinctFieldAutoIncrements 
 
     Return True 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.OrderBy">
      <summary>
 Should return an SQLSelectOrderByFields object containing the list 
 of fields the collection will be sorted by. Just as with an SQL statement, the 
 order of the fields added to the collection indicates the group sorting. If 
 IDatabaseObjects.TableJoins has been implemented then fields from the adjoining 
 table or tables can be utilized. The sort order is used by the ObjectByOrdinal, 
 ObjectByOrdinalFirst and ObjectsSearch functions. Implementing this function is 
 optional. 
 </summary>
 
 <example>
 <code>
 Protected Function OrderBy() As SQL.SQLSelectOrderByFields Implements IDatabaseObjects.OrderBy 
 
     OrderBy = New SQL.SQLSelectOrderByFields 
     OrderBy.Add("ProductCode", SQL.OrderBy.Ascending) 
 
 End Function 
 </code>
 </example></member>
    <member name="M:DatabaseObjects.IDatabaseObjects.TableJoins(DatabaseObjects.SQL.SQLSelectTable,DatabaseObjects.SQL.SQLSelectTables)">
      <summary>
 Should return an SQLSelectTableJoins object containing the table 
 or tables to be joined to the primary table. This function is useful in 
 optimising database loading speeds by allowing multiple tables to be joined into 
 one data set. The resultant data set can then be used to load 
 objects from the associated tables avoiding subsequent SQL calls. For a complete 
 example, see the demonstration program. Implementing this function is optional. 
 </summary>
 
 <example>
 <code>
 Protected Function TableJoins(ByVal objPrimaryTable As SQL.SQLSelectTable, ByVal objTables As SQL.SQLSelectTables) As SQL.SQLSelectTableJoins Implements IDatabaseObjects.TableJoins 
 
     'Implementing this function is optional, but is useful when attempting to optimise loading speeds. 
     'This function is used by the ObjectsList, Object, ObjectByKey, ObjectOrdinal and ObjectSearch functions. 
     'If this function has been implemented Search can also search fields in the joined table(s). 
     'In this example, the Products table will always be joined with the Supplier table. We could also join the Products 
     'table to the Category table, however the Product.Category property is not used often enough to warrant 
     'always joining the category table whenever loading a product. Of course, you can always join different 
     'tables in different situations, for example you might want join to other tables when searching and to 
     'not join other tables in normal circumstances. 
 
     Dim objTableJoins As SQL.SQLSelectTableJoins = New SQL.SQLSelectTableJoins 
 
     With objTableJoins.Add(objPrimaryTable, SQL.SQLSelectTableJoin.Type.Inner, objTables.Add("Suppliers")) 
         .Where.Add("SupplierID", SQL.ComparisonOperator.EqualTo, "SupplierID") 
     End With 
 
     With objTableJoins.Add(objPrimaryTable, SQL.SQLSelectTableJoin.Type.Inner, objTables.Add("Categories")) 
         .Where.Add("CategoryID", SQL.ComparisonOperator.EqualTo, "CategoryID") 
     End With 
 
     Return objTableJoins 
 
 End Function 
 </code>
 </example></member>
    <member name="T:DatabaseObjects.IGlobalDatabaseObjects">
      <summary>
 The IGlobalDatabaseObjects interface aids in maintaining a class library's 
 abstraction layer when external objects (objects outside of the class library) 
 need to be used. For example, if we had two DLL class libraries, the first an 
 Inventory class library that exposes, amongst other classes a collection of 
 Product objects and the second library needs to use the Product objects provided 
 by the Inventory library. In particular, it needs to be able to store and load a 
 Product using it's distinct value (ProductID). So, rather than exposing a public 
 function in the Inventory library to load a Product using it's distinct value 
 (ProductID) the Products class can implement the IGlobalDatabaseObjects interface. 
 Implementing this interface allows a product to be loaded from it's distinct value 
 without exposing a public function - thereby maintaining a degree of abstraction 
 between the two dlls. Conversely, the product's distinct value (ProductID) can 
 be extracted by calling DirectCast(objProduct, IDatabaseObject).DistinctValue. 
 An example of using an external DLL that implements IGlobalDatabaseObjects: 
 Dim objProduct As Product = DirectCast(objProducts, IGlobalDatabaseObjects).Object(1234) 
 </summary>
    </member>
    <member name="M:DatabaseObjects.IGlobalDatabaseObjects.Object(System.Object)">
      <summary>
 Should return the object in the collection for the distinct value 
 argument. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.ObjectReference">
      <summary>
 This class can be used to simplify the process of creating and returning late-bound 
 IDatabaseObject or DatabaseObject objects. This is is particularly useful in speeding 
 up load times of referenced objects by delaying loading the associated object or 
 objects until the property or method is actually called. This is opposed to loading 
 the object when the container object is loaded. 
 The object is loaded only on the first call to the Object property. 
 Subsequent calls to the Object property return the already loaded object. 
 If pobjDistinctValue is nothing (0 if an integer or "" if a string) then the Object 
 property will always return Nothing. Similarly if the default constructor is called 
 then the Object property will always return Nothing. 
 If IfNothingUseObjectByOrdinalFirst is true and the distinct value is nothing then the 
 first item in the collection will be returned. 
 </summary>
    </member>
    <member name="M:DatabaseObjects.ObjectReference.#ctor">
      <summary>
 If this constructor is used then the Object property will always return Nothing 
 which is useful for a new object that should always return Nothing for the associated object 
 </summary>
    </member>
    <member name="M:DatabaseObjects.ObjectReference.#ctor(DatabaseObjects.DatabaseObjects,System.Object,System.Boolean)">
      <summary>
 Initializes the object reference with the distinct value of the object reference 
 and the collection that contains the object reference. The object is not loaded 
 by the constructor - only when the Object property is called. 
 </summary>
 <param name="objCollection">
 The collection that contains the referenced object. The class' Mybase.Object 
 function is called to load the object. 
 </param>
 <param name="objDistinctValue">
 The distinct value (usually an identity or auto increment value) that identifies 
 the referenced object. 
 </param>
 <param name="bIfNothingUseObjectByOrdinalFirst">
 If the distinct value is nothing (0 if an integer or "" if a string) then the 
 ObjectByOrdinalFirst function is used to load the default object when the Object 
 function is first called. Subsequent calls return the already loaded object. 
 </param></member>
    <member name="M:DatabaseObjects.ObjectReference.#ctor(DatabaseObjects.Database,DatabaseObjects.IDatabaseObjects,System.Object,System.Boolean)">
      <summary>
 Initializes the object reference with the distinct value of the object reference 
 and the collection that contains the object reference. The object is not loaded 
 by the constructor - only when the Object property is called. 
 </summary>
 <param name="objCollection">
 The collection that contains the referenced object. The class' MyBase.Object 
 function is called to load the object. 
 </param>
 <param name="objDistinctValue">
 The distinct value (usually an identity or auto increment value) that identifies 
 the referenced object. 
 </param>
 <param name="bIfNothingUseObjectByOrdinalFirst">
 If the distinct value is nothing (0 if an integer or "" if a string) then the 
 ObjectByOrdinalFirst function is used to load the default object when the Object 
 function is first called. Subsequent calls return the already loaded object. 
 </param></member>
    <member name="P:DatabaseObjects.ObjectReference.Object">
      <summary>
 Sets/returns the referenced object. 
 When getting the value of this property on the first call the associated object 
 is loaded. If bIfNothingUseObjectByOrdinalFirst is true and the DistinctValue is 
 nothing then the default object is loaded. 
 Subsequent get calls will not load the object but return the already loaded object. 
 </summary>
    </member>
    <member name="P:DatabaseObjects.ObjectReference.DistinctValue">
      <summary>
 This property can be used when saving the distinct value associated with this object 
 The Me.Object.DistinctValue could be used but this could cause an unnecessary loading 
 of the associated object when saving if the 'Property Get Object' hadn't been called 
 while the object was loaded. 
 </summary>
 <example>
 <code>
 
 Private pobjGroup As New ObjectReference 
 
 &lt;DatabaseObjects.FieldMapping("ProductGroupID")&gt; _ 
 Private Property GroupID() As Integer 
     Get 
 
         Return pobjGroup.DistinctValue 
 
     End Get 
 
     Set(ByVal Value As Integer) 
 
         pobjGroup = New ObjectReference(ProductGroups, Value) 
 
     End Set 
 End Property 
 </code>
 </example></member>
    <member name="P:DatabaseObjects.ObjectReference.ObjectIsNothing">
      <summary>
 This property can be used when saving the object. Me.Object Is nothing could be 
 used but this could cause an unnecessary loading of the associated object when 
 saving if the 'Property Get Object' hadn't been called while the object was loaded. 
 If this property is true then DistinctValue will be either 0 or "" (depending 
 on the data type of the distinct value passed to the constructor). 
 </summary>
    </member>
    <member name="T:DatabaseObjects.SQL.DataType">
      <summary>
 Provides a set of uniform and portable data types that can be used between 
 Microsoft Access, SQLServer and MySQL. Please refer to the DataTypeString 
 function in the Source\SQL\SQLTable.vb file for the actual SQL equivalents for 
 each database. 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.TinyInteger">
      <summary>
 Integer data from 0 through 255 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.SmallInteger">
      <summary>
 Integer data from 2^15 (-32,768) through 2^15 - 1 (32,767) 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Integer">
      <summary>
 Integer (whole number) data from -2^31 (-2,147,483,648) through 2^31 - 1 (2,147,483,647) 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.BigInteger">
      <summary>
 Integer (whole number) data from -2^63 (-9223372036854775808) through 2^63-1 (9223372036854775807) 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Character">
      <summary>
 SQLServer limitation: Fixed-length non-Unicode character data with a maximum length of 8,000 characters 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.UnicodeCharacter">
      <summary>
 SQLServer limitation: Fixed-length Unicode data with a maximum length of 4,000 characters 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.VariableCharacter">
      <summary>
 SQLServer limitation: Variable-length non-Unicode data with a maximum of 8,000 characters 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.UnicodeVariableCharacter">
      <summary>
 SQLServer limitation: Variable-length Unicode data with a maximum length of 4,000 characters 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Decimal">
      <summary>
 Fixed precision and scale numeric data. 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Real">
      <summary>
 Floating precision number data from -3.40E + 38 through 3.40E + 38. Equivalent 
 to VB.NET Single data type. The MySQL equivalent used is FLOAT. 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Float">
      <summary>
 Floating precision number data from -1.79E + 308 through 1.79E + 308. Equivalent 
 to .NET Double data type. The MySQL equivalent used is DOUBLE. 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.SmallMoney">
      <summary>
 Monetary data values from -214,748.3648 through +214,748.3647, with accuracy to a 
 ten-thousandth of a monetary unit. The MySQL equivalent used is DECIMAL(10,4). 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Money">
      <summary>
 Monetary data values from -2^63 (-922,337,203,685,477.5808) through 2^63 - 1 
 (+922,337,203,685,477.5807), with accuracy to a ten-thousandth of a monetary unit. 
 The MySQL equivalent used is DECIMAL(19,4). 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Boolean">
      <summary>
 Integer data with either a 1 or 0 value 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.SmallDateTime">
      <summary>
 SQL Server: Date and time data from January 1, 1900, through June 6, 2079, with 
 an accuracy of one minute. This data type for Access and MySQL is equivalent to 
 DATETIME. 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.DateTime">
      <summary>
 Date and time data from January 1, 1753, through December 31, 9999, with an 
 accuracy of three-hundredths of a second, or 3.33 milliseconds. This is a SQLServer 
 limitation. MySQL supports '1000-01-01 00:00:00' to '9999-12-31 23:59:59'. To 
 provide portability, accuracy to only 1 second can be assumed. 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.TimeStamp">
      <summary>
 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Text">
      <summary>
 Variable-length non-Unicode data with a maximum length of 2^31 - 1 (2,147,483,647) characters 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.UnicodeText">
      <summary>
 Variable-length Unicode data with a maximum length of 2^30 - 1 (1,073,741,823) characters 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Binary">
      <summary>
 SQLServer limitation: Fixed-length binary data with a maximum length of 8,000 bytes 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.VariableBinary">
      <summary>
 SQLServer limitation: Variable-length binary data with a maximum length of 8,000 bytes 
 </summary>
    </member>
    <member name="F:DatabaseObjects.SQL.DataType.Image">
      <summary>
 Variable-length binary data with a maximum length of 2^31 - 1 (2,147,483,647) bytes 
 </summary>
    </member>
    <member name="P:DatabaseObjects.SQL.SQLStatement.DefaultConnectionType">
      <summary>
 This is used as the default connection type when manually instantiating a 
 SQLSelect, SQLDelete, SQLUpdate or SQLInsert command (which all inherit from 
 SQLStatement) and is set by the last Database.Connect function's ConnectionType 
 argument. However, the Database class does not rely on this property as the 
 ConnectionType property is set before any SQL statements are executed. This 
 allows different Database instances to use different databases. 
 </summary>
    </member>
    <member name="T:DatabaseObjects.SQL.SQLTableExists">
      <summary>
 This class can be used to determine whether a table exists. This class can be 
 used will all databases. If after running the SQL statement the data set is not 
 empty then the table exists. 
 </summary>
    </member>
  </members>
</doc>

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

About the Author

Toby Wicks

United States United States
No Biography provided

| Advertise | Privacy | Mobile
Web03 | 2.8.140721.1 | Last Updated 31 Jan 2007
Article Copyright 2005 by Toby Wicks
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid