• Compact your database. Compacting can speed up queries because it reorganizes a table's records so that they reside in adjacent database pages ordered by the table's primary key (primary key: One or more fields (columns) whose values uniquely identify each record in a table. A primary key cannot allow Null values and must always have a unique index. A primary key is used to relate a table to foreign keys in other tables.). This will improve the performance of sequential scans of a table's records because the minimum number of database pages will have to be read to retrieve all of the records. After compacting the database, run each query to compile it using the updated table statistics.
• Index (index: A feature that speeds up searching and sorting in a table based on key values and can enforce uniqueness on the rows in a table. The primary key of a table is automatically indexed. Some fields can't be indexed because of their data type.) any field used to set criteria (criteria: Conditions you specify to limit which records are included in the result set of a query or filter.) for the query and index fields on both sides of a join (join: An association between a field in one table or query and a field of the same data type in another table or query. Joins tell the program how data is related. Records that don't match may be included or excluded, depending on the type of join.), or create a relationship (relationship: An association that is established between common fields (columns) in two tables. A relationship can be one-to-one, one-to-many, or many-to-many.) between these fields. When you create relationships, the Microsoft Jet database engine (Microsoft Jet database engine: The part of the Access database system that retrieves and stores data in user and system databases. It can be thought of as a data manager upon which database systems, such as Access, are built.) creates an index on the foreign key (foreign key: One or more table fields (columns) that refer to the primary key field or fields in another table. A foreign key indicates how the tables are related.) if one does not already exist; otherwise, it uses the existing index.

  The Jet database engine automatically optimizes a query that joins an Access table on your hard drive and an ODBC (Open Database Connectivity (ODBC): A standard method of sharing data between databases and programs. ODBC drivers use the standard Structured Query Language (SQL) to gain access to external data.) server table if the Access table is small and the joined fields are indexed. In this case, Access improves performance by requesting only the necessary records from the server. Make sure tables you join from different sources are indexed on the join fields.

• Index the fields you use for sorting.

• Use the Between...And, the In, and the = operators on indexed fields.

• When defining a field in a table, choose the smallest data type (data type: The characteristic of a field that determines what type of data it can hold. Data types include Boolean, Integer, Long, Currency, Single, Double, Date, String, and Variant (default).) appropriate for the data in the field. Also, give fields you'll use in joins (join: An association between a field in one table or query and a field of the same data type in another table or query. Joins tell the program how data is related. Records that don't match may be included or excluded, depending on the type of join.) the same or compatible data types, such as AutoNumber and Number (if the FieldSize property is set to Long Integer).
• When creating a query, add only the fields you need. In fields used to set criteria (criteria: Conditions you specify to limit which records are included in the result set of a query or filter.), clear the Show check box if you don't want to display those fields.
• If you use criteria to restrict the values in a field used in a join between tables with a one-to-many relationship (one-to-many relationship: An association between two tables in which the primary key value of each record in the primary table corresponds to the value in the matching field or fields of many records in the related table.), test whether the query runs faster with the criteria placed on the "one" side or the "many" side of the join. In some queries, you get faster performance by adding the criteria to the field on the "one" side of the join instead of the "many" side.
• Avoid calculated fields (calculated field: A field, defined in a query, that displays the result of an expression rather than displaying stored data. The value is recalculated each time a value in the expression changes.) in subqueries (subquery: An SQL SELECT statement that is inside another select or action query.). If you add a query that contains a calculated field to another query, the expression (expression: Any combination of mathematical or logical operators, constants, functions, and names of fields, controls, and properties that evaluates to a single value. Expressions can perform calculations, manipulate characters, or test data.) in the calculated field may slow performance in the top-level query. In the example below, query Q1 is used as the input for query Q2:

  Q1: SELECT IIF([MyColumn]="Yes","Order Confirmed","Order Not Confirmed") AS X FROM MyTable;
  Q2: SELECT * FROM Q1 WHERE X="Order Confirmed";
  								

  
  

  Because the IIf expression in Q1 cannot be optimized, Q2 also cannot be optimized. If an expression that can't be optimized is nested within a subquery, the entire query cannot be optimized.

  An alternative way to construct the query is as follows:

  Q1: SELECT * FROM MyTable WHERE MyColumn = "Yes";
  								

  
  
