You are previewing Alison Balter’s Mastering Microsoft Access 2002 Desktop Development.
O'Reilly logo
Alison Balter’s Mastering Microsoft Access 2002 Desktop Development

Book Description

What Ms Balter's book offers over most or all of the other books on the market is that Ms Balter is able to take a highly technical topic and present it in a manner that is easy to comprehend. It is a book that the reader will often want to read from cover to cover, but it can also act as an excellent reference.

  • Readers of Alison Balter's Mastering Microsoft Access 2002 Desktop Development will learn (

  • A thorough knowledge of Access application development. (

  • Real-world solutions to specific development and programming problems. (

  • Professional programming techniques backed by concise, no-nonsense explanations of the underlying theories. (

  • Debugging and troubleshooting methods to solve problems quickly and get stalled development projects back on track.

  • Table of Contents

    1. Copyright
      1. Dedication
    2. About the Author
    3. Acknowledgments
    4. Tell Us What You Think!
    5. Introduction
    6. I. The Basics of Access Development
      1. 1. Access as a Development Tool
        1. Why This Chapter Is Important
        2. What Types of Applications Can You Develop in Access?
          1. Access as a Development Platform for Personal Applications
          2. Access as a Development Platform for Small-Business Applications
          3. Access as a Development Platform for Departmental Applications
          4. Access as a Development Platform for Corporation-Wide Applications
          5. Access as a Development Platform for Enterprise-Wide Client/Server Applications
          6. Access as a Development Platform for Intranet/Internet Applications
        3. Access as a Scalable Product
        4. What Exactly Is a Database?
        5. Getting to Know the Database Objects
          1. Tables: A Repository for Your Data
            1. Relationships: Tying the Tables Together
          2. Queries: Stored Questions or Actions to Be Applied to Your Data
          3. Forms: A Means of Displaying, Modifying, and Adding Data
          4. Reports: Turning Data into Information
          5. Data Access Pages: Forms Viewed in a Browser
          6. Macros: A Means of Automating Your System
          7. Modules: The Foundation to the Application Development Process
        6. Object Naming Conventions
        7. Hardware Requirements
          1. What Hardware Does the Developer’s System Require?
          2. What Hardware Does the User’s System Require?
        8. How Do I Get Started Developing an Access Application?
          1. Task Analysis
          2. Data Analysis and Design
            1. Normalization Made Easy
          3. Prototyping
          4. Testing
          5. Implementation
          6. Maintenance
        9. What’s New in Access 2002
          1. What’s New with Forms
          2. What’s New with Reports
          3. The Exciting World of PivotTables and PivotCharts
          4. Welcome to the Programmability Enhancements in Access 2002
          5. Access 2002 and XML
          6. What’s New with ADP Projects
          7. What’s New with Data Access Pages
          8. Other New Features Found in Access 2002
        10. Summary
      2. 2. What Every Developer Needs to Know About Tables
        1. Why This Chapter Is Important
        2. Building a New Table
          1. Designing a Table from Scratch
        3. Selecting the Appropriate Field Type for Your Data
          1. Text Fields: The Most Common Field Type
          2. Memo Fields: For Those Long Notes and Comments
          3. Number Fields: For When You Need to Calculate
          4. Date/Time Fields: Tracking When Things Happened
          5. Currency Fields: Storing Money
          6. AutoNumber Fields: For Unique Record Identifiers
          7. Yes/No Fields: When One of Two Answers Is Correct
          8. OLE Object Fields: The Place to Store Just About Anything
          9. Hyperlink Fields: Your Link to the Internet
        4. Working with Field Properties
          1. Field Size: Limiting What’s Entered into a Field
          2. Format: Determining How Data Is Displayed
          3. Input Mask: Determining What Data Goes into a Field
          4. Caption: A Great Timesaver
          5. Default Value: Saving Data-Entry Time
          6. Validation Rule: Controlling What’s Entered in a Field
          7. Validation Text: Providing Error Messages to the User
          8. Required: Making the User Enter a Value
          9. Allow Zero Length: Accommodating Situations with Nonexistent Data
          10. Indexes: Speeding Up Searches
          11. Unicode Compression
        5. The All-Important Primary Key
        6. Working with the Lookup Feature
        7. Working with Table Properties
        8. Using Indexes to Improve Performance
        9. Access Tables and the Internet
          1. The Hyperlink Field Type
          2. Saving Table Data as HTML
          3. Saving Table Data as XML
        10. Working with PivotTable and PivotChart Views
        11. Summary
      3. 3. Relationships: Your Key to Data Integrity
        1. Why This Chapter Is Important
        2. Introduction to Relational Database Design
          1. The History of Relational Database Design
          2. Goals of Relational Database Design
          3. Rules of Relational Database Design
            1. The Rules of Tables
            2. The Rules of Uniqueness and Keys
            3. Foreign Keys and Domains
          4. Normalization and Normal Forms
            1. First Normal Form
            2. Second Normal Form
            3. Third Normal Form
          5. Denormalization—Purposely Violating the Rules
          6. Integrity Rules
            1. Overall Rules
            2. Database-Specific Rules
          7. Examining the Types of Relationships
            1. One-to-Many
            2. One-to-One
            3. Many-to-Many
        3. Establishing Relationships in Access
          1. Establishing a Relationship Between Two Tables
          2. Looking at Guidelines for Establishing Relationships
          3. Modifying an Existing Relationship
        4. Establishing Referential Integrity
          1. Cascade Update Related Fields
          2. Cascade Delete Related Records
        5. Looking at the Benefits of Relationships
        6. Examining Indexes and Relationships
        7. Summary
      4. 4. What Every Developer Needs to Know About Query Basics
        1. Why This Chapter Is Important?
        2. What Is a Query, and When Should You Use One?
        3. Everything You Need to Know About Query Basics
          1. Adding Tables to Your Queries
          2. Adding Fields to Your Query
          3. Removing a Field from the Query Design Grid
          4. Inserting a Field After the Query Is Built
          5. Moving a Field to a Different Location on the Query Design Grid
          6. Saving and Naming Your Query
        4. Ordering Your Query Result
          1. Sorting by More than One Field
        5. Refining Your Query with Criteria
        6. Working with Dates in Criteria
        7. Understanding How Query Results Can Be Updated
        8. Building Queries Based on Multiple Tables
          1. Pitfalls of Multitable Queries
          2. Row Fix-Up in Multitable Queries
        9. Creating Calculated Fields
        10. Getting Help from the Expression Builder
        11. Summarizing Data with Totals Queries
        12. Excluding Fields from the Output
        13. Nulls and Query Results
        14. Refining Your Queries with Field, Field List, and Query Properties
          1. Field Properties: Changing the Behavior of a Field
          2. Field List Properties: Changing the Properties of the Field List
          3. Query Properties: Changing the Behavior of the Overall Query
        15. Building Parameter Queries When You Don’t Know the Criteria at Design Time
        16. Summary
      5. 5. What Every Developer Needs to Know About Forms
        1. Why This Chapter Is Important
        2. Uses of Forms
        3. Anatomy of a Form
        4. Creating a New Form
          1. Creating a Form with the Form Wizard
          2. Creating a Form from Design View
        5. Working with the Form Design Window
          1. Understanding and Working with the Form Design Tools
            1. Toggling the Tools to Get What You Want
          2. Adding Fields to the Form
          3. Selecting, Moving, Aligning, and Sizing Form Objects
            1. Selecting Form Objects
            2. Moving Things Around
            3. Aligning Objects to One Another
            4. Snap to Grid
            5. Power Sizing Techniques
            6. Controlling Object Spacing
          4. Modifying Object Tab Order
        6. Selecting the Correct Control for the Job
          1. Labels
          2. Text Boxes
          3. Combo Boxes
          4. List Boxes
          5. Check Boxes
          6. Option and Toggle Buttons
          7. Option Groups
        7. Control Morphing
          1. Morphing a Text Box to a Combo Box
          2. Morphing a Combo Box to a List Box
        8. Conditional Formatting
        9. What Form Properties Are Available, and Why Should You Use Them?
          1. Working with the Properties Window
          2. Working with the Important Form Properties
            1. Format Properties of a Form
            2. Data Properties of a Form
            3. Other Properties of a Form
        10. What Control Properties Are Available, and Why Use Them?
          1. Format Properties of a Control
          2. Data Properties of a Control
          3. Other Properties of a Control
        11. Bound, Unbound, and Calculated Controls
        12. Using Expressions to Enhance Your Forms
        13. The Command Button Wizards: Programming Without Typing
        14. Building Forms Based on More Than One Table
          1. Creating One-to-Many Forms
            1. Building a One-to-Many Form by Using the Form Wizard
            2. Building a One-to-Many Form with the Subform/Subreport Wizard
          2. Working with Subforms
        15. Basing Forms on Queries: The Why and How
          1. Embedding SQL Statements Versus Stored Queries
        16. Access Forms and the Internet
          1. Adding a Hyperlink to a Form
          2. Saving a Form as HTML
          3. Saving a Form as XML
          4. Saving a Form as Microsoft Active Server Pages or Microsoft IIS 1-2
          5. Designing the Clients Form
          6. Designing the Projects Form
          7. Adding a Command Button That Links the Clients and Projects Forms
          8. What’s Ahead
        17. Summary
      6. 6. What Every Developer Needs to Know About Reports
        1. Why This Chapter Is Important
        2. Types of Reports Available
          1. Detail Reports
          2. Summary Reports
          3. Cross-tabulation Reports
          4. Reports with Graphics and Charts
          5. Reports with Forms
          6. Reports with Labels
        3. Anatomy of a Report
        4. Creating a New Report
          1. Creating a Report with the Report Wizard
          2. Creating a Report from Design View
        5. Working with the Report Design Window
          1. Understanding the Report Design Tools
          2. Adding Fields to the Report
          3. Selecting, Moving, Aligning, and Sizing Report Objects
            1. Selecting Report Objects
            2. Moving Things Around
            3. Aligning Objects with One Another
            4. Using Snap to Grid
            5. Using Power-Sizing Techniques
            6. Controlling Object Spacing
        6. Selecting the Correct Control for the Job
          1. Labels
          2. Text Boxes
          3. Lines
          4. Rectangles
          5. Bound Object Frames
          6. Unbound Object Frames
          7. Image Controls
          8. Other Controls
        7. What Report Properties Are Available and Why Use Them
          1. Working with the Properties Window
          2. The Report’s Format Properties
          3. The Report’s Data Properties
          4. Other Report Properties
        8. What Control Properties Are Available and Why Use Them
          1. The Control’s Format Properties
            1. The Control’s Data Properties
          2. The Other Control Properties
        9. Inserting Page Breaks
        10. Unbound, Bound, and Calculated Controls
        11. Using Expressions to Enhance Your Reports
        12. Building Reports Based on More Than One Table
          1. Creating One-to-Many Reports
            1. Building a One-to-Many Report with the Report Wizard
            2. Building a Report Based on a One-To-Many Query
            3. Building a One-to-Many Report with the Subreport Wizard
          2. Working with Subreports
        13. Working with Sorting and Grouping
          1. Adding Sorting and Grouping
          2. Sorting and Grouping Properties
          3. What Are Group Header and Footer Properties and Why Use Them?
        14. Improving Performance and Reusability by Basing Reports on Stored Queries or Embedded SQL Statements
        15. Access Reports and the Internet
          1. Adding a Hyperlink to a Report
          2. Saving a Report as HTML
          3. Saving a Report as XML
          4. Designing the rptClientListing Report
          5. Designing the rptTimeSheet Report
        16. Summary
      7. 7. VBA: An Introduction
        1. Why This Chapter Is Important
        2. VBA Explained
        3. What Are Access Class Modules, Standard Modules, Form Modules, and Report Modules?
          1. Where Is VBA Code Written?
          2. The Anatomy of a Module
          3. Option Explicit
          4. Creating Event Procedures
          5. Creating Functions and Subroutines
            1. Creating a User-Defined Routine in a Code Module
            2. Creating a User-Defined Routine in a Form or Report Class Module
          6. Calling Event and User-Defined Procedures
          7. Scope and Lifetime of Procedures
            1. Public Procedures
            2. Private Procedures
            3. Scope Precedence
            4. Static Procedures
        4. Working with Variables
          1. Declaring Variables
          2. VBA Data Types
          3. Scope and Lifetime of Variables: Exposing Your Variables as Little as Possible
            1. Local Variables
            2. Static Variables: A Special Type of Local Variable
            3. Private Variables
            4. Public Variables
        5. Adding Comments to Your Code
        6. Using the Line Continuation Character
        7. Using the VBA Control Structures
          1. If...Then...Else
          2. Immediate If (IIf)
          3. The Conditional If: Conditional Compilation
          4. Select Case
          5. Looping
          6. For...Next
          7. With...End With
          8. For Each...Next
        8. Passing Parameters and Returning Values
        9. Executing Procedures from the Module Window
        10. The DoCmd Object: Performing Macro Actions
        11. Working with Built-In Functions
          1. Built-In Functions
            1. Format
            2. Instr
            3. InStrRev
            4. Left
            5. Right
            6. Mid
            7. UCase
            8. DatePart
            9. DateDiff
            10. DateAdd
            11. Replace
            12. StrRev
            13. MonthName
          2. Functions Made Easy with the Object Browser
        12. Working with Constants
          1. Working with Symbolic Constants
            1. Scoping Symbolic Constants
          2. Working with Intrinsic Constants
        13. Tools for Working in the Visual Basic Editor
          1. List Properties and Methods
          2. List Constants
          3. Quick Info
          4. Parameter Information
          5. Complete Word
          6. Definition
          7. Mysteries of the Coding Environment Solved
          8. The Project Window
          9. The Properties Window
          10. The View Microsoft Access Tool
          11. Find and Replace
          12. Help
          13. Splitting the Code Window
          14. Using Bookmarks to Save Your Place
        14. Customizing the VBE
          1. Coding Options—The Editor Tab
          2. Code Color, Fonts, and Sizes—The Editor Format Tab
          3. General Options—The General Tab
          4. Docking Options—The Docking Tab
        15. Summary
      8. 8. Objects, Properties, Methods, and Events Explained
        1. Why This Chapter Is Important
        2. Understanding Objects, Properties, Events, and Methods
          1. What Exactly Are Objects?
          2. What Exactly Are Properties?
          3. What Exactly Are Events?
          4. What Exactly Are Methods?
        3. Using the Object Browser to Learn About Access’s Objects
          1. How to Use the Object Browser
          2. Pasting Code Templates into a Procedure
        4. Referring to Objects
        5. Properties and Methods Made Easy
          1. Default Properties
        6. Declaring and Assigning Object Variables
          1. Object Variables Versus Regular Variables
          2. Generic Versus Specific Object Variables
          3. Cleaning Up After Yourself
        7. Understanding the Differences Between Objects and Collections
          1. Manipulating a Single Object
            1. With...End With: Performing Multiple Commands on an Object
          2. Manipulating a Collection of Objects
            1. For...Each: Performing the Same Command on Multiple Objects
        8. Passing Objects to Subroutines and Functions
        9. Determining the Type of a Control
        10. Special Properties That Refer to Objects
        11. Understanding Access’s Object Model
          1. The Application Object
            1. Application Object Properties
            2. Application Object Methods
          2. The Forms Collection
          3. The Reports Collection
          4. The DataAccessPages Collection
          5. The Modules Collection
          6. The CurrentProject Object
            1. The AllForms Collection
            2. The AllReports Collection
            3. The AllMacros Collection
            4. The AllModules Collection
            5. The AllDataAccessPages Collection
          7. The CurrentData Object
            1. The AllTables Collection
            2. The AllQueries Collection
          8. The CodeProject Object
          9. The CodeData Object
          10. The Screen Object
          11. The DoCmd Object
        12. New Access 2002 Properties
          1. Enabling and Disabling Command Buttons
        13. Summary
      9. 9. Advanced Form Techniques
        1. Why This Chapter Is Important
        2. What Are the Form Events, and When Do You Use Them?
          1. Current
          2. BeforeInsert
          3. AfterInsert
          4. BeforeUpdate
          5. AfterUpdate
          6. Dirty
          7. Undo
          8. Delete
          9. BeforeDelConfirm
          10. AfterDelConfirm
          11. Open
          12. Load
          13. Resize
          14. Unload
          15. Close
          16. Activate
          17. Deactivate
          18. GotFocus
          19. LostFocus
          20. Click
          21. DblClick
          22. MouseDown
          23. MouseMove
          24. MouseUp
          25. KeyDown
          26. KeyUp
          27. KeyPress
          28. Error
          29. Filter
          30. ApplyFilter
          31. Timer
          32. Understanding the Sequence of Form Events
            1. What Happens When a Form Is Opened?
            2. What Happens When a Form Is Closed?
            3. What Happens When a Form Is Sized?
            4. What Happens When Focus Shifts from One Form to Another?
            5. What Happens When Keys Are Pressed?
            6. What Happens When Mouse Actions Take Place?
        3. What Are the Section and Control Events, and When Do You Use Them?
          1. BeforeUpdate
          2. AfterUpdate
          3. Updated
          4. Change
          5. NotInList
          6. Enter
          7. Exit
          8. GotFocus
          9. LostFocus
          10. Click
          11. DblClick
          12. MouseDown
          13. MouseMove
          14. MouseUp
          15. KeyDown
          16. KeyUp
          17. KeyPress
          18. Understanding the Sequence of Control Events
            1. What Happens When Focus Is Moved to or from a Control?
            2. What Happens When the Data in a Control Is Updated?
        4. Referring to Me
        5. What Types of Forms Can I Create, and When Are They Appropriate?
          1. Single Forms: Viewing One Record at a Time
          2. Continuous Forms: View Multiple Records at a Time
          3. Multipage Forms: When Everything Doesn’t Fit on One Screen
          4. Tabbed Forms: Conserving Screen Real Estate
            1. Adding a Tab Control and Manipulating Its Pages
            2. Adding Controls to the Pages of a Tab Control
            3. Modifying the Tab Order of Controls
            4. Changing the Properties of the Tab Control
            5. Changing the Properties of Each Page
          5. Switchboard Forms: Controlling Your Application
          6. Splash Screen Forms: A Professional Opening to Your Application
          7. Dialog Forms: Gathering Information
        6. Using Built-In Dialog Boxes
          1. Message Boxes
            1. The MsgBox Function
          2. Input Boxes
          3. The FileDialog Object
        7. Adding Custom Menus, Toolbars, and Shortcut Menus to Your Forms
          1. Designing a Menu
            1. Associating a Command with a Menu Item
            2. Deleting and Renaming Menus
            3. Manipulating Command Bars by Using Code
        8. Taking Advantage of Built-In, Form-Filtering Features
        9. Including Objects from Other Applications: Linking Versus Embedding
          1. Bound OLE Objects
          2. Unbound OLE Objects
        10. OpenArgs
        11. Switching a Form’s RecordSource
        12. Power Combo Box and List Box Techniques
          1. Handling the NotInList Event
          2. Working with a Pop-Up Form
          3. Adding Items to a Combo Box or List Box at Runtime
            1. Populating a Combo or List Box with a Callback Function
          4. Handling Multiple Selections in a List Box
        13. Power Subform Techniques
          1. Referring to Subform Controls
        14. Synchronizing a Form with Its Underlying Recordset
        15. Creating Custom Properties and Methods
          1. Creating Custom Properties
            1. Creating and Using a Public Variable as a Form Property
            2. Creating and Using Custom Properties with PropertyLet and PropertyGet Routines
          2. Creating Custom Methods
          3. Getting Things Going with a Startup Form
          4. Building a Splash Screen
        16. Summary
      10. 10. Advanced Report Techniques
        1. Why This Chapter Is Important
        2. Events Available for Reports, and When to Use Them
          1. The Open Event
          2. The Close Event
          3. The Activate Event
          4. The Deactivate Event
          5. The NoData Event
          6. The Page Event
          7. The Error Event
        3. Order of Events for Reports
        4. Events Available for Report Sections, and When to Use Them
          1. The Format Event
          2. The Print Event
          3. The Retreat Event
          4. Order of Section Events
        5. Programmatically Manipulating Report Sections
        6. Special Report Properties
          1. MoveLayout
          2. NextRecord
          3. PrintSection
          4. Interaction of MoveLayout, NextRecord, and PrintSection
          5. FormatCount
          6. PrintCount
          7. HasContinued
          8. WillContinue
        7. Controlling the Printer
          1. The Printer Object
          2. The Printers Collection
        8. Practical Applications of Report Events and Properties
          1. Changing a Report’s RecordSource
          2. Working with Report Filters
          3. Working with the Report Sort Order
          4. Using the Same Report to Display Summary, Detail, or Both
          5. Numbering Report Items
          6. Printing Multiple Labels
          7. Determining Where a Label Prints
          8. Building a Report from a Crosstab Query
          9. Printing the First and Last Page Entries in the Page Header
          10. Creating a Multifact Crosstab Report
        9. Summary
      11. 11. Advanced Query Techniques
        1. Why This Chapter Is Important
        2. Action Queries
          1. Update Queries
          2. Delete Queries
          3. Append Queries
          4. Make Table Queries
          5. Special Notes About Action Queries
          6. Using Action Queries Versus Processing Records with Code
        3. Special Query Properties
          1. Unique Values
          2. Unique Records
          3. Top Values
        4. Optimizing Queries
          1. Understanding the Query Compilation Process
          2. Analyzing a Query’s Performance
          3. Things You Can Do to Improve a Query’s Performance
          4. Rushmore Technology
            1. Important Notes About Rushmore
        5. Crosstab Queries
          1. Creating a Crosstab Query with the Crosstab Query Wizard
          2. Creating a Crosstab Query Without the Crosstab Query Wizard
          3. Creating Fixed Column Headings
          4. Important Notes About Crosstab Queries
        6. Outer Joins
        7. Self Joins
        8. Understanding SQL
          1. What Is SQL, and Where Did It Come From?
          2. What Do You Need to Know About SQL?
          3. SQL Syntax
          4. The SELECT Statement
            1. The SELECT Clause
            2. The FROM Clause
            3. The WHERE Clause
            4. The ORDER BY Clause
            5. The JOIN Clause
            6. Self Joins
            7. Non-equi Joins
            8. ALL, DISTINCTROW, and DISTINCT Clauses
            9. The TOP Predicate
            10. The GROUP BY Clause
            11. The HAVING Clause
          5. Applying What You Have Learned
            1. Using the Graphical QBE Grid as a Two-Way Tool
            2. Including SQL Statements in VBA Code
        9. Union Queries
          1. The ALL Keyword
          2. Sorting the Query Results
          3. Using the Graphical QBE to Create a Union Query
          4. Important Notes about Union Queries
        10. Pass-Through Queries
        11. The Propagation of Nulls and Query Results
        12. Subqueries
        13. Using SQL to Update Data
          1. The UPDATE Statement
          2. The DELETE Statement
          3. The INSERT INTO Statement
          4. The SELECT INTO Statement
        14. Using SQL for Data Definition
          1. The CREATE TABLE Statement
          2. The CREATE INDEX Statement
          3. The ALTER TABLE Statement
          4. The DROP INDEX Statement
          5. The DROP TABLE Statement
        15. Using the Result of a Function as the Criteria for a Query
        16. Passing Parameter Query Values from a Form
        17. Jet 4.0 ANSI-92 Extensions
          1. Table Extensions
            1. Creating Defaults
            2. Creating Check Constraints
            3. Implementing Cascading Referential Integrity
            4. Controlling Fast Foreign Keys
            5. Implementing Unicode String Compression
            6. Controlling Autonumber Fields
          2. View and Stored Procedures Extensions
          3. Transaction Extensions
          4. Security Extensions
          5. Archive Payments
          6. Show All Payments
          7. Create State Table
        18. Summary
      12. 12. Advanced VBA Techniques
        1. Why This Chapter Is Important
        2. What Are User-Defined Types, and Why Would You Use Them?
          1. Declaring a User-Defined Type
          2. Creating a Type Variable
          3. Storing Information from a Record in a Form into a Type
          4. Retrieving Information from the Elements of a Type
        3. Working with Constants
          1. Defining Your Own Constants
            1. Scoping Symbolic Constants
          2. Working with Intrinsic Constants
        4. Working with Arrays
          1. Declaring and Working with Fixed Arrays
          2. Declaring and Working with Dynamic Arrays
          3. Passing Arrays as Parameters
        5. Advanced Function Techniques
          1. Passing by Reference Versus Passing by Value
          2. Optional Parameters: Building Flexibility into Functions
          3. Named Parameters: Eliminate the Need to Count Commas
          4. Recursive Procedures
          5. Using Parameter Arrays
        6. Working with Empty and Null
          1. Working with Empty
          2. Working with Null
        7. Creating and Working with Custom Collections
          1. Creating a Collection
          2. Adding Items to a Collection
          3. Accessing an Item in a Collection
          4. Removing Items from a Collection
          5. Iterating Through the Elements of a Collection
        8. Low-Level File Handling
        9. Understanding and Effectively Using Compilation Options
          1. Compile on Demand
        10. Importing and Exporting Code Modules
        11. Working with Project Properties
          1. Examples of Null, the DoCmd Object, and Intrinsic Constants
          2. An Example of Using a Type Structure
        12. Summary
      13. 13. Exploiting the Power of Class Modules
        1. Exploring the Benefits of Class Modules
        2. Object Orientation—An Introduction
        3. Creating and Using a Class Module
          1. Adding Properties
          2. Adding Methods
          3. Instantiating and Using the Class
          4. Property Let and Get—Adding Properties the Right Way
          5. Setting Values with Property Set
        4. Creating Multiple Class Instances
        5. The Initialize and Terminate Events
          1. Initialize
          2. Terminate
        6. Working with Enumerated Types
        7. Building Hierarchies of Classes
        8. Adding a Parent Property to Classes
        9. The Implements Keyword
        10. Working with Custom Collections
          1. Creating a Collection
          2. Adding Items to a Collection
          3. Looping Through the Elements of a Custom Collection
          4. Referencing Items in a Collection
          5. Removing Items from a Collection
        11. Adding Your Own Events
          1. The FileInformation Class
            1. Using a Collection to Manipulate Multiple Instances of the FileInformation Class
          2. Data Access Class
          3. System Information Class
        12. Summary
      14. 14. What Are ActiveX Data Objects and Data Access Objects, and Why Are They Important?
        1. Why This Chapter Is Important
        2. Using ActiveX Data Objects Versus Data Access Objects
        3. Examining the ActiveX Data Object Model
          1. The Connection Object
          2. The Recordset Object
          3. The Command Object
        4. Understanding ADO Recordset Types
          1. The CursorType Parameter
          2. The LockType Parameter
          3. The Options Parameter
          4. Consistent Versus Inconsistent Updates
          5. Selecting a Cursor Location
          6. Working with the Supports Method
        5. Working with ADO Recordset Properties and Methods
          1. Examining Record-Movement Methods
          2. Detecting the Limits of a Recordset
          3. Counting the Number of Records in a Recordset
          4. Sorting, Filtering, and Finding Records
            1. Sorting a Recordset
            2. Filtering a Recordset
            3. Finding a Specific Record in a Recordset
            4. Working with Variables in Strings
          5. Using the AbsolutePosition Property
          6. Using the Bookmark Property
          7. Running Parameter Queries
          8. Refreshing Recordset Data
          9. Working with Persisting Recordsets
        6. Modifying Table Data Using ADO Code
          1. Changing Record Data One Record at a Time
          2. Performing Batch Updates
          3. Making Bulk Changes
          4. Deleting an Existing Record
          5. Adding a New Record
        7. Creating and Modifying Database Objects Using ADO Code
          1. Adding a Table Using Code
          2. Removing a Table Using Code
          3. Establishing Relationships Using Code
          4. Creating a Query Using Code
        8. Examining the Data Access Object Model
          1. Workspaces
          2. Users
          3. Groups
          4. Databases
          5. TableDefs
          6. Indexes
          7. QueryDefs
          8. Fields
          9. Parameters
          10. Recordsets
          11. Relations
          12. Containers
          13. Documents
          14. Properties
          15. Errors
        9. Getting to Know DBEngine
        10. Using CurrentDB()
        11. Understanding DAO Recordset Types
          1. Dynasets
          2. Snapshots
          3. Tables
        12. Selecting Among the Types of DAO Recordset Objects Available
        13. Working with DAO Recordset Properties and Methods
          1. Creating a Recordset Variable
          2. Using Arguments to Open a Recordset
          3. Examining Record-Movement Methods
          4. Detecting the Limits of a Recordset
          5. Counting the Number of Records in a Recordset
          6. Sorting, Filtering, and Finding Records
            1. Sorting a Recordset
            2. Filtering a Recordset
            3. Finding a Specific Record Within a Recordset
          7. Using the AbsolutePosition Property
          8. Using the Bookmark Property
          9. Using the RecordsetClone Property
          10. Running Parameter Queries
        14. Modifying Table Data Using DAO Code
          1. Changing Record Data One Record at a Time
          2. Making Bulk Changes
          3. Deleting an Existing Record
          4. Adding a New Record
          5. Using the LastModified Property
        15. Creating and Modifying Database Objects Using DAO Code
          1. Adding a Table Using Code
          2. Removing a Table Using Code
          3. Establishing Relationships Using Code
          4. Creating a Query Using Code
        16. Using the DAO Containers Collection
          1. Using Recordset Methods on a Data-Entry Form
        17. Summary
    7. II. What to Do When Things Don’t Go As Planned
      1. 15. Debugging: Your Key to Successful Development
        1. Why This Chapter Is Important
        2. Avoiding Bugs
          1. Option Explicit
          2. Strong-Typing
          3. Naming Standards
          4. Variable Scoping
          5. Bugs Happen!
        3. Harnessing the Power of the Immediate Window
          1. Testing Values of Variables and Properties
          2. Setting Values of Variables and Properties
          3. Clearing the Immediate Window
          4. Practicing with the Built-In Functions
          5. Executing Subroutines, Functions, and Methods
          6. Printing to the Immediate Window at Runtime
        4. Invoking the Debugger
        5. Using Breakpoints to Troubleshoot
        6. Stepping Through Code
          1. Using Step Into
          2. Executing Until the Next Breakpoint Is Reached
          3. Using Step Over
          4. Using Step Out
        7. Setting the Next Statement to Execute
        8. Using the Calls Window
        9. Working with the Locals Window
        10. Working with Watch Expressions
          1. Using Auto Data Tips
          2. Using a Quick Watch
          3. Adding a Watch Expression
          4. Editing a Watch Expression
          5. Breaking When an Expression Is True
          6. Breaking When an Expression Changes
        11. Continuing Execution After a Runtime Error
        12. Looking At Gotchas with the Immediate Window
        13. Using Assertions
        14. Debugging Tips
        15. Summary
      2. 16. Error Handling: Preparing for the Inevitable
        1. Why This Chapter Is Important
        2. Implementing Error Handling
        3. Using On Error Statements
          1. Using On Error Goto
            1. Including the Error Number and Description in the Error Handler
            2. Using On Error Goto 0
          2. Using On Error Resume Next
        4. Using Resume Statements
          1. The Resume Statement
          2. The Resume Next Statement
          3. The Resume <LineLabel> Statement
        5. Clearing an Error
        6. Examining the Cascading Error Effect
        7. Using the Err Object
        8. Raising an Error
          1. Generating an Error on Purpose
          2. Creating User-Defined Errors
        9. Using the Errors Collection
        10. Creating a Generic Error Handler
          1. Logging the Error
          2. Determining the Appropriate Response to an Error
          3. Creating an Error Form
          4. Printing the Error Form
        11. Preventing Your Own Error Handling from Being Invoked
        12. Creating a Call Stack
        13. Building a Custom Error Handler Class
        14. Working with Error Events
        15. Creating a List of Error Codes and Descriptions
        16. Summary
      3. 17. Optimizing Your Application
        1. Why This Chapter Is Important
        2. Introducing Optimization
        3. Modifying Hardware and Software Configurations
          1. Hardware, Hardware, More Hardware, Please!
            1. RAM, RAM—That’s All I Need!
            2. Defragment Your User’s Hard Disk
            3. Compact Your Database
            4. Don’t Use Compressed Drives
            5. Tune Virtual Memory: Tweak the Swap File
            6. Run Access and Your Application Locally
            7. Do Everything You Can to Make Windows Itself Faster
          2. Change Access’s Software Settings
        4. What Jet 3.5 Did to Improve Performance
        5. Understanding What Jet 4.0 Does to Improve Performance
        6. Letting the Performance Analyzer Determine Problem Areas
        7. Designing Tables to Optimize Performance
          1. Why Be Normal?
          2. I Thought You Just Told Me to Normalize
          3. Index, Index, Index!
          4. Select the Correct Data Type
        8. Designing Queries to Optimize Performance
        9. Making Coding Changes to Improve Performance
          1. Eliminate Variants and Use the Smallest Data Type Possible
          2. Use Specific Object Types
          3. Use Inline Code
          4. Toggle Booleans Using Not
          5. Use the Built-In Collections
          6. Use the Len Function
          7. Use True and False Instead of 0
          8. Use Transactions...Sometimes?
          9. Eliminate Unused Dim and Declare Statements
          10. Eliminate Unused Code
          11. Use Variables to Refer to Properties, Controls, and Data Access Objects
          12. Use With...End With
          13. Resolve Variable Outside a Loop
          14. Use the Me Keyword
          15. Use String Functions When VBA Provides a Variant and String Alternative
          16. Use Dynamic Arrays
          17. Use Constants When They Are Available
          18. Use Bookmarks
          19. Set Object Variables Equal to Nothing
          20. Use Action Queries Instead of Looping Through Recordsets
          21. Deliver Your Application with the Modules Compiled
          22. Retaining the Compiled State
          23. Distribute Your Application as an MDE
          24. Organize Your Modules
        10. Designing Forms and Reports to Improve Performance
          1. Designing Forms
          2. Designing Reports
        11. Summary
    8. III. Developing Multiuser and Enterprise Applications
      1. 18. A Strategy to Developing Access Applications
        1. Why This Chapter Is Important
        2. Splitting Databases into Tables and Other Objects
        3. Basing Forms and Reports on Queries or Embedded SQL Statements
        4. Understanding the Access Runtime Engine
          1. Features of the MOD
          2. Differences Between the Standard and Runtime Versions of Access
          3. Steps for Preparing an Application for Distribution
            1. Basing Your Application Around Forms
            2. Adding Start-Up Options to Your Database
            3. Securing Your Application
            4. Building Error Handling in to Your Applications
            5. Adding Custom Help
            6. Building Custom Command Bars
          4. The Access Runtime Engine: Summing It Up
        5. Using an EXE Versus Access Database: What It Means to You
        6. Understanding the Importance of Securing Your Database
        7. Using Access as a Front End
          1. Things You Need to Worry About in Converting to Client/Server
          2. Benefits and Costs of Client/Server Technology
          3. Your Options When Using Access as a Front End
          4. What Are the Considerations for Migrating to a Client/Server Environment?
        8. Summary
      2. 19. Using External Data
        1. Why This Chapter Is Important
        2. Importing, Linking, and Opening Files: When and Why
          1. Selecting an Option
          2. Looking at Supported File Formats
        3. Importing External Data
          1. Using the User Interface
          2. Using Code
            1. Importing Database Data Using Code
            2. Importing Text Data Using Code
            3. Importing Spreadsheet Data Using Code
        4. Creating a Link to External Data
          1. Using the User Interface
            1. Using the Database Splitter to Create Links
            2. Creating Links to Access Tables
            3. Creating Links to Other Types of Tables
          2. Using Code
            1. Providing Connection Information
            2. Creating the Link
        5. Opening an External Table
          1. Providing Connection Information
          2. Opening the Table
        6. Understanding Windows Registry Settings
        7. Using the Jet OLEDB:Link Provider String
        8. Working with Passwords
        9. Refreshing and Removing Links
          1. Updating Links That Have Moved
          2. Deleting Links
        10. Looking at Special Considerations
          1. dBASE
          2. Text Data
        11. Troubleshooting
          1. Connection Problems
          2. Temp Space
        12. Looking at Performance Considerations and Links
        13. Working with HTML Documents
          1. Splitting the Database Using the Database Splitter
          2. Refreshing Links
        14. Summary
      3. 20. Developing Multiuser and Enterprise Applications
        1. Why This Chapter Is Important
        2. Designing Your Application with Multiuser Issues in Mind
          1. Multiuser Design Strategies
            1. Strategies for Installing Access
          2. Strategies for Installing Your Application
          3. The Basics of Linking to External Data
        3. Understanding Access’s Locking Mechanisms
        4. Understanding the Client/Server Model
        5. Deciding Whether to Use the Client/Server Model
          1. Dealing with a Large Volume of Data
          2. Dealing with a Large Number of Concurrent Users
          3. Demanding Faster Performance
          4. Handling Increased Network Traffic
          5. Implementing Backup and Recovery
          6. Focusing on Security
          7. Sharing Data Among Multiple Front-End Tools
          8. Understanding What It All Means
        6. The Roles Access Plays in the Application Design Model
          1. The Front End and Back End as Access MDB Files
          2. The Front End as an MDB File Using Links to Communicate to a Back End
          3. The Front End Using SQL Pass-Through to Communicate to a Back End
          4. The Front End Executing Procedures Stored on a Back End
          5. The Front End as a Microsoft Access Data Project Communicating Directly to a Back End
        7. Learning the Client/Server Buzzwords
        8. Upsizing: What to Worry About
          1. Indexes
          2. AutoNumber Fields
          3. Default Values
          4. Validation Rules
          5. Relationships
          6. Security
          7. Table and Field Names
          8. Reserved Words
          9. Case Sensitivity
          10. Properties
          11. Visual Basic Code
        9. Proactively Preparing for Upsizing
        10. Introduction to Transaction Processing
        11. Understanding the Benefits of Transaction Processing
        12. Modifying the Default Behavior of Transaction Processing
        13. Implementing Explicit Transaction Processing
        14. Introduction to Replication
        15. Uses of Replication
          1. Sharing Data Among Offices
          2. Sharing Data Among Dispersed Users
          3. Reducing Network Load
          4. Distributing Application Updates
          5. Backing Up the Data in Your Application
        16. Understanding When Replication Isn’t Appropriate
        17. Understanding the Implementation of Replication
          1. The Access User Interface
          2. Briefcase Replication
          3. The Replication Manager
          4. ADO Code
          5. Programs That Support Replication Using DAO
        18. Summary
    9. IV. Black-Belt Programming
      1. 21. Using ActiveX Controls
        1. Why This Chapter Is Important
        2. Incorporating ActiveX Controls in Access 2002
          1. Installing an ActiveX Control
          2. Registering an ActiveX Control
          3. Adding ActiveX Controls to Forms
          4. Understanding and Managing the Control Reference in Your Access Application
        3. Setting Properties of an ActiveX Control at Design Time
        4. Coding Events of an ActiveX Control
        5. Using the Calendar Control
          1. Properties of a Calendar Control
          2. Methods of a Calendar Control
        6. Using the UpDown Control
        7. Using the StatusBar Control
        8. Using the Common Dialog Control
        9. Using the Rich Textbox Control
        10. Using the TabStrip Control
        11. Using the ImageList Control
        12. Licensing and Distribution Issues
          1. Adding a Calendar to the Report Criteria Dialog
        13. Summary
      2. 22. Automation: Communicating with Other Applications
        1. Why This Chapter Is Important
        2. Defining Some Automation Terms
        3. Declaring an Object Variable to Reference Your Application
        4. Creating an Automation Object
          1. Declaring an Object Variable
        5. Manipulating an Automation Object
          1. Setting and Retrieving Properties
          2. Executing Methods
        6. Early Binding Versus Late Binding
          1. CreateObject and GetObject
        7. Controlling Excel from Access
        8. Closing an Excel Automation Object
        9. Creating a Graph from Access
        10. Controlling Word from Access
          1. Using Word to Generate a Mass Mailing
          2. Using Word to Overcome the Limitations of Access as a Report Writer
        11. Controlling PowerPoint from Access
        12. Automating Outlook from Access
        13. Controlling Access from Other Applications
        14. Summary
      3. 23. Exploiting the Power of the Windows API
        1. Why This Chapter Is Important
        2. Declaring an External Function to the Compiler
          1. Passing Parameters to DLL Functions
            1. Passing by Reference Versus Passing by Value
            2. Passing String Parameters
          2. Aliasing a Function
            1. Function Calls and Invalid Characters
            2. DLL Functions with Duplicate Names
            3. Eliminating the “A” Suffix Required by ANSI
            4. Unique Procedure Names in an Access Library or Module
            5. Calling Functions Referenced with Ordinal Numbers
        3. Working with Constants and Types
          1. Working with Constants
          2. Working with Types
          3. Using the Windows API Text Viewer
            1. Loading a Text File
            2. Loading a Database File
            3. Pasting API Declares, Types, and Constants
        4. Calling DLL Functions: Important Issues
        5. Examining the Differences Between 16-Bit and 32-Bit APIs
        6. Using API Functions
        7. Manipulating the Windows Registry
        8. Getting Information About the Operating Environment
        9. Determining Drive Types and Available Drive Space
        10. Summary
      4. 24. Creating Your Own Libraries
        1. Why This Chapter Is Important
        2. Preparing a Database to Be a Library
          1. Structuring Code Modules for Optimal Performance
          2. Writing Library Code That Runs
          3. Compiling the Library
        3. Creating a Reference
          1. Creating a Library Reference
          2. Creating a Runtime Reference
            1. Calling a Function from a Library at Runtime
            2. Using the LoadOnStartup Key
          3. Creating an Explicit Reference
          4. Creating a Reference Using VBA Code
        4. Debugging a Library Database
        5. Securing an Access Library
        6. Summary
      5. 25. Using Builders, Wizards, and Menu Add-Ins
        1. Why This Chapter Is Important
        2. Using Builders
          1. Looking at Design Guidelines
          2. Creating a Builder
            1. Writing a Builder Function
            2. Designing a Builder Form
            3. Registering a Builder
              1. Manually Adding Entries to the Windows Registry
            4. Automating the Creation of Registry Entries
        3. Using Wizards
          1. Looking at Design Guidelines
          2. Creating a Wizard
          3. Getting the Wizard Ready to Go
        4. Using Menu Add-Ins
          1. Looking at Design Guidelines
          2. Creating a Menu Add-In
        5. Summary
      6. 26. An Introduction to Access and the Internet/Intranet
        1. Why This Chapter Is Important
        2. Saving Database Objects as HTML
          1. Saving Table Data as HTML
          2. Saving Query Results as HTML
          3. Saving Forms as HTML
          4. Saving Reports as HTML
        3. Linking to HTML Files
        4. Importing HTML Files
        5. Understanding Data Access Pages
        6. Creating Data Access Pages
          1. Creating a Data Access Page Using the AutoPage Feature
          2. Creating a Data Access Page Using a Wizard
          3. Creating a Data Access Page from an Existing Web Page
          4. Creating a Data Access Page from Scratch
        7. Modifying Important Properties of a Data Access Page
          1. The ConnectionFile Property
          2. The ConnectionString Property
          3. The DataEntry Property
          4. The MaxRecords Property
          5. The RecordsetType Property
          6. The UseRemoteProvider Property
        8. Modifying the Record Navigation Control Properties
          1. The RecordSource Property
          2. First, Previous, Next, and Last Buttons
          3. The New Button
          4. The Delete Button
          5. The Save Button
          6. The Undo Button
          7. The Sort Ascending and Sort Descending Buttons
          8. The ShowToggleFilterButton Button
        9. Creating Grouped Data Access Pages
        10. Augmenting Data Access Pages with VBScript
          1. Important Data Access Page Events
          2. VBScript Versus VBA
          3. VBScript Versus JavaScript
        11. Summary
    10. V. Adding Polish to Your Application
      1. 27. Database Security Made Easy
        1. Why This Chapter Is Important
        2. Implementing Share-Level Security: Establishing a Database Password
        3. Encrypting a Database
        4. Establishing User-Level Security
          1. Step 1: Creating a Workgroup
            1. Understanding the Workgroup: The System.mdw File
            2. Establishing a Workgroup
            3. Joining a Different Workgroup
          2. Step 2: Changing the Password for the Admin User
          3. Step 3: Creating an Administrative User
          4. Step 4: Making the Administrative User a Member of the Admins Group
          5. Step 5: Exiting Access and Logging On as the System Administrator
          6. Step 6: Removing the Admin User from the Admins Group
          7. Step 7: Assigning a Password to the System Administrator
          8. Step 8: Opening the Database You Want to Secure
          9. Step 9: Running the Security Wizard
          10. Step 10: Creating Users and Groups
            1. Adding Groups
            2. Adding Users
            3. Assigning Users to the Appropriate Groups
          11. Step 11: Assigning Rights to Users and Groups
        5. Securing VBA Code with a Password
        6. Providing an Additional Level of Security: Creating an MDE
        7. Securing a Database Without Requiring Users to Log On
        8. Looking at Special Issues
          1. Passwords
          2. Security and Linked Tables
          3. Ownership
          4. Printing Security
        9. Summary
      2. 28. Advanced Security Techniques
        1. Why This Chapter Is Important
        2. Maintaining Groups Using Code
          1. Adding a Group
          2. Removing a Group
        3. Using Code to Maintain Users
          1. Adding Users
          2. Assigning Users to a Group
          3. Removing Users from a Group
          4. Removing Users
        4. Listing All Groups and Users
          1. Listing All Groups
          2. Listing All Users
          3. Listing Users in a Specific Group
          4. Determining Whether a User Is a Member of a Specific Group
        5. Working with Passwords
          1. Assigning Passwords to Users
          2. Listing Users Without Passwords
          3. Ensuring That Users Have Passwords
        6. Assigning and Revoking Permissions to Objects Using Code
          1. Determining Whether a Group Has Permission to an Object
          2. Determining Whether a User Has Permission to an Object
          3. Determining Whether a User Has Implicit Rights to an Object
          4. Setting Permissions to New Objects
          5. Manipulating Database Permissions
        7. Encrypting a Database Using Code
        8. Accomplishing Field-Level Security Using Queries
        9. Prohibiting Users and Groups from Creating Objects
          1. Prohibiting Users and Groups from Creating Objects
        10. Accomplishing Prohibited Tasks by Logging On as a Different User
        11. Securing Client/Server Applications
        12. Security and Replication
        13. Implementing Security with SQL
          1. Maintaining Users with SQL
            1. Using SQL to Add a User
            2. Using SQL to Add a User to a Group
            3. Using SQL to Remove a User from a Group
            4. Using SQL to Remove a User
            5. Using SQL to Change a Password
          2. Maintaining Groups with SQL
            1. Using SQL to Add a Group
            2. Using SQL to Remove a Group
          3. Using SQL to Assign and Remove Permissions
        14. DAO and Security
        15. Choosing Between ADOX, SQL, and DAO
        16. Summary
      3. 29. Documenting Your Application
        1. Why This Chapter Is Important
        2. Preparing Your Application to Be Self-Documenting
          1. Documenting Your Tables
          2. Documenting Your Queries
          3. Documenting Your Forms
          4. Documenting Your Reports
          5. Documenting Your Macros
          6. Documenting Your Modules
          7. Using Database Properties to Document the Overall Database
        3. Using the Database Documenter
          1. Using the Documenter Options
          2. Producing Documentation in Other Formats
        4. Writing Code to Create Your Own Documentation
        5. Summary
      4. 30. Maintaining Your Application
        1. Why This Chapter Is Important
        2. Compacting Your Database
          1. Using the User Interface
          2. Using a Shortcut
          3. Compacting Whenever a Database Closes
          4. Using the CompactDatabase Method of the JetEngine Object
          5. Using the CompactRepair Method of the Application Object
        3. Converting an Access Database
        4. Detecting Broken References
        5. Summary
      5. 31. Third-Party Tools That Can Help You to Get Your Job Done Effectively
        1. Why This Chapter Is Important
        2. Total Access CodeTools
        3. Total Access Analyzer
        4. Total Visual Agent
        5. Total Access Components
        6. Total Access Statistics
        7. Total Access Detective
        8. Total Visual SourceBook
        9. Total Access Memo
        10. Solutions::Explorer
        11. Component Toolbox OCX
        12. Solutions::Schedule
        13. Solutions::PIM Professional
        14. Summary
      6. 32. Distributing Your Application
        1. Why This Chapter Is Important
        2. Introducing the Packaging Wizard
        3. Loading the Packaging Wizard Add-In
        4. Distributing Your Application to Run with a Full Copy of Access
        5. Using Full Versions Versus Runtime Versions of Access
          1. Hidden Database Window
          2. Hidden Design Views
          3. Built-In Toolbars Not Supported
          4. Unavailable Menu Items
          5. Disabled Keys
        6. Preparing Your Database for Use with the Access Runtime Version
          1. Creating the Application
            1. Building the Application Around Forms and Menus
            2. Building Error Handling into the Application
            3. Adding Custom Menus and Toolbars
            4. Setting Startup Options
            5. Securing the Application
            6. Distributing Your Application as an MDE
          2. Adding Custom Help to the Application
          3. Testing and Debugging the Application
          4. Running and Testing the Application with the /Runtime Command-Line Switch
          5. Running the Packaging Wizard
            1. Identifying Application and Package Information
            2. Supplying Application Information
            3. List of Files to Search for Dependency Information
            4. Inclusion of the Runtime
            5. Modifying Installation Locations
            6. Inclusion of Database Components
            7. Selecting Start Menu Items to be Created
            8. Choosing a File to Run When the Installation Is Complete
            9. The Final Step
          6. Deploying the Application
          7. Distributing the Application
        7. Looking at Other Issues
          1. Automating the Process of Linking to Tables
          2. Using Replication to Efficiently Distribute Your Application
        8. Summary
    11. VI. Appendixes
      1. A. Table Structures
        1. The tblClients Table
        2. The tblClientAddresses Table
        3. The tblAddressTypes Table
        4. The tblClientPhones Table
        5. The tblPhoneTypes Table
        6. The tblCorrespondence Table
        7. The tblCorrespondenceTypes Table
        8. The tblTerms Table
        9. The tblContactTypes Table
        10. The tblCompanyInfo Table
        11. The tblEmployees Table
        12. The tblErrorLog Table
        13. The tblErrors Table
        14. The tblExpenseCodes Tables
        15. The tblPaymentMethods Table
        16. The tblPayments Table
        17. The tblProjects Table
        18. The tblTimCardExpenses Table
        19. The tblTimeCardHours Table
        20. The tblTimeCards Table
        21. The tblWorkCodes Table
      2. B. Naming Conventions