Sitemap Main Page
Part I: The Basics of Access Development
Chapter 1. Access As a Development Tool
What Types of Applications Can You Develop in Access?
Getting to Know the Database Objects
How Do I Get Started Developing an Access Application?
What's New in Access 2002 and 2003?
Practical Examples: The Application Design for a Computer Consulting Firm
Chapter 2. What Every Developer Needs to Know About Databases and Tables
Selecting the Appropriate Field Type for Your Data
Working with the Lookup Feature
Using Indexes to Improve Performance
Access Tables and the Internet
Adding Smart Tags to Your Tables
Creating a Pivot Table or Pivot Chart from a Table
Database Specifications and Limitations
Table Specifications and Limitations
Chapter 3. Relationships: Your Key to Data Integrity
Introduction to Relational Database Design
Establishing Relationships in Access
Establishing Referential Integrity
Looking at the Benefits of Relationships
Examining Indexes and Relationships
Chapter 4. What Every Developer Needs to Know About Query Basics
What Is a Query, and When Should You Use One?
Everything You Need to Know About Query Basics
Refining Your Query with Criteria
Working with Dates in Criteria
Understanding How You Can Update Query Results
Building Queries Based on Multiple Tables
Getting Help from the Expression Builder
Summarizing Data with 'Totals' Queries
Excluding Fields from the Output
Refining Your Queries with Field, Field List, and Query Properties
Building Parameter Queries When You Don't Know the Criteria at Design Time
Building Parameter Queries When You Don't Know the Criteria at Design Time
Adding Smart Tags to Your Queries
Creating a Pivot Table or Pivot Chart from a Query
Query Specifications and Limitations
Chapter 5. What Every Developer Needs to Know About Forms
Working with the Form Design Window
Selecting the Correct Control for the Job
What Form Properties Are Available, and Why Should You Use Them?
What Control Properties Are Available, and Why Should You Use Them?
Bound, Unbound, and Calculated Controls
Using Expressions to Enhance Your Forms
The Command Button Wizards: Programming Without Typing
Building Forms Based on More Than One Table
Basing Forms on Queries: The Why and How
Adding Smart Tags to Your Forms
Creating a Pivot Table or Pivot Chart from a Form
Form Specifications and Limitations
Practical Examples: Designing Forms for Your Application
Chapter 6. What Every Developer Needs to Know About Reports
Working with the Report Design Window
Selecting the Correct Control for the Job
What Report Properties Are Available and Why Use Them?
What Control Properties Are Available and Why Use Them?
Unbound, Bound, and Calculated Controls
Using Expressions to Enhance Your Reports
Building Reports Based on More Than One Table
Working with Sorting and Grouping
Improving Performance and Reusability by Basing Reports on Stored Queries or Embedded SQL Statements
Access Reports and the Internet
Report Specifications and Limitations
Practical Examples: Building Reports Needed for Your Application
Chapter 7. VBA: An Introduction
What Are Access Class Modules, Standard Modules, Form Modules, and Report Modules?
Using the Line Continuation Character
Using the VBA Control Structures
Passing Parameters and Returning Values
Passing Parameters and Returning Values
Executing Procedures from the Module Window
The 'DoCmd' Object: Performing Macro Actions
Working with Built-In Functions
Tools for Working in the Visual Basic Editor
Practical Examples: Event Routines, User-Defined Functions, and Subroutines
Chapter 8. Objects, Properties, Methods, and Events Explained
Understanding Objects, Properties, Events, and Methods
Using the Object Browser to Learn About Access's Objects
Properties and Methods Made Easy
Declaring and Assigning Object Variables
Understanding the Differences Between Objects and Collections
Passing Objects to Subroutines and Functions
Determining the Type of a Control
Special Properties That Refer to Objects
Understanding Access's Object Model
Properties Introduced with Access 2002 and Access 2003
Practical Examples: Working with Objects
Chapter 9. Advanced Form Techniques
What Are the Form Events, and When Do You Use Them?
What Are the Section and Control Events, and When Do You Use Them?
What Types of Forms Can I Create, and When Are They Appropriate?
Adding Custom Menus, Toolbars, and Shortcut Menus to Your Forms
Taking Advantage of Built-In, Form-Filtering Features
Including Objects from Other Applications: Linking Versus Embedding
Switching a Form's 'RecordSource'
Power Combo Box and List Box Techniques
Synchronizing a Form with Its Underlying Recordset
Creating 'Custom' Properties and Methods
Practical Examples: Applying Advanced Techniques to Your Application
Chapter 10. Advanced Report Techniques
Events Available for Reports, and When to Use Them
Events Available for Report Sections, and When to Use Them
Programmatically Manipulating Report Sections
Practical Applications of Report Events and Properties
Practical Examples: Practicing What You Learned
Chapter 11. Advanced Query Techniques
The Propagation of 'Null's and Query Results
Using the Result of a Function as the Criteria for a Query
Passing 'Parameter' Query Values from a Form
Passing 'Parameter' Query Values from a Form
Practical Examples: Applying These Techniques in Your Application
Chapter 12. Advanced VBA Techniques
What Are User-Defined Types, and Why Would You Use Them?
Working with 'Empty' and 'Null'
Creating and Working with Custom Collections
Understanding and Effectively Using Compilation Options
Importing and Exporting Code Modules
Working with Project Properties
Practical Examples: Putting Advanced Techniques to Use
Chapter 13. Exploiting the Power of Class Modules
Object OrientationAn Introduction
Creating and Using a Class Module
Setting Values with 'Property Set'
Creating Multiple Class Instances
The 'Initialize' and 'Terminate' Events
Building Hierarchies of Classes
Adding a 'Parent' Property to Classes
Working with Custom Collections
Practical Examples: Class Modules
Chapter 14. What Are ActiveX Data Objects and Data Access Objects, and Why Are They Important?
Understanding ADO Recordset Types
Working with ADO Recordset Properties and Methods
Modifying Table Data Using ADO Code
Creating and Modifying Database Objects Using ADO Code
Understanding DAO Recordset Types
Selecting Among the Available Types of DAO Recordset Objects
Working with DAO 'Recordset' Properties and Methods
Modifying Table Data Using DAO Code
Creating and Modifying Database Objects Using DAO Code
Using the DAO 'Containers' Collection
Practical Examples: Applying These Techniques to Your Application
Part II: What to Do When Things Don't Go as Planned
Chapter 15. Debugging: Your Key to Successful Development
Harnessing the Power of the Immediate Window
Using Breakpoints to Troubleshoot
Setting the Next Statement to Execute
Working with the Locals Window
Working with Watch Expressions
Continuing Execution After a Runtime Error
Looking At Gotchas with the Immediate Window
Practical Examples: Debugging Real Applications
Chapter 16. Error Handling: Preparing for the Inevitable
Examining the Cascading Error Effect
Creating a Generic Error Handler
Preventing Your Own Error Handling from Being Invoked
Building a Custom Error Handler Class
Creating a List of Error Codes and Descriptions
Practical Examples: Incorporating Error Handling
Chapter 17. Optimizing Your Application
Modifying Hardware and Software Configurations
Understanding What Jet 4.0 Does to Improve Performance
Letting the Performance Analyzer Determine Problem Areas
Designing Tables to Optimize Performance
Optimizing the Performance of Your Queries
Making Coding Changes to Improve Performance
Designing Forms and Reports to Improve Performance
Practical Examples: Improving the Performance of Your Applications
Part III: Developing Multiuser and Enterprise Applications
Chapter 18. A Strategy to Developing Access Applications
Splitting Databases into Tables and Other Objects
Basing Forms and Reports on Queries or Embedded SQL Statements
Understanding the Access Runtime Engine
Using an EXE Versus Access Database: What It Means to You
Understanding the Importance of Securing Your Database
Practical Examples: Applying the Strategy to the Computer Consulting Firm Application
Chapter 19. Using External Data
Importing, Linking, and Opening Files: When and Why
Creating a Link to External Data
Understanding Windows Registry Settings
Using the 'Jet OLEDB:Link Provider' String
Sharing Data with SharePoint Team Services
Looking at Special Considerations
Looking at Performance Considerations and Links
Practical Examples: Working with External Data from Within Your Application
Chapter 20. Developing Multiuser and Enterprise Applications
Designing Your Application with Multiuser Issues in Mind
Understanding Access's Locking Mechanisms
Understanding the Client/Server Model
Deciding Whether to Use the Client/Server Model
The Roles Access Plays in the Application Design Model
Learning the Client/Server Buzzwords
Proactively Preparing for Upsizing
An Introduction to Transaction Processing
Understanding the Benefits of Transaction Processing
Modifying the Default Behavior of Transaction Processing
Implementing Explicit Transaction Processing
Understanding When Replication Isn't Appropriate
Understanding the Implementation of Replication
Practical Examples: Getting Your Application Ready for an Enterprise Environment
Part IV: Black-Belt Programming
Chapter 21. Using ActiveX Controls
Incorporating ActiveX Controls in Access 2003
Setting Properties of an ActiveX Control at Design Time
Coding Events of an ActiveX Control
Using the Common Dialog Control
Using the Rich Textbox Control
Licensing and Distribution Issues
Practical Examples: Implementing ActiveX Controls
Chapter 22. Automation: Communicating with Other Applications
Defining Some Automation Terms
Declaring an Object Variable to Reference Your Application
Manipulating an Automation Object
Early Binding Versus Late Binding
Closing an Excel Automation Object
Controlling PowerPoint from Access
Automating Outlook from Access
Controlling Access from Other Applications
Practical Examples: Using Automation to Extend the Functionality of Your Applications
Chapter 23. Exploiting the Power of the Windows API
Declaring an External Function to the Compiler
Working with Constants and Types
Calling DLL Functions: Important Issues
Practical Examples: Using Windows API Functions in Your Applications
Chapter 24. Creating Your Own Libraries
Preparing a Database to Be a Library
Practical Examples: Building a Library for Your Application
Chapter 25. Using Builders, Wizards, and Menu Add-Ins
Practical Examples: Designing Your Own Add-Ins
Chapter 26. An Introduction to Access and the Internet/Intranet
Saving Database Objects as HTML
Understanding Data Access Pages
Modifying Important Properties of a Data Access Page
Modifying the Record Navigation Control Properties
Creating Grouped Data Access Pages
Augmenting Data Access Pages with VBScript
Part V: Adding Polish to Your Application
Chapter 27. Database Security Made Easy
Implementing Share-Level Security: Establishing a Database Password
Establishing User-Level Security
Securing VBA Code with a Password
Providing an Additional Level of Security: Creating an MDE
Securing a Database Without Requiring Users to Log On
Practical Examples: Securing a Copy of the Northwind Database
Chapter 28. Advanced Security Techniques
Assigning and Revoking Permissions to Objects Using Code
Encrypting a Database Using Code
Accomplishing Field-Level Security Using Queries
Prohibiting Users and Groups from Creating Objects
Accomplishing Prohibited Tasks by Logging On as a Different User
Securing Client/Server Applications
Implementing Security with SQL
Choosing Between ADOX, SQL, and DAO
Practical Examples: Applying Advanced Techniques to Your Application
Chapter 29. Documenting Your Application
Preparing Your Application to Be Self-Documenting
Writing Code to Create Your Own Documentation
Practical Examples: Applying What You Learned
Chapter 30. Maintaining Your Application
Practical Examples: Maintaining Your Application
Chapter 31. Third-Party Tools That Can Help You Get Your Job Done Effectively
Practical Examples: Using Third-Party Tools with Your Applications
Chapter 32. Distributing Your Application
Introducing the Packaging Wizard
Loading the Packaging Wizard Add-In
Distributing Your Application to Run with a Full Copy of Access
Using Full Versions Versus Runtime Versions of Access
Preparing Your Database for Use with the Access Runtime Version
The 'tblClientAddresses' Table
The 'tblCorrespondenceTypes' Table
The 'tblTimeCardExpenses' Table
Appendix B. Naming Conventions