• If expressions are necessary in the output, try to place them in a control (control: A graphical user interface object, such as a text box, check box, scroll bar, or command button, that lets users control the program. You use controls to display data or choices, perform an action, or make the user interface easier to read.) on a form or report. For example, you could change the previous query into a parameter query that prompts for the value of MyColumn, and then base a form or report on the query. On the form or report, you could then add a calculated control (calculated control: A control that is used on a form, report, or data access page to display the result of an expression. The result is recalculated each time there is a change in any of the values on which the expression is based.) that displays "Order Confirmed" or "Order Not Confirmed" depending on the value in MyColumn.

  Construct the query as follows:

  PARAMETERS [To see confirmed orders, enter Yes. To see unconfirmed orders, enter No.] Text;
SELECT *
FROM MyTable
WHERE MyColumn = [To see confirmed orders, enter Yes. To see unconfirmed orders, enter No.];

  In the calculated control on the form or report, enter:

  =IIF([MyColumn]="Yes","Order Confirmed","Order Not Confirmed")

• When grouping records by the values in a joined field, specify Group By for the field that's in the same table as the field you're totaling (calculating an aggregate (aggregate function: A function, such as Sum, Count, Avg, or Var, that you use to calculate totals.) on). For example, if you create a query that totals the Quantity field in the Order Details table and groups by OrderID, it's recommended that you specify Group By for the OrderID field in the Order Details table. If you specify Group By for the OrderID field in the Orders table, Access must join all the records first and then perform the aggregate, instead of performing the aggregate and then joining only the necessary fields.

  For greater speed, use Group By on as few fields as possible. As an alternative, use the First function where appropriate.

  If a totals query includes a join, consider grouping the records in one query and adding this query to a separate query that will perform the join. This improves performance in some queries.

• Avoid restrictive query criteria on calculated and nonindexed (index: A feature that speeds up searching and sorting in a table based on key values and can enforce uniqueness on the rows in a table. The primary key of a table is automatically indexed. Some fields can't be indexed because of their data type.) fields whenever possible.

• If the RecordSource property for a form or report is set to an SQL statement (SQL string/statement: An expression that defines an SQL command, such as SELECT, UPDATE, or DELETE, and includes clauses such as WHERE and ORDER BY. SQL strings/statements are typically used in queries and in aggregate functions.), save the SQL statement as a query, and then set the RecordSource property to the name of the query.
• For bulk update queries against ODBC data sources (ODBC data source: Data and the information needed to access that data from programs and databases that support the Open Database Connectivity (ODBC) protocol.), optimize performance on the server by setting the FailOnError Property to Yes.
• If your data doesn't change often, use make-table queries (make-table query: A query (SQL statement) that creates a new table and then creates records (rows) in it by copying records from an existing table.) to create tables from your query results. Use the resulting tables rather than queries as the basis for your forms, reports, or other queries, and make sure you add indexes (index: A feature that speeds up searching and sorting in a table based on key values and can enforce uniqueness on the rows in a table. The primary key of a table is automatically indexed. Some fields can't be indexed because of their data type.) according to the guidelines recommended here.
• Avoid using domain aggregate functions (domain aggregate function: A function, such as DAvg or DMax, that is used to calculate statistics over a set of records (a domain).), such as the DLookup function, to access data from a table that's not in the query. Domain aggregate functions are specific to Access, which means that the Microsoft Jet database engine (Microsoft Jet database engine: The part of the Access database system that retrieves and stores data in user and system databases. It can be thought of as a data manager upon which database systems, such as Access, are built.) can't optimize queries that use them. Instead, add to the query the table that the function was accessing, or create a subquery (subquery: An SQL SELECT statement that is inside another select or action query.).
• If you are creating a crosstab query (crosstab query: A query that calculates a sum, average, count, or other type of total on records, and then groups the result by two types of information: one down the left side of the datasheet and the other across the top.), use fixed column headings whenever possible.

These settings affect all tables and queries, and all text box controls (control: A graphical user interface object, such as a text box, check box, scroll bar, or command button, that lets users control the program. You use controls to display data or choices, perform an action, or make the user interface easier to read.) whose FilterLookup property is set to Database Default.

1. On the Tools menu, click Options.
2. Click the Edit/Find tab, and then set the Filter By Form Defaults according to the performance you want to achieve.
   • If the list of values takes too long to display in nonindexed fields only, try limiting the lists to indexed fields. You can do this by clearing the Local Nonindexed Fields and ODBC Fields check boxes. If the lists take too long to display in indexed fields, clear the Local Indexed Fields check box as well since there are too many records in the indexes for the lists to display quickly.

     Note  If you use the same nonindexed field repeatedly to filter records, consider indexing it to improve filtering and other search operations on the field.

   • If lists aren't displaying the values from indexed or nonindexed fields, check under Show List Of Values In to make sure the appropriate boxes are selected, or try increasing the number in the Don't Display Lists Where More Than This Number Of Records Read box so that it's greater than or equal to the maximum number of records in any nonindexed field in the underlying table.

