You are previewing Alison Balter's Mastering Access 97 Development, Second Edition.
O'Reilly logo
Alison Balter's Mastering Access 97 Development, Second Edition

Book Description

One of the premier corporate database applications, Access, is a powerful application that can be programmed and customized. But to do that, readers need information. And this book provides that knowledge by showing users how to develop simple and complex applications for Access.

Table of Contents

  1. Copyright
    1. Dedication
  2. What's New in This Edition
  3. Acknowledgments
  4. About the Author
    1. Tell Us What You Think!
  5. Introduction
  6. I. Building a Foundation for Your Access Applications
    1. 1. Introduction to Access Development
      1. 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 Scalable Product
      2. What Exactly Is a Database?
      3. 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. Macros: A Means of Automating Your System
        6. Modules: The Foundation to the Application Development Process
      4. Object Naming Conventions
      5. Hardware Requirements
        1. What Hardware Does Your System Require?
        2. What Hardware Does the User's System Require?
      6. 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
        7. A Practical Example of Application Design: A Computer Consulting Firm
      7. Summary
    2. 2. A Strategy for Developing Access Applications
      1. Why Strategize?
      2. Splitting Tables and Other Objects
      3. Basing Forms and Reports on Queries
      4. Understanding the Access Runtime Engine
        1. Features of the ODE
        2. Differences Between the Standard and Runtime Versions of Access
        3. Preparing an Application for Distribution
        4. The Access Runtime Engine: Summing It Up
      5. EXE Versus Access Database: What It Means to You
      6. 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 All This Means to You Right Now
      8. Applying the Strategy to the Computer Consulting Firm Application
      9. Summary
    3. 3. What Every Developer Needs to Know About Tables
      1. Building a New Table
        1. Building a Table with a Wizard
        2. Designing a Table from Scratch
        3. Building a Table from a Datasheet
      2. 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: 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
      3. 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: Make the User Enter a Value
        9. Allow Zero Length: Accommodate Situations with Nonexistent Data
        10. Indexed: Speeding Up Searches
      4. The All-Important Primary Key
      5. Working with the Lookup Feature
      6. Working with Table Properties
      7. Using Indexes to Improve Performance
      8. Access Tables and the Internet
        1. The Hyperlink Field Type
        2. Saving Table Data as HTML
      9. Practical Examples: Designing the Tables Needed for the Computer Consulting Firm's Time and Billing Application
      10. Summary
    4. 4. Relationships: Your Key to Data Integrity
      1. Understanding Relationships
      2. Examining the Types of Relationships
        1. One-to-Many
        2. One-to-One
        3. Many-to-Many
      3. Establishing Relationships
        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. Practical Examples: Establishing the Relationships Between the Tables Included in the Time and Billing Database
      8. Summary
    5. 5. What Every Developer Needs to Know About Query Basics
      1. What Is a Query and When Should You Use One?
      2. Everything You Need to Know About Selecting Fields
        1. Removing a Field from the Query Grid
        2. Inserting a Field After the Query Is Built
        3. Moving a Field to a Different Location on the Query Grid
        4. Saving Your Query
      3. Ordering Your Query Result
        1. Sorting by More than One Field
      4. Refining Your Query with Criteria
      5. Working with Dates in Criteria
      6. Understanding How Query Results Can Be Updated
      7. Building Queries Based on Multiple Tables
        1. Pitfalls of Multitable Queries
        2. Row Fix-up in Multitable Queries
      8. Creating Calculated Fields
      9. Getting Help from the Expression Builder
      10. Summarizing Data with Totals Queries
      11. Excluding Fields from the Output
      12. Nulls and Query Results
      13. Refining Your Queries with Field and Query Properties
        1. Field Properties: Changing the Behavior of a Field
      14. Field List Properties
        1. Query Properties Changing the Behavior of the Overall Query
      15. Building Parameter Queries When You Don't Know the Criteria at Design Time
      16. Practical Examples: Building Queries Needed by the Time and Billing Application for the Computer Consulting Firm
      17. Summary
    6. 6. What Every Developer Needs to Know About Form Basics
      1. Uses of Forms
      2. Anatomy of a Form
      3. Creating a New Form
        1. Creating a Form with the Form Wizard
        2. Creating a Form from Design View
      4. 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 with One Another
          4. Snap to Grid
          5. Power Sizing Techniques
          6. Controlling Object Spacing
        4. Modifying Object Tab Order
      5. Selecting the Correct Control for the Job
        1. Labels
        2. Text Boxes
        3. Combo Boxes
        4. List Boxes
        5. Checkboxes
        6. Option Buttons
        7. Toggle Buttons
        8. Option Groups
      6. Control Morphing
        1. Text Box to Combo Box
        2. Combo Box to List Box
      7. What Form Properties Are Available and Why Use Them?
        1. Working with the Properties Window
        2. Working with the Important Form Properties
          1. Format Properties of a Form
        3. Data Properties of a Form
        4. Other Properties of a Form
      8. 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
      9. Bound, Unbound, and Calculated Controls
      10. Using Expressions to Enhance Your Forms
      11. The Command Button Wizards: Programming Without Typing
      12. 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
      13. Basing Forms on Queries: The Why and How
        1. Embedding SQL Statements Versus Stored Queries
      14. Access Forms and the Internet
        1. Adding a Hyperlink to a Form
        2. Saving a Form as HTML
        3. Saving a Form as Microsoft IIS 1-2
      15. Practical Examples: Designing Forms for Your Application
        1. Designing the Clients Form
        2. Designing the Time Cards Form
        3. Designing the Payments Form
        4. Designing the Projects Form
        5. What's Ahead
      16. Summary
    7. 7. What Every Developer Needs to Know About Report Basics
      1. 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
      2. Anatomy of a Report
      3. Creating a New Report
        1. Creating a Report with the Report Wizard
        2. Creating a Report from Design View
      4. 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
      5. 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
      6. 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
      7. 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
      8. Inserting Page Breaks
      9. Unbound, Bound, and Calculated Controls
      10. Using Expressions to Enhance Your Reports
      11. 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
      12. 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
      13. Improving Performance and Reusability by Basing Reports on Stored Queries
      14. Access Reports and the Internet
        1. Adding a Hyperlink to a Report
        2. Saving a Report as HTML
      15. Practical Examples: Building Reports Needed for Your Application
        1. Designing the rptClientListing Report
        2. Designing the rptTimeSheet Report
      16. Summary
    8. 8. VBA 101: The Basics of VBA
      1. VBA Explained
      2. Access Class Modules, Standard Modules, Form Modules, and Report Modules Explained
        1. Anatomy of a Module
        2. Option Explicit
        3. Event Procedures Made Easy
        4. Creating Functions and Subroutines
        5. Calling Event and User-Defined Procedures
        6. Scope and Lifetime of Procedures
          1. Public Procedures
          2. Private Procedures
          3. Scope Precedence
          4. Static Procedures
        7. Naming Conventions for Procedures
      3. 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
      4. Adding Comments to Your Code
      5. Using the Line-Continuation Character
      6. 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
      7. Passing Parameters and Returning Values: An Introduction
      8. Working with Built-In Functions
        1. Format
        2. Instr
        3. Left
        4. Right
        5. Mid
        6. UCase
        7. DatePart
        8. DateDiff
        9. DateAdd
        10. Functions Made Easy with the Object Browser
      9. Tools for Working with the Module Window
        1. List Properties and Methods
        2. List Constants
        3. Quick Info
        4. Parameter Information
        5. Complete Word
        6. Definition
      10. Practical Examples: Event Routines, User-Defined Functions, and Subroutines Needed for the Time and Billing Application
      11. Summary
    9. 9. Advanced VBA Techniques
      1. Navigation Tips and Tricks
        1. Mysteries of the Coding Environment Solved
        2. Zoom Shift+F2
        3. Find and Replace
        4. Help
        5. Splitting the Code Window
        6. Full Module View
        7. Using Bookmarks to Save Your Place
      2. Executing Procedures from the Module Window
      3. The DoCmd Object: Performing Macro Actions
      4. 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
      5. Working with Constants
        1. Defining Your Own Constants
          1. Scoping Symbolic Constants
        2. Working with Intrinsic Constants
      6. Working with Arrays
        1. Declaring and Working with Fixed Arrays
        2. Declaring and Working with Dynamic Arrays
      7. 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
      8. Property Let and Get: Working with Custom Properties
        1. Property Let
        2. Property Get
      9. Class Modules
      10. Working with Empty and Null
        1. Working with Empty
        2. Working with Null
      11. Understanding and Effectively Using Compilation Options
        1. Compile On Demand
        2. Compile Loaded Modules
        3. Compile All Modules
      12. Customizing the IDE
        1. Code Color, Fonts, and Sizes
        2. Coding Options
      13. Practical Examples: Putting Advanced Techniques to Use in the Time and Billing Application
        1. Examples of Null, the DoCmd Object, and Intrinsic Constants
        2. An Example of Using a Type Structure
      14. Summary
    10. 10. The Real Scoop on Objects, Properties, and Events
      1. Understanding Access's Object Model
        1. The Application Object
      2. The Forms Collection
        1. The Reports Collection
        2. The Modules Collection
        3. The Screen Object
        4. The DoCmd Object
      3. 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?
      4. Using the Object Browser to Learn About Access's Objects
        1. How to Use the Object Browser
        2. Pasting Code Templates into a Procedure
      5. Referring to Objects
      6. Properties and Methods Made Easy
        1. Default Properties
      7. Declaring and Assigning Object Variables
        1. Object Variables Versus Regular Variables
        2. Generic Versus Specific Object Variables
        3. Cleaning Up After Yourself
      8. 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...NEXT: Performing the Same Command on Multiple Objects
        3. Collections Versus Containers and Documents
        4. Creating Custom Collections
          1. Defining Custom Collections
          2. Adding Items to and Removing Items from a Custom Collection
          3. Looping Through the Elements of a Custom Collection
          4. Referring to a Specific Item in a Collection
      9. Using the New Keyword
      10. Passing Objects to Functions and Subroutines
      11. Returning to a Unique Item in a Collection
      12. Determining the Type of a Control
      13. Special Properties That Refer to Objects
      14. Practical Examples of Working with Objects
        1. Bringing Up Multiple Instances of the Projects Form
        2. Enabling and Disabling Command Buttons
      15. Summary
    11. 11. What Are Macros and When Do You Need Them?
      1. Why Learning About Macros Is Important
      2. The Basics of Creating and Running a Macro
        1. Macro Actions
        2. Macro Action Arguments
        3. Macro Names
        4. Macro Conditions
      3. Running an Access Macro
        1. Running a Macro from the Macro Design Window
        2. Running a Macro from the Macros Tab
        3. Triggering a Macro from a Form or Report Event
      4. Modifying an Existing Macro
        1. Inserting New Macro Actions
        2. Deleting Macro Actions
        3. Moving Macro Actions
        4. Copying Macro Actions
      5. Documenting Your Macro: Adding Comments
      6. Testing a Macro
      7. When You Should Use Macros and When You Shouldn't
      8. Converting a Macro to VBA Code
      9. Creating an AutoExec Macro
      10. Creating an AutoKeys Macro
      11. The DoCmd Object
      12. Practical Examples: Adding an AutoExec Macro to the Time and Billing Application
      13. Summary
    12. 12. Advanced Query Concepts
      1. Action Queries
        1. Update Queries
        2. Delete Queries
        3. Append Queries
        4. Make Table Queries
        5. Special Notes About Action Queries
        6. Action Queries Versus Processing Records with Code
      2. Special Query Properties
        1. Unique Values
        2. Unique Records
        3. Top Values
      3. Optimizing Queries
        1. 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
      4. Crosstab Queries
        1. Creating a Crosstab Query with the Crosstab Query Wizard
        2. Creating a Crosstab Query Without the Crosstab Query Wizard
        3. Fixed Column Headings
        4. Important Notes About Crosstab Queries
      5. Outer Joins
      6. Self-Joins
      7. 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 Clause
        5. The FROM Clause
        6. The WHERE Clause
        7. The ORDER BY Clause
        8. The JOIN Clause
        9. ALL, DISTINCTROW, and DISTINCT Clauses
        10. The GROUP BY Clause
          1. The HAVING Clause
        11. Applying What You Have Learned
          1. Using the Graphical QBE Grid as a Two-Way Tool
          2. Including SQL Statements in VBA Code
      8. Union Queries
      9. Pass-Through Queries
      10. The Propagation of Nulls and Query Results
      11. Subqueries
      12. Using the Result of a Function as the Criteria for a Query
      13. Passing Parameter Query Values from a Form
      14. Practical Examples: Applying These Techniques in Your Application
        1. Archive Payments
        2. Show All Payments
        3. Create State Table
      15. Summary
    13. 13. Let's Get More Intimate with Forms: Advanced Techniques
      1. What Are the Form Events and When Do You Use Them?
        1. Current
        2. BeforeInsert
        3. BeforeUpdate
        4. AfterUpdate
        5. AfterInsert
        6. Delete
        7. BeforeDelConfirm
        8. AfterDelConfirm
        9. Open
        10. Load
        11. Resize
        12. Unload
        13. Close
        14. Activate
        15. Deactivate
        16. GotFocus
        17. LostFocus
        18. Click
        19. DblClick
        20. MouseDown
        21. MouseMove
        22. MouseUp
        23. KeyDown
        24. KeyUp
        25. KeyPress
        26. Error
        27. Filter
        28. ApplyFilter
        29. Timer
        30. 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?
      2. 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?
      3. Referring to Me
      4. 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 Tab Pages
          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
      5. Using Built-In Dialog Boxes
        1. Message Boxes
          1. The MsgBox Statement
          2. The MsgBox Function
        2. Input Boxes
        3. Common Dialog Boxes
      6. 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
      7. Taking Advantage of Built-in Form-Filtering Features
      8. Including Objects from Other Applications: Linking Versus Embedding
        1. Bound OLE Objects
        2. Unbound OLE Objects
      9. OpenArgs
      10. Switching a Form's Record Source
      11. Power Combo Box and List Box Techniques
        1. Handling the NotInList Event
        2. Populating a Combo Box or List Box with a Callback Function
        3. Handling Multiple Selections in a List Box
      12. Power Subform Techniques
        1. Referring to Subform Controls
      13. Synchronizing a Form with Its Underlying Recordset
      14. 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
      15. Practical Examples: Applying Advanced Techniques to Your Application
        1. Building an AutoExec Routine to Launch the Application
        2. Building a Splash Screen
      16. Summary
    14. 14. Let's Get More Intimate with Reports: Advanced Techniques
      1. 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
      2. Order of Events for Reports
      3. 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
      4. Special Report Properties
        1. MoveLayout
        2. NextRecord
        3. PrintSection
        4. Interaction of MoveLayout, NextRecord, and PrintSection
        5. FormatCount
        6. PrintCount
        7. HasContinued
        8. WillContinue
      5. Practical Applications of Report Events and Properties
        1. Changing a Report's RecordSource
        2. Using the Same Report to Display Summary, Detail, or Both
        3. Printing Multiple Labels
        4. Determining Where a Label Prints
        5. Building a Report from a Crosstab Query
        6. Printing the First and Last Page Entries in the Page Header
        7. Creating a Multifact Crosstab Report
      6. Practical Examples
      7. Summary
    15. 15. What Are the Data Access Objects and Why Are They Important?
      1. Understanding Data Access Objects
      2. 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
      3. Getting to Know DBEngine
      4. Using CurrentDB()
      5. Understanding Recordset Types
        1. Dynasets
        2. Snapshots
        3. Tables
      6. Selecting Among the Types of Recordset Objects Available
      7. Working with 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 in a Recordset
        7. Using the AbsolutePosition Property
        8. Using the Bookmark Property
        9. Using the RecordsetClone Property
        10. Running Parameter Queries
      8. Modifying Table Data Using 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
      9. Creating and Modifying Database Objects Using Code
        1. Adding a Table Using Code
        2. Removing a Table Using Code
        3. Establishing Relationships Using Code
        4. Creating a Query Using Code
      10. Using the Containers Collection
      11. Practical Examples: Applying These Techniques to Your Application
        1. Creating a Report Selection Form
        2. Using Recordset Methods on a Data-Entry Form
      12. Summary
  7. II. What To Do When Things Don't Go As Planned
    1. 16. Debugging: Your Key to Successful Development
      1. Understanding the Importance of Debugging
      2. Avoiding Bugs
        1. Option Explicit
        2. Strong-Typing
        3. Naming Standards
        4. Variable Scoping
        5. Bugs Happen!
      3. Harnessing the Power of the Debug Window
        1. Testing Values of Variables and Properties
        2. Setting Values of Variables and Properties
        3. Clearing the Debug Window
        4. Practicing with the Built-In Functions
        5. Executing Subroutines, Functions, and Methods
        6. Printing to the Debug 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 Pane
      10. Working with Watch Expressions
        1. Using Auto Data Tips
        2. Using 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 Debug Window
      13. Practical Examples: Debugging Real Applications
      14. Summary
    2. 17. Handling Those Dreaded Runtime Errors
      1. Implementing Error Handling
      2. Working with Error Events
      3. Using On Error Statements
        1. Using On Error Goto
        2. Including the Error Number and Description in the Error Handler
        3. Using On Error Resume Next
        4. Using On Error Goto 0
      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. Practical Examples: Incorporating Error Handling
      13. Summary
  8. III. Preparing Your Applications for a Multiuser Environment
    1. 18. Developing for a Multiuser Environment
      1. 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
      2. Understanding Access's Locking Mechanisms
      3. Locking and Refreshing Strategies
        1. Default Record Locking
          1. Determining the Locking Mechanism for a Query
          2. Determining the Locking Mechanism for a Form or Report
        2. Default Open Mode
        3. Number of Update Retries
        4. ODBC Refresh Interval
        5. Refresh Interval
        6. Update Retry Interval
        7. Refreshing Versus Requerying Data
      4. Form Locking Strategies
        1. No Locks
        2. All Records
        3. Edited Record
      5. Recordset Locking
        1. Pessimistic Locking
        2. Optimistic Locking
      6. Effectively Handling Locking Conflicts
        1. Errors with Pessimistic Locking
        2. Coding Around Pessimistic Locking Conflicts
        3. Errors with Optimistic Locking or New Records
        4. Coding Around Optimistic Locking Conflicts
        5. Testing to See Who Has a Record Locked
      7. Testing a Record for Locking Status
      8. Using Code to Refresh or Requery
      9. Understanding the .LDB File
      10. Creating Custom Counters
      11. Using Unbound Forms
      12. Using Replication to Improve Performance
      13. Practical Examples: Making an Application Multiuser Ready
      14. Summary
    2. 19. Using External Data
      1. Understanding External Data
      2. Importing, Linking, and Opening: When and Why
        1. Selecting an Option
        2. Looking At Supported File Formats
      3. Importing External Data
        1. Importing External Data via the User Interface
        2. Importing External Data 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. Creating a Link 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. Creating a Link 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 Connection String
      8. Working with Passwords
      9. Refreshing and Removing Links
        1. Updating Links That Have Moved
        2. Deleting Links
      10. Creating an External Table
      11. Looking At Special Considerations
        1. dBASE
        2. FoxPro
        3. Text Data
      12. Troubleshooting
        1. Connection Problems
        2. Temp Space
      13. Looking At Performance Considerations and Links
      14. Working with HTML Documents
      15. Practical Examples: Working with External Data from within Your Application
        1. Splitting the Database By Using the Database Splitter
        2. Refreshing Links
      16. Summary
    3. 20. Client/Server Techniques
      1. Understanding the Client/Server Model
      2. 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
      3. Roles Access Plays in the Application Design Model
        1. The Front-End and Back-End
        2. The Front-End 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 Using ODBCDirect to Communicate to a Back-End
      4. Learning the Client/Server Buzzwords
      5. 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
      6. Proactively Preparing for Upsizing
      7. Defining an ODBC Data Source
      8. Connecting to a Database Server
      9. Working with Linked Tables
        1. Linking to External Tables via the User Interface
        2. Linking to External Tables via Code
        3. Linking to Views Rather Than Tables
        4. Using Pass-Through Queries
          1. Creating a Pass-Through Query with the User Interface
          2. Executing a Pass-Through Query Using Code
          3. Executing a Stored Procedure
        5. Opening a Server Table Directly
        6. Using ODBCDirect to Access Client/Server Data
      10. Summary
    4. 21. Client/Server Strategies
      1. Developing Client/Server Strategies
      2. Selecting the Best Recordset Type
      3. Using Forward-Scrolling Snapshots
      4. Using Key Set Fetching
      5. Using Pass-Through Queries and Stored Procedures
      6. Using ODBCDirect
      7. Preconnecting to the Server
      8. Reducing the Number of Connections
      9. Optimizing Data Handling
      10. Optimizing Queries and Forms
        1. Optimizing Queries
        2. Optimizing Forms
      11. Practical Examples: Using Client/Server Strategies
      12. Summary
    5. 22. Transaction Processing
      1. Understanding Transaction Processing
      2. Understanding the Benefits
      3. Modifying the Default Behavior
      4. Implementing Explicit Transaction Processing
      5. Looking At Transaction Processing Issues
        1. Realizing That Transactions Occur in a Workspace
        2. Making Sure the Data Source Supports Transactions
        3. Nesting Transactions
        4. Neglecting to Explicitly Commit Transactions
        5. Checking Available Memory
        6. Using Forms with Transactions
      6. Using Transaction Processing in a Multiuser Environment
      7. Using Transaction Processing in a Client/Server Environment
        1. Implicit Transactions
        2. Explicit Transactions
        3. Nested Transactions
        4. Lock Limits
        5. Negative Interactions with Server-Specific Transaction Commands
      8. Practical Examples: Improving the Integrity of the Time and Billing Application Using Transaction Processing
      9. Summary
    6. 23. Optimizing Your Application
      1. Understanding Optimization
      2. 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
      3. Understanding What Jet 3.5 Does to Improve Performance
      4. Letting the Performance Analyzer Determine Problem Areas
      5. 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
      6. Designing Queries to Optimize Performance
      7. Changing Code 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 Length Function
        7. Use True and False Instead of Zero
        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. Use the Me Keyword
        14. Use String Functions When Possible
        15. Use Dynamic Arrays
        16. Use Constants When Possible
        17. Use Bookmarks
        18. Set Object Variables Equal to Nothing
        19. Use Action Queries Instead of Looping Through Recordsets
        20. Deliver Your Application with the Modules Compiled
        21. Retaining the Compiled State
        22. Distribute Your Application as an MDE
        23. Organize Your Modules
      8. Designing Forms and Reports to Improve Performance
        1. Designing Forms
        2. Designing Reports
      9. Practical Examples: Improving the Performance of the Time and Billing Application
      10. Summary
    7. 24. Replication Made Easy
      1. What Is Replication?
      2. 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
      3. Understanding When Replication Isn't Appropriate
      4. An Overview of the Implementation of Replication
        1. The Access User Interface
        2. Briefcase Replication
        3. The Replication Manager
        4. DAO Code
        5. Programs That Support Replication Using DAO
      5. The Replication Architecture: What Makes Replication Tick?
        1. The Tracking Layer
        2. The Microsoft Replication Manager
        3. The Synchronizer
        4. File System Transport
        5. The Briefcase Reconciler
        6. Registry Entries
      6. Understanding Replication Topologies
        1. Star Topology
        2. Ring Topology
        3. Fully Connected Topology
        4. Linear Topology
        5. Hybrid Topology
      7. Changes That Replication Makes to Your Database
        1. Fields Added to Each Replicated Table
        2. System Tables Added to the Database
        3. Properties Added to the Database Objects
        4. Changes to Sequential AutoNumber Fields
        5. Changes to the Size of the Database
      8. Making a Database Replicable
        1. Rendering a Database Replicable with the Access User Interface
        2. Rendering a Database Replicable with the Windows 95 Briefcase
      9. Preventing Objects from Being Replicated
      10. Creating Additional Replicas
        1. Creating Additional Replicas with the Access User Interface
        2. Creating Additional Replicas with the Windows 95 Briefcase
      11. Synchronizing Replicas
        1. Synchronizing Databases with the Access User Interface
        2. Synchronizing Databases with the Windows 95 Briefcase
      12. Resolving Replication Conflicts
      13. Using the Replication Manager
        1. Running the Replication Manager for the First Time
        2. Replicating a Database with the Replication Manager
        3. Creating Replicas with the Replication Manager
        4. Partial Replication
        5. Synchronizing Replicas with the Replication Manager
          1. Remote Synchronizations
          2. Scheduled Synchronizations
        6. Reviewing the Synchronization History
        7. Working with Synchronization Properties
      14. Implementing Replication by Using Code
        1. Making a Database Replicable by Using Code
        2. Flagging an Object as Local
        3. Creating a Replica by Using Code
        4. Creating a Partial Replica Using Code
        5. Synchronizing a Database by Using Code
        6. Handling Conflicts by Using Code
      15. Practical Examples: Managing the Time and Billing Application with Replication
      16. Summary
  9. IV. Extending the Power of Access
    1. 25. Automation: Communicating with Other Applications
      1. Understanding Automation
      2. Defining Some Automation Terms
      3. Declaring an Object Variable to Reference Your Application
      4. Using CreateObject and GetObject
        1. CreateObject
        2. GetObject
      5. Manipulating an Automation Object
        1. Setting and Retrieving Properties
        2. Executing Methods
      6. Controlling Excel from Access
      7. Closing an Automation Object
      8. Creating a Graph from Access
      9. Controlling Word from Access
      10. Controlling PowerPoint from Access
      11. Controlling Access from Other Applications
      12. Practical Examples: Using Automation to Extend the Functionality of the Time and Billing Application
      13. Summary
    2. 26. Using ActiveX Controls
      1. ActiveX Controls Explained
      2. Incorporating ActiveX Controls in Access 97
        1. Registering an ActiveX Control
      3. Adding ActiveX Controls to Forms
        1. Understanding and Managing the Control Reference in Your Access Application
      4. Setting Properties of an ActiveX Control at Design Time
      5. Coding Events of an ActiveX Control
      6. The Calendar Control
        1. Properties of a Calendar Control
        2. Methods of a Calendar Control
      7. The UpDown Object
      8. The StatusBar Control
      9. The Common Dialog Control
      10. The Rich Textbox Control
      11. The TabStrip Control
      12. The ImageList Control
      13. Licensing and Distribution Issues
      14. Practical Examples: Implementing ActiveX Controls
        1. Adding a Calendar to the Report Criteria Dialog
      15. Summary
    3. 27. Access and the Internet
      1. What's New with Access and the Internet
      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. Static Versus Dynamic HTML Formats
      6. The Publish to the Web Wizard
      7. Working with HTML Templates
      8. Sending Data to an FTP or HTTP Server
        1. Importing or Linking to Data on FTP and HTTP Servers
        2. Exporting an Object to an FTP Server
      9. Taking Advantage of Hyperlinks
        1. Storing Hyperlinks in Tables
        2. Placing Hyperlinks on Forms and Reports
      10. The Microsoft WebBrowser Control
      11. The Web Toolbar
      12. Replication Over the Internet
      13. Summary
    4. 28. Managing Application Development with Visual SourceSafe
      1. What Is Visual SourceSafe?
      2. How Do I Install Visual SourceSafe?
      3. Using Visual SourceSafe: An Overview
      4. The Logistics of Managing a Project with Visual SourceSafe
        1. Adding a Database to Visual SourceSafe
          1. Understanding the Objects Placed Under SourceSafe Control
        2. Creating a Database from a SourceSafe Project
        3. Checking in and Checking out Database Objects
        4. Getting the Latest Version
        5. Adding Objects to Visual SourceSafe
        6. Refreshing an Object's Status
      5. Leveraging the Power of Visual SourceSafe
        1. Showing Differences Between Modules
        2. Showing an Object's History
        3. Reverting to an Object's Previous Version
      6. Changes Visual SourceSafe Makes to Access's Behavior
        1. The Compact Command
        2. Opening a Database
        3. Closing a Database
        4. Opening an Object in Design View
        5. Saving a New Object or Using Save As on an Existing Object
        6. Renaming an Object
        7. Deleting an Object
      7. Understanding the Limitations of Visual SourceSafe
      8. Practical Examples: Putting the Time and Billing Application Under SourceSafe Control
      9. Summary
    5. 29. Leveraging Your Application: Creating Your Own Libraries
      1. Understanding Library Databases
      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
          1. Creating a Runtime Reference
          2. Calling a Function from a Library
        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. Practical Examples: Building a Library for Your Application
      7. Summary
    6. 30. Using Builders, Wizards, and Menu Add-Ins
      1. Defining Builders, Wizards, and Menu Add-Ins
      2. Using Builders
        1. Looking At Design Guidelines
        2. Creating a Builder
        3. Writing a Builder Function
        4. Designing a Builder Form
        5. Registering a Builder
          1. Manually Adding Entries to the Windows Registry
          2. 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. Practical Examples: Designing Your Own Add-Ins
      6. Summary
  10. V. Putting the Final Polish on Your Application
    1. 31. Using External Functions: The Windows API
      1. Using the Win32 API
      2. Declaring an External Function to the Compiler
        1. Passing by Reference versus Passing by Value
        2. Passing String Parameters
        3. Aliasing a Function
          1. Function Calls and Invalid Characters
          2. DLL Functions with Duplicate Names
          3. Eliminating the A 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
        4. Loading a Text File
        5. Loading a Database File
        6. 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. Getting Information about the Operating Environment
      8. Determining Drive Types and Available Drive Space
      9. Practical Examples: Applying What You Have Learned to the Time and Billing Application
      10. Summary
    2. 32. Database Security Made Easy
      1. Reviewing Your Options for Securing a Database
      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: Creating an Administrative User
        3. Step 3: Making the Administrative User a Member of the Admins Group
        4. Step 4: Changing the Password for the Admin User
        5. Step 5: Removing the Admin User from the Admins Group
        6. Step 6: Exiting Access and Logging On as the System Administrator
        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. Providing an Additional Level of Security: Creating an MDE File
      6. Looking At Special Issues
        1. Passwords
        2. Security and Linked Tables
        3. Ownership
        4. Printing Security
      7. Practical Examples: Securing the Time and Billing Application
      8. Summary
    3. 33. Complex Security Issues
      1. Controlling Security Via Code
      2. Maintaining Groups By Using Code
        1. Adding a Group
        2. Removing a Group
      3. Maintaining Users By Using Code
        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
      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 By Using Code
      7. Encrypting a Database By Using Code
      8. Accomplishing Field-Level Security By Using Queries
      9. Prohibiting Users from Creating Objects
        1. Prohibiting Users from Creating Databases
        2. Prohibiting Users from Creating Other Objects
      10. Accomplishing Prohibited Tasks By Logging on as a Different User
      11. Securing Client/Server Applications
      12. Examining Security and Replication
      13. Practical Examples: Applying Advanced Techniques to Your Application
      14. Summary
    4. 34. Documenting Your System
      1. Understanding Why You Should Document
      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
      3. Using Database Properties to Document the Overall Database
      4. Using the Database Documenter
        1. Using the Documenter Options
        2. Producing Documentation in Other Formats
      5. Writing Code to Create Your Own Documentation
      6. Practical Examples: Applying What You Learned to the Time and Billing Application
      7. Summary
    5. 35. Database Maintenance Techniques
      1. Understanding What Database Maintenance Is All About
      2. Compacting Your Database
        1. Using the User Interface
        2. Using a Shortcut
        3. Using Code
      3. Repairing Your Database
        1. Using the User Interface
        2. Using a Shortcut
        3. Using Code
      4. Summary
    6. 36. Developing a Help File
      1. Deciding To Create a Help File
      2. Looking At Help from a User's Perspective
        1. The Contents Tab
        2. The Index Tab
        3. The Find Tab
        4. The Office Assistant
        5. Button Bars
        6. Hotspots
        7. Hypergraphics
        8. Authorable Buttons
      3. Planning the Help File
      4. Building the Help Components
        1. Creating a Topic File
          1. Creating an RTF File
          2. Adding a Help Topic
          3. Creating Topic IDs: The # Footnote
          4. Creating Titles: The $ Footnote
          5. Specifying Search Keywords: The K Footnote
          6. Using Other Tags
          7. Giving It a Test Run: Building Some Help Topics
          8. Adding Nonscrolling Regions
          9. Adding Hotspots
          10. Adding Graphics
          11. Adding Hypergraphics
        2. Creating a Map File
        3. Creating a Contents File
        4. Creating the Help Project File
        5. Preparing the Help Project to be Compiled
          1. Specifying the Help Topic File
          2. Specifying the Map File
          3. Locating Graphics Files
          4. Adding and Customizing Help Windows
          5. Using Other Options
        6. Compiling the Project
      5. Adding Custom Help to Your Applications
      6. Getting Help with Help: Authoring Tools
      7. Practical Examples: Adding Help to the Time and Billing Application
      8. Summary
    7. 37. Distributing Your Application with ODE
      1. Distributing Your Application: An Introduction
      2. Looking At the ODE
        1. Royalty-Free Runtime License
        2. Setup Wizard
        3. Replication Manager
        4. Two-Volume Language Reference
        5. 32-Bit ActiveX Controls
        6. Win32 API Text Viewer
        7. Help Workshop for Windows 95
        8. Microsoft Access Developer Sample CD-ROM
        9. Microsoft Graph Runtime Executable
      3. Distributing Your Application to Run with a Full Copy of Access
      4. 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
      5. Preparing Your Database for Use with the Access Runtime Version
        1. Creating the Application
          1. Building the Application Around Forms
          2. Building Error Handling into the Application
          3. Adding Custom Menus and Toolbars
          4. Setting Startup Options
          5. Securing the Application
        2. Distributing Your Application as an MDE
        3. Adding Custom Help to the Application
        4. Testing and Debugging the Application
        5. Running and Testing the Application with the /Runtime Command Line Switch
        6. Running the Setup Wizard
          1. Viewing the Introductory Screen
          2. Adding Files to be Included on the Distribution Disks
          3. Adding Components
          4. Defining Shortcuts
          5. Adding Registry Values
          6. Designating Access Components
          7. Reordering Components and Setting Their Properties
          8. Setting Key Attributes of the Application
          9. Specifying That a Program Execute After Setup is Completed
          10. Specifying a Location for the Setup Files
        7. Packaging and Distributing the Application
      6. Looking At Other Issues
        1. Automating the Process of Linking to Tables
        2. Using Replication to Efficiently Distribute Your Application
      7. Practical Examples: Distributing the Time and Billing Application
      8. Summary
  11. VI. Appendixes
    1. A. Table Structures
      1. The tblClients table
      2. The tblCompanyInfo Table
      3. The tblEmployees Table
      4. The tblErrorLog Table
      5. The tblErrors Table
      6. The tblExpenseCodes Tables
      7. The tblPaymentMethods Table
      8. The tblPayments Table
      9. The tblProjects Table
      10. The tblTimeCardExpenses Table
      11. The tblTimeCardHours Table
      12. The tblTimeCards Table
      13. The tblWorkCodes Table
    2. B. Naming Conventions