For each text box control (control: A graphical user interface object, such as a text box, check box, scroll bar, or command button, that lets users control the program. You use controls to display data or choices, perform an action, or make the user interface easier to read.) on a form, you can specify whether the values stored in the field appear on its list in the Filter By Form window.

1. Open a form in Design view (Design view: A window that shows the design of these database objects: tables, queries, forms, reports, macros, and data access pages. In Design view, you can create new database objects and modify the design of existing ones.).
2. Display the property sheet for any text box control.

   How?

   1. Open a table, query, form, report, or data access page (data access page: A Web page, published from Access, that has a connection to a database. In a data access page, you can view, add to, edit, and manipulate the data stored in the database. A page can also include data from other sources, such as Excel.) in Design view (Design view: A window that shows the design of these database objects: tables, queries, forms, reports, macros, and data access pages. In Design view, you can create new database objects and modify the design of existing ones.).
   2. Open the property sheet by doing one of the following:
      • On a form or report, double-click the form selector (form selector: The box where the rulers meet, in the upper-left corner of a form in Design view. Use the box to perform form-level operations, such as selecting the form.) or the report selector (report selector: The box where the rulers meet in the upper-left corner of a report in Design view. Use the box to perform report-level operations, such as selecting the report.).

      

      Form or report selector

      • On a data access page, click Select Page on the Edit menu.
      • On a table or query, click Properties on the toolbar.
      • For a section on a form or report, double-click the section selector (section selector: The box on the left side of a section bar when an object is open in Design view. Use the box to perform section-level operations, such as selecting the section.).

      

      Section selector

      • For a section on a data access page, double-click the section bar.

      

      Section bar

      • To set properties of a query field, click the cell in the Field row, and then click Properties on the toolbar.
      • To set properties of a query field list, click anywhere in the list, and then click Properties on the toolbar.
      • To set properties for the body of a data access page, click above the first section, and then click Properties on the toolbar.
      • To set properties for a control (control: A graphical user interface object, such as a text box, check box, scroll bar, or command button, that lets users control the program. You use controls to display data or choices, perform an action, or make the user interface easier to read.), click the control, and then click Properties on the toolbar.
   3. In the property sheet, click the property you want to set, and then do one of the following:
      • If an arrow appears in the property box, click it and then select a value from the list.
      • Type a setting or expression (expression: Any combination of mathematical or logical operators, constants, functions, and names of fields, controls, and properties that evaluates to a single value. Expressions can perform calculations, manipulate characters, or test data.) in the property box.
      • If a Build button appears next to the property box, click it to display a builder (builder: An Access tool that simplifies a task. For example, you can quickly create a complex expression with the Expression Builder.) or list of builders.

   Tips

   • To get Help on any property in the property sheet, click the property and then press F1.

   • If you need more space to enter or edit a property setting, press SHIFT+F2 to open the Zoom box.

   Note  If the AllowDesignChanges property of a form is set to All Views, you can also set form properties in Form view (Form view: A window that displays a form to show or accept data. Form view is the primary means of adding and modifying data in tables. You can also change the design of a form in this view.) and Datasheet view (Datasheet view: A window that displays data from a table, form, query, view, or stored procedure in a row-and-column format. In Datasheet view, you can edit fields, add and delete data, and search for data.).

3. In the FilterLookup property box, set the property to the setting that will achieve the performance you want.
   • If the list takes too long to display in the Filter By Form window, either set the FilterLookup property to Never, or set it to Database Default and then make the appropriate changes in the Options dialog box (Tools menu).
   • If the list in the Filter By Form window isn't displaying the values stored in that field, make sure the FilterLookup property isn't set to Never. If the FilterLookup property is set to Database Default or Always, make the appropriate changes in the Options dialog box (Tools menu).

• Avoid overlapping controls.
• Don't sort records in an underlying query (query: A question about the data stored in your tables, or a request to perform an action on the data. A query can bring together data from multiple tables to serve as the source of data for a form, report, or data access page.) unless record order is important, especially with multiple-table queries.
• If the underlying record source (record source: The underlying source of data for a form, report, or data access page. In an Access database, it could be a table, query, or SQL statement. In an Access project, it could be a table, view, SQL statement, or stored procedure.) includes many records and you want to use the form primarily to enter new records, set the DataEntry property of the form to Yes so that the form opens to a blank record. If you open a form with all records showing, Access has to read each record before it can display the blank record at the end of the recordset.
• Close forms that aren't being used.

• Use bitmaps and other graphic objects sparingly.
• Convert unbound object frames that display graphics to image controls.
• Use black-and-white rather than color bitmaps.

A form without a form module (form module: A module that includes code for all event procedures triggered by events occurring on a specific form or its controls.) loads more quickly and occupies less disk space. If a form or controls on the form don't use event procedures (event procedure: A procedure that is automatically executed in response to an event initiated by the user or program code, or that is triggered by the system.), the form doesn't require a form module.

• Eliminate code from forms that don't need it by setting the HasModule form property to No. The HasModule property specifies whether the form has a form module.
• Instead of using command buttons with event procedures, you can use command buttons with macros (macro: An action or set of actions that you can use to automate tasks.), or hyperlinks (hyperlink: Colored and underlined text or a graphic that you click to go to a file, a location in a file, a Web page on the World Wide Web, or a Web page on an intranet. Hyperlinks can also go to newsgroups and to Gopher, Telnet, and FTP sites.).

Notes

• If a form currently contains event procedures, and you decide to eliminate all event procedure code from that form, you must set the HasModule property to No to completely remove the form module.

• You can still use code with a form that has no form module by calling Function procedures from a standard module using an expression (expression: Any combination of mathematical or logical operators, constants, functions, and names of fields, controls, and properties that evaluates to a single value. Expressions can perform calculations, manipulate characters, or test data.). (You can't use Sub procedures, because they can't be called using an expression.) To do this, define a Function procedure in a standard module and then call that function from an event property (event property: A named attribute of a control, form, report, data access page, or section you use to respond to an associated event. You can run a procedure or macro when an event occurs by setting the related event property.) of the form or a control. For example, to use a command button to call a function to open a form, add an expression to the OnClick property of the command button like this: =OpenDataEntry().

• Base subforms on queries rather than on tables, and include only fields from the record source (record source: The underlying source of data for a form, report, or data access page. In an Access database, it could be a table, query, or SQL statement. In an Access project, it could be a table, view, SQL statement, or stored procedure.) that are absolutely necessary. Extra fields can decrease subform performance.
• Index (index: A feature that speeds up searching and sorting in a table based on key values and can enforce uniqueness on the rows in a table. The primary key of a table is automatically indexed. Some fields can't be indexed because of their data type.) all the fields in the subform that are linked to the main form (main form: A form that contains one or more subforms.).
• Index any subform fields that are used for criteria.
• Set the subform's AllowEdits, AllowAdditions, and AllowDeletions properties to No if the records in the subform aren't going to be edited. Or set the RecordsetType property to Snapshot.

• Avoid overlapping controls.
• Avoid sorting and grouping on expressions.
• Index (index: A feature that speeds up searching and sorting in a table based on key values and can enforce uniqueness on the rows in a table. The primary key of a table is automatically indexed. Some fields can't be indexed because of their data type.) fields you sort or group on.
• Avoid using domain aggregate functions (domain aggregate function: A function, such as DAvg or DMax, that is used to calculate statistics over a set of records (a domain).). Include the field in the report's underlying query or use a subreport (subreport: A report that is contained within another report.).
• Make sure the report's underlying query is optimized.
• Use the HasData property or NoData event to determine if a report is bound to an empty recordset.

• Use bitmaps and other graphic objects sparingly.
• Convert unbound object frames (unbound object frame: A control that you place on a form or report to contain an unbound object. An unbound object is an object, such as a picture, whose value isn't derived from data stored in a table.) that display graphics to image controls (image control: A control that is used to display a picture on a form, report, or data access page.).
• Use black-and-white rather than color bitmaps.

• Base subreports on queries rather than tables, and include only fields from the record source that are absolutely necessary. Extra fields can decrease subreport performance.
• Index all the fields in the subreport that are linked to the main report.
• Index any subreport fields used for criteria (criteria: Conditions you specify to limit which records are included in the result set of a query or filter.).

• When using a data access page within Access, close all database objects that aren't being used. When using a data access page in Internet Explorer, close all windows that aren't being used.
• On data access pages that are used for data entry, set the Data Entry property of the page to True so that the page opens to a blank record.
• Index any fields that you sort, group, or filter on.
• Bind a data access page to an XML data file, so the page could get its data from a file located on the local client instead of having to access the database server.

• Avoid overlapping controls.
• Use bound span controls instead of text boxes to display any data that isn't updateable— for example, to display autonumbered values, values derived from expressions, and hyperlinks.

  Security  Use bound span controls or hyperlink controls with caution. Unauthorized users may be able to insert harmful HTML text into these controls. Processing this text without validation or modification could result in the loss of personal information or other data. To prevent the HTML text contained in a control from being rendered, encode the contents of the control.

• Use bitmaps and other graphic objects sparingly. Use black-and-white rather than color bitmaps.

• Make sure the ExpandedByDefault property is set to False for the highest group level. Setting it to False for lower group levels will speed up other interactions after the page is opened.
• Make sure the DataPageSize group level property is set to a low rather than a high number, or is set to All. The lower the number, the faster the records are displayed.
• On a page that contains records with a one-to-many relationship, group records by table rather than by a field or expression.
• On a page that is based on tables with a one-to-many relationship, bind each section to a table rather than to a query. Access retrieves the records from a table only as it needs to display them on the page. With a query, Access retrieves all the records before it displays any records on the page. Use a query only when you want to limit the data used on the page, calculate aggregate values, or perform a task that's possible only in a query.

Be sure to keep a copy of your original Access database. If you need to modify the design of forms, reports, or modules in an MDE file, you must modify the original Access database, and then resave it as an MDE file. Saving an Access database containing tables as an MDE file creates complications reconciling different versions of the data if you need to modify the design of the forms, reports, or modules later. For this reason, saving an Access database as an MDE file is most appropriate for the front-end database of a front-end/back-end application (front-end/back-end application: An application consisting of a "back-end" database file that contains tables, and copies of a "front-end" database file that contain all other database objects with links to the "back-end" tables.).

In previous versions of Access, user-level security could be used with Microsoft Visual Basic for Applications (VBA) modules. In Access 2000 and later, all VBA code for an Access database (.mdb) file or an Access project (.adp) (Microsoft Access project: An Access file that connects to a Microsoft SQL Server database and is used to create client/server applications. A project file doesn't contain any data or data-definition-based objects such as tables and views.) file, including stand-alone modules (standard module: A module in which you can place Sub and Function procedures that you want to be available to other procedures throughout your database.) and class modules (class module: A module that can contain the definition for a new object. Each instance of a class creates a new object. Procedures defined in the module become properties and methods of the object. Class modules can exist alone or with forms and reports.) (such as code behind forms and reports) must enable the security features by setting a password, or by saving the database as an MDE or ADE file (ADE file: A Microsoft Access project (.adp) file with all modules compiled and all editable source code removed.), which removes the source code.

Some restrictions may prevent you from saving your Access database as an MDE file (MDE file: Microsoft Access database (.mdb) file with all modules compiled and all editable source code removed.):

• You must have password access to the Microsoft Visual Basic for Applications (VBA) code.
• If your database is replicated, you must first remove replication (replication: The process of copying a database so that two or more copies can exchange updates of data or replicated objects. This exchange is called synchronization.).
• If your Access database references another Access database, or add-in (add-in: A supplemental program that adds custom commands or custom features to Microsoft Office.), you must save all Access databases or add-ins in the chain of references as MDE files.

Additionally, if you define a database password or user-level security before saving an Access database as an MDE file, those features will still apply to an MDE file created from that database. If your Access database has a database password or user-level security defined and you want to remove these features, you must do so before saving it as an MDE file.

To save an Access database that has engaged user-level security as an MDE file, you must meet the following requirements before you can proceed:

• You must join the workgroup information file (workgroup information file: A file that Access reads at startup that contains information about the users in a workgroup. This information includes users' account names, their passwords, and the groups of which they are members.) that defines the user accounts used to access the database, or that were in use when the database was created.
• Your user account must have Open/Run and Open Exclusive permissions for the database.
• Your user account must have Modify Design or Administer permissions for any tables in the database, or you must be the owner (owner: When security is being used, the user account that has control over a database or database object. By default, the user account that created a database or database object is the owner.) of any tables in the database.
• Your user account must have Read Design permissions for all objects in the database.

If you try to create an MDE file from an Access database (.mdb) or an add-in (.mda) (add-in: A supplemental program that adds custom commands or custom features to Microsoft Office.) that references another Access database or add-in, Access displays an error message and doesn't let you complete the operation. To save a database that references another database as an MDE file, you must save all databases in the chain of references as MDE files, starting from the first database referenced. After saving the first database as an MDE file, you must then update the reference in the next database to point to the new MDE file before saving it as an MDE file, and so on.

For example, if Database1.mdb references Database2.mdb, which references Database3.mda, you would proceed as follows:

1. Save Database3.mda as Database3.mde.
2. Open Database 2.mdb and change its reference to point to the new Database3.mde.
3. Save Database2.mdb as Database2.mde.
4. Open Database1.mdb and change its reference to point to the new Database2.mde.
5. Save Database1.mdb as Database1.mde.

A replicated database (either a replica (replica: A copy of a database that is a member of a replica set and can be synchronized with other replicas in the set. Changes to the data in a replicated table in one replica are sent and applied to the other replicas.) or Design Master (Design Master: The only member of the replica set in which you can make changes to the database structure that can be propagated to other replicas.)) cannot be saved as an MDE file. To save a replicated database as an MDE file, you must first remove replication (replication: The process of copying a database so that two or more copies can exchange updates of data or replicated objects. This exchange is called synchronization.).

Once a database is saved as an MDE file, it can be replicated; however, replication is only recommended in situations where no further changes need to be made to the original database. If you need to make a design change to a replica set (replica set: The Design Master and all replicas that share the same database design and unique replica set identifier.) of MDE files, you must make that change in the original database, resave it as an MDE file, and then create and distribute an entirely new replica set from the new MDE file.

If you delete data or objects in an Access database (Microsoft Access database: A collection of data and objects (such as tables, queries, or forms) that is related to a particular topic or purpose. The Microsoft Jet database engine manages the data.), or if you delete objects in an Access project (Microsoft Access project: An Access file that connects to a Microsoft SQL Server database and is used to create client/server applications. A project file doesn't contain any data or data-definition-based objects such as tables and views.), the file can become fragmented and use disk space inefficiently. Compacting the Access file makes a copy of the file and rearranges how the file is stored on your disk. Compacting a previous-version Access database won't convert it to Access 2002 - 2003 format.

Compacting optimizes the performance of both Access databases and Access projects. However, in an Access project, compacting does not affect database objects (database objects: An Access database contains objects such as tables, queries, forms, reports, pages, macros, and modules. An Access project contains objects such as forms, reports, pages, macros, and modules.)— such as tables or views— that reside in the Microsoft SQL Server database (Microsoft SQL Server database: A database in Microsoft SQL Server, it consists of tables, views, indexes, stored procedures, functions, and triggers.) instead of in the Access project itself.

Compacting has no effect on autonumbering in an Access project. However, in an Access database, if you have deleted records from the end of a table that has an AutoNumber field (AutoNumber data type: In a Microsoft Access database, a field data type that automatically stores a unique number for each record as it's added to a table. Three kinds of numbers can be generated: sequential, random, and Replication ID.), compacting the database resets the AutoNumber value; the AutoNumber value of the next record you add will be one greater than the AutoNumber value of the last undeleted record in the table.

In most cases, Access detects whether an Access file is damaged when you try to open it and gives you the option to repair it at that time. If the current Access file contains a reference to another Access file that is corrupt, Access does not attempt to repair the other file. In some situations, Access may not detect that a file is damaged. If an Access file behaves unpredictably, compact and repair it.

Access can repair:

• Corruption in a table in an Access database (Microsoft Access database: A collection of data and objects (such as tables, queries, or forms) that is related to a particular topic or purpose. The Microsoft Jet database engine manages the data.).

• Missing information about the structure of an Access file's Visual Basic for Applications (VBA) project.

• Corruption in a form, report, or module.

• Missing information that Access needs to open a particular form, report, or module.

To help prevent corruption of Access files, follow these guidelines:

• Compact and repair Access files regularly. You can specify that Access compact a file automatically when you close it.

• Back up your Access files regularly.

• Avoid quitting Access unexpectedly. For example, don't quit Access suddenly by turning off your computer.

• If you are experiencing network problems, avoid using a shared Access database located on a network server until the problems are resolved. If possible, move the Access database to a computer where you can access it locally instead of over the network.

If a serious problem occurs and causes Access to shut down, Access restarts, creates a copy of the file that was open, and names it filename_Backup.mdb or filename_Backup.adp, where filename is the name of the original file. If filename_Backup.mdb or filename_Backup.adp already exists, Access asks you to specify the name of the file. Access then attempts to compact and repair the original file.