Microsoft Access Team Blog : Access 2007

Access 2007 hotfix package now available

Clint Covington — Fri, 11 Sep 2009 01:08:36 GMT

Here are the list of issues fixed in this download package.

In Microsoft Office Access 2007, you have a report that includes a form reference in the criteria of the record source. When you enter a letter at the first parameter prompt, a numeric value is displayed on the report. For example, if you enter the letter "a" at the first parameter prompt, the value "97" is displayed on the report.
In Access 2007, you have a form or a report that is bound to a SQL Server stored procedure. The stored procedure is executed multiple times when you perform one of the following actions:

You open a form in Form View.
You open a form in Datasheet View.
You open a report in Report View.
You print or print preview a report.

This problem does not occur in Access 2003.
Note You also experience the problem when you open a form or a report in Design View or in Layout View. However, this is not fixed in the hotfix.

After you apply 2007 Office system Service Pack 2, the Navigation Pane in Access 2007 continues to scroll after you release the mouse. This problem occurs when the Navigation Pane is viewed by Details or by Icon, but not by List.
After you apply 2007 Office system Service Pack 2, the description of an object does not appear in the Navigation Pane in Access 2007. This problem occurs when the Navigation Pane is viewed by Details.

After you apply 2007 Office system Service Pack 2, when you open an object in Access 2007 the text on the status bar flickers.
In Access 2007, you open a view that contains a field which uses a sum function in Report View or in Layout View. If you move the scroll bar while the sum function is calculating, the value of the field changes.

Handling the SQL Server bigint data type in Access 2007 using ADO

Mike Stowe — Thu, 11 Jun 2009 01:31:28 GMT

Today’s guest blogger is Vinny Malanga. Vinny is the CTO of IMI Software, Inc., which specializes in software development for the property management industry.

I recently received a call from a client asking for help on how to use the SQL Server bigint data type in a disconnected Access .accdb file. Here’s the scenario:

There’s a SQL Server table that is using the bigint data type as an identity column. In this scenario, the Access database is completely disconnected from the SQL Server 2008 database. There is no use of ODBC or linked tables. All data access is handled using ADO.

As explained in SQL Server 2008 Books Online the range of the bigint data type is -2^63 (-9,223,372,036,854,775,808) to 2^63-1 (9,223,372,036,854,775,807). The problem is that there is no equivalent Access data type to the SQL Server bigint data type. But, you are not out of luck. There are a couple of ways that you can handle this. Both options are explained below.

The first option is to have all stored procedures or views which return the bigint value to Access explicitly cast the bigint value to a varchar. Access can then utilize the data as a string value. When sending the value back to SQL Server (such as when updating or deleting a record), the stored procedure simply casts the string back to a bigint so it can be used appropriately in SQL Server.

The second option is to utilize the Variant data type in Access. I know what you may be thinking at this point. At first glance, many of you may not like the sound of this, and as a general rule, I tend to agree, but it is worth exploring this option. By taking this approach, there is no casting in SQL Server necessary. The Variant data type can hold the bigint value that SQL Server sends to Access because the Decimal data type is a subtype of the Variant data type. You can’t explicitly declare a Decimal data type in Access but the Variant data type does store the value as a decimal. You can see this by running the VarType(VarName) function. The result is 14 which is the VB constant for vbDecimal. You could also run the TypeName(VarName) function which returns Decimal. I’ve included these methods in the sample access database in the cmdGetName_Click() event. Just uncomment them and the result will print in the debug window.

Another small caveat to using a variant is if you are going to display the value in a textbox. The large bigint values will display in scientific notation. For example, if you are displaying the bigint value 9223372036854775807, an Access textbox will display this as 9.22337203685478E+18. However, the actual value is stored appropriately so this isn’t an issue if the field is hidden. For display purposes though, you could cast the value to a string using CStr(Expression) when binding to the textbox (again, a little more overhead), or simply display the value in a label control.

As a general rule, using variants can degrade performance. Since the data type isn’t explicitly declared, VBA has the additional overhead of maintaining which data type it is actually storing. Also, variants are large, 16 bytes so they have a higher memory footprint. However, variants are there for a reason and sometimes they do have their purpose. This could be one of them. I’m not totally opposed to this method, but personally I try to avoid using the Variant data type when another option is available. So, personally, I tend to gravitate toward the first option.

I’ve supplied some SQL scripts and a sample Access database applying both methods There are also some examples in the sample database on the use of classes, disconnected ADO Recordsets, and general object oriented programming principles.

Here are the scripts to create the objects in a SQL Server database.

-- 1 Create a table:
-- I have set the identity to begin at the largest bigint value
-- for demonstration purposes.
CREATE TABLE [dbo].[tblName](
    [RecordID] [bigint] IDENTITY(9223372036854775807,-1) NOT NULL,
    [Name] [varchar](50) NULL,
 CONSTRAINT [PK_tblName] PRIMARY KEY CLUSTERED 
(
    [RecordID] ASC
)
WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, 
       ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO

-- Create four Stored Procedures.
CREATE PROCEDURE [dbo].[procGetNameUsingString] 
AS
BEGIN
    SET NOCOUNT ON;
    -- bigint range is -9223372036854775808 to 9223372036854775807

    -- Cast RecordID to varchar(19) when sending to Access
    -- 19 is the number of characters needed to hold the largest
    -- length bigint value. Use 20 if you're going to use negative
    -- numbers to account for the negative sign.
    SELECT CAST(RecordID AS varchar(19)) AS RecordID, Name FROM tblName
END
GO

CREATE PROCEDURE [dbo].[procGetNameUsingVariant] 
AS
BEGIN
    SET NOCOUNT ON;
    SELECT  RecordID, Name FROM tblName
END
GO

CREATE PROCEDURE [dbo].[procUpdateNameUsingString]
    (
        @RecordID        varchar(19),
        @Name            varchar(50),
        @ReturnValue    bit OUTPUT
    )
AS
BEGIN
    SET NOCOUNT ON;
    -- Declare a variable to hold the bigint value
    -- and assign it the result of casting the incoming
    -- string representation of RecordID back to a bigint value.
    DECLARE @RecordIDBigInt bigint
    SET @RecordIDBigInt = CAST(@RecordID AS bigint)
    -- Update the record using the bigint value.
    UPDATE tblName
    SET Name = @Name
    WHERE RecordID = @RecordIDBigInt
    
    SET @ReturnValue = @@ROWCOUNT
END
GO

CREATE PROCEDURE [dbo].[procUpdateNameUsingVariant]
    (
        @RecordID        bigint,
        @Name            varchar(50),
        @ReturnValue    bit OUTPUT
    )
AS
BEGIN
    SET NOCOUNT ON;

    UPDATE tblName
    SET Name = @Name
    WHERE RecordID = @RecordID
    
    SET @ReturnValue = @@ROWCOUNT
END
GO

-- Create a view (example if using views
-- rather than stored procedures).
CREATE VIEW [dbo].[vwGetNameUsingString]
AS
SELECT     RecordID, CAST(Name AS varchar(19)) AS Expr1
FROM         dbo.tblName
GO

Once you’ve run the scripts, your SQL database will contain one new table, four new stored procedures, and one new view. You’ll want to add a record to the newly-created table to make use of the form in the sample Access database.

You can download the sample Access database from here. You should change the connection string in the Connect subroutine of the clsDataAccess module to suit your environment. Note that the code requires a reference to the Microsoft ActiveX Data Objects 6.0 Library. The sample database already contains the reference; this is something to keep in mind if you implement the class in your database.

VBA values for Office theme colors

Clint Covington — Tue, 26 May 2009 19:17:02 GMT

Recently, there was a thread on UtterAccess that I thought might be helpful to more people. The poster radish asks:

I'd like to change the color of a control then be able to change it back to its original color. If I wanted to use the theme's highlight color, e.g., how would I do that in code? It's listed in the property sheet as "Highlight". Sure, I could grab the values of that color but is it possible to reference "Highlight", "Access Theme 5" or "Dark Blue 3" in vba code?

Access 2007 has a series of generic colors that change color based on the Office theme color. Internally, we store negative numbers and map those to predefined colors in the theme color table.

You can get the underlying value using the immediate window. Something like:

?forms("colors").Controls("Text16").backcolor

In case you are lazy like me—here is a table of the color values you need to use in VBA to have it theme with the Office theme color.

Color	VBA Color Value
Alternate Row	-2147483610
Background Form	-2147483613
Background Light Header	-2147483612
Borders/Gridlines	-2147483609
Text Black	-2147483617
Text description	-2147483614
Text Light	-2147483616
Text Dark	-2147483615
Highlight	-2147483608

Here is a link where you can get similar color values for system colors.

Synchronize with SharePoint under the hood

Clint Covington — Tue, 26 May 2009 18:46:00 GMT

Recently I was asked the following question:

I am looking to get an understanding of the internal operations during an Access 2007 synchronize execution. I have just been exposed to a SharePoint MOSS and Access 2007 environment where at times the normal sync time goes from 7-minutes to around an hour. I am taking the side of “network bandwidth” as the reason and not the side of “data quantity” as the root cause for the increased time.

Each user has their own copy of the SharePoint Lists (tables), which they work with offline. The users update their Access tables and at certain times (at their own discretion) during the day executes the synchronize function, which leads to why I expose myself to this forum's sages. Just what actions/decisions are being executed and how they are selected?

From a high level there are seven stages to synchronizing data with SharePoint:

The client sends pending changes to the server.
The client delete the local cache.
The client requests a new local cache from the server.
The server pulls the data out of SQL Server and sends it to the client in batches of XML.
The data travels the wire from the server to the client.
The client parses the XML and loads it into an in-memory table.
The client asks the user to resolve any potential conflicts.

Client Memory

When the user takes an application with SharePoint link tables Offline, Access stores an copy of all the list data in an XML format that mirrors what was retrieved from the server. When Access is running this data is parsed into an in-memory table. One of the first performance challenges you will face is when Access parses the XML and loads the data in memory. If the working set gets too big Access Windows swap memory out to disk which causes the machine to thrash. I typically check task manager to see how large the working set is. There are two remedies to this problem:

Increase memory on the client machine, and/or
Move data that doesn’t change (such as stale and large lookup data) to a local table.

Rehydrating the Cache

When the user clicks synchronize, Access will send pending changes to the server and request an updated version of the list. Access 2007 re-fetchs the linked list(s) including the User Information Lists. If your site has a large user information list—this could take quite a while. There are a couple solutions if your app has a large User Information List:

Move the data into it’s own site and not inherit the permissions from the parent site. This should give you a custom user information list that only includes people that are actually using the site.
If you don’t use the User Information List the link table can be deleted. The app should still continue to function other than not resolving the Created By and Modified By lookup fields.

The performance of fetching data is impacted by performance of the SharePoint Server to query the list items, return the user information list, and sending data down the wire. It is limited to the speed of light—the further you are from the server the slower the response. Obviously connection speed also has a huge influence. You also have to factor in parsing the XML and loading the DOM in memory.

What is on the wire?

You can see what is actually sent over the wire by installing the free Fiddler Web Debugging Proxy.

I find this tool invaluable to understand what is happening in the application.

In investigations that we’ve done, the pushing up and fetching of the data (which includes the network time plus whatever processing SharePoint does) often takes about 2/3 of the time in the go offline/sync scenario.

Conflict Detection

If there are conflicts detected during a sync operation (meaning the item was changed by someone on the server and someone on the client) Access launches the conflict detection dialog. We leave it up to the user to figure out which record to keep.

Summary

Access 2007 is much more efficient than Access 2003 working with SharePoint data; however, there are many opportunities for us to improve make this scenario for the client and server. We will talk more about this subject in a couple months.

How to: Create a Shortcut Menu for a Form, Form Control, or Report

Mike Stowe — Thu, 21 May 2009 11:00:00 GMT

Today’s guest blogger is Edwin Blancovitch. Edwin is president of Advanced Developers.net, creators of Easy Payroll, a software package to manage your human resources, payroll, scheduling, time and attendance needs.

When you're designing a form or report, you may want to provide a method for a user to easily use a command that applies only to the correct context. One way to do this is to create a custom shortcut menu and apply it to a form report, or control. The shortcut menu appears when the user right-clicks the object to which the shortcut menu is applied.

In earlier versions of Access, you could use the Customize dialog box to create custom shortcut menus. In Microsoft Office Access 2007, you must use Visual Basic for Applications (VBA) code to create a shortcut menu. This article shows you how to create a shortcut menu using VBA.

To create a shortcut menu, you first have to create a CommandBar object. The CommandBar object represents the shortcut menu. Then, you use the Add method to create CommandBarControl objects. Each time you create a CommandBarControl object, a command is added to the shortcut menu.

Example 1: A Simple Shortcut Menu

The following example creates a shortcut menu named SimpleShortcutMenu that contains two commands, Remove Filter/Sort and Filter by Selection.

Note To use the following examples, you must set a reference to the Microsoft Office 12.0 Object Library. See Set References to Type Libraries for more information about setting references.

Sub CreateSimpleShortcutMenu()
    Dim cmbShortcutMenu As Office.CommandBar
    
    ' Create a shortcut menu named "SimpleShortcutMenu".
    Set cmbShortcutMenu = CommandBars.Add("SimpleShortcutMenu", _
                        msoBarPopup, False, False)
                        
    ' Add the Remove Filter/Sort command.
    cmbShortcutMenu.Controls.Add Type:=msoControlButton, Id:=605
    
    ' Add the Filter By Selection command.
    cmbShortcutMenu.Controls.Add Type:=msoControlButton, Id:=640
    
    Set cmbShortcutMenu = Nothing
End Sub

Once you've run the code, the shortcut menu is saved as part of the database. You don't have to run the same code to recreate the shortcut menu each time you open the database.

To assign the shortcut menu to a form, form control, or report, set Shortcut Menu property of the object to Yes and set the Shortcut Menu Bar property of the object to the name of the shortcut menu. For this example, set the Shortcut Menu Bar property to SimpleShortcutMenu.

Note In some instances, you may want to create a temporary CommandBar. To do this, set the Temporary argument of the Add method to True. When you do this, the CommandBar is deleted when Access is closed.

Example 2: A Shortcut Menu With Grouping

The following example creates a shortcut menu named cmdFormFiltering that contains commands that are useful to use with Continuous forms. In this example, the BeginGroup property is used on several controls to group controls visually.

Sub CreateShortcutMenuWithGroups()
    Dim cmbRightClick As Office.CommandBar
    
    ' Create the shortcut menu.
    Set cmbRightClick = CommandBars.Add("cmdFormFiltering", _
                      msoBarPopup, False, False)
    
    With cmbRightClick
        ' Add the Find command.
        .Controls.Add msoControlButton, 141
        
        ' Start a new grouping and add the Sort Ascending command.
        .Controls.Add(msoControlButton, 210).BeginGroup = True
        
        ' Add the Sort Descending command.
        .Controls.Add msoControlButton, 211
        
        ' Start a new grouping and add the Remove Filer/Sort command.
        .Controls.Add(msoControlButton, 605).BeginGroup = True
        
        ' Add the Filter by Selection command.
        .Controls.Add msoControlButton, 640
        
        ' Add the Filter Excluding Selection command.
        .Controls.Add msoControlButton, 3017
        
        ' Add the Between... command.
        .Controls.Add msoControlButton, 10062
    End With
End Sub

Example 3: A Shortcut Menu for Reports

The following example creates a shortcut menu named cmdReportRightClick that contains commands that are useful to use with a report. This example illustrates how to change the Caption property of each control as they're added to the shortcut menu.

Sub CreateReportShortcutMenu()
    Dim cmbRightClick As Office.CommandBar
    Dim cmbControl As Office.CommandBarControl

    Set cmbRightClick = CommandBars.Add("cmdReportsRightClick", _
                                        msoBarPopup, False, False)

    With cmbRightClick
        
        ' Add the Print command.
        Set cmbControl = .Controls.Add(msoControlButton, 2521)
        ' Change the caption displayed for the control.
        cmbControl.Caption = "Quick Print"
        
        ' Add the Print command.
        Set cmbControl = .Controls.Add(msoControlButton, 15948)
        ' Change the caption displayed for the control.
        cmbControl.Caption = "Select Pages"
        
        ' Add the Page Setup... command.
        Set cmbControl = .Controls.Add(msoControlButton, 247)
        ' Change the caption displayed for the control.
        cmbControl.Caption = "Page Setup"
        
        ' Add the Mail Recipient (as Attachment)... command.
        Set cmbControl = .Controls.Add(msoControlButton, 2188)
        ' Start a new group.
        cmbControl.BeginGroup = True
        ' Change the caption displayed for the control.
        cmbControl.Caption = "Email Report as an Attachment"
        
        ' Add the PDF or XPS command.
        Set cmbControl = .Controls.Add(msoControlButton, 12499)
        ' Change the caption displayed for the control.
        cmbControl.Caption = "Save as PDF/XPS"
        
        ' Add the Close command.
        Set cmbControl = .Controls.Add(msoControlButton, 923)
        ' Start a new group.
        cmbControl.BeginGroup = True
        ' Change the caption displayed for the control.
        cmbControl.Caption = "Close Report"
    End With
    
    Set cmbControl = Nothing
    Set cmbRightClick = Nothing
End Sub

Displaying the Shortcut Menu

By default, a shortcut menu is displayed when the user right-clicks the object that the shortcut menu is assigned to. The problem is, many users do not know that right-clicking their mouse can display a menu.

You can use the ShowPopup method to display a shortcut menu when the user clicks on an object. The following example shows how to display the cmdFormFiltering shortcut menu when the user clicks the Command0 button.

Private Sub Command0_Click()
    
    ' Display the shortcut menu when the user clicks the button.
    Application.CommandBars("cmdFormFiltering").ShowPopup
    
End Sub

How to Discover the IDs to Use

In the previous examples, a numeric ID was used to specify the control to the Add method. How do you find the ID to use for the control that you want to add? Access doesn’t provide a built-in method that you can use to find right ID to use.

The following example shows how to find the right ID to use. The CreateCommandBarsWithIDs function uses cbShowButtonFaceIds function to create four CommandBars, each with 500 controls.

The CommandBars are displayed on the Add-Ins tab of the Ribbon. The number displayed beside each icon is the ID to use when adding the control to a shortcut menu.

Function CreateCommandBarsWithIDs()
    Call cbShowButtonFaceIds("CmdIDs_01", 1, 500)
    Call cbShowButtonFaceIds("CmdIDs_02", 501, 1000)
    Call cbShowButtonFaceIds("CmdIDs_03", 1001, 1500)
    Call cbShowButtonFaceIds("CmdIDs_04", 1501, 2000)
End Function

Function cbShowButtonFaceIds(strName As String, _
                             lngIDStart As Long, _
                             lngIDStop As Long)

    Dim cbrNewToolBar As CommandBar
    Dim cmdNewButton As CommandBarButton
    Dim intCntr As Integer

    On Error Resume Next

    ' Delete the CommandBar if it already exists.
    Application.CommandBars(strName).Delete

    ' Create the CommandBar.
    Set cbrNewToolBar = Application.CommandBars.Add( _
                      Name:=strName, temporary:=True)

    ' Loop through the IDs.
    For intCntr = lngIDStart To lngIDStop
        ' Create a new button for each ID.
        Set cmdNewButton = cbrNewToolBar.Controls.Add( _
                         Type:=msoControlButton)

        With cmdNewButton
            .FaceId = intCntr
            .TooltipText = "Faceid= " & intCntr
            .Caption = intCntr
            .Style = msoButtonIconAndCaptionBelow
        End With

        ' This takes awhile to run. Display a count
        ' to indicate progress.
        Debug.Print intCntr & " of " & lngIDStop
    Next intCntr

    ' Display the new CommandBar.
    With cbrNewToolBar
        .Width = 600
        .Left = 100
        .Top = 200
        .Visible = True
    End With

    Set cbrNewToolBar = Nothing
    Set cmdNewButton = Nothing
End Function

Access 2007 and Runtime SP2 now available

Ryan McMinn — Thu, 30 Apr 2009 03:45:19 GMT

Highlights

The ability to export reports to Excel has been added.
Fixes for issues with the import data wizards, report printing and previewing, macros, Excel integration, and date filters.
Updates to Access Developer Extensions and Access Runtime are updated for SP2 and are available in all supported languages. The ADE is patched with the full Office Suite patch, while the Access Runtime is in a separate patch.

More Access Runtime info

This version of the Access 2007 Runtime contains the same version of files as Office 2007 Service Pack 2 (SP2). For additional information about Microsoft Office Access 2007 Runtime Service Pack 2, click the following article number to view the article in the Microsoft Knowledge Base: 957262 Description of the Microsoft Office Access 2007 Runtime Service Pack 2.

Also, the international versions of the Runtime are also available; except the Italian version which will be available in a couple of days. We will announce it on the blog. Enjoy!

Download: Microsoft Office Suite Service Pack 2

Download: Update for Access Runtime and Data Connectivity 2007 Service Pack 2

Download: Full Access SP2 Runtime

Here is a link for info on all the fixes across office.

Please install SP2 and send us your feedback.

Access 2007 SP2 due to ship April 28th

Clint Covington — Sat, 25 Apr 2009 03:21:05 GMT

The Office Sustained Engineering team has announced the official ship date. Highlights for Access include:

The ability to export reports to Excel has been added.
Fixes for issues with the import data wizards, report printing and previewing, macros, Excel integration, and date filters.
Updates to Access Developer Extensions and runtime (including as a patch) are now included in SP2.

We will have a complete list of fixes available on the 28th.

Template demonstrates how to synchronize combo boxes

accblog — Fri, 03 Apr 2009 04:54:20 GMT

You can download a template for Access 2007 that demonstrates how to synchronize two combo boxes. For example, say you choose a category from one combo box, and you want a second combo box to only display products within that category. The template shows you how to make it happen.

On the Getting Started page of Access, click Sample in the left pane, and then click How to synchronize combo boxes.

Click Download, and Access launches the template. The template contains all the instructions you need to set up combo boxes of your own, whether you want to use VBA code or macros.

You can also download the template via Office Online here.

Accessing external data using the IN clause

robcooper — Fri, 27 Mar 2009 13:36:00 GMT

Someone sent us a question the other day about one of my favorite dark corners in Access and we thought it might be interesting to dive into this area a little.

Microsoft Access SQL supports two uses of the IN keyword. The most commonly used case is as part of the WHERE clause of a SQL statement to provide a list of values used as criteria. Using the Customers table in the Northwind 2007 sample database as an example, this might look something like:

SELECT [First Name], [Last Name], [State/Province]
FROM [Customers]
WHERE [State/Province] IN ('WA', 'CA', 'NY')

This query returns the names of customers that live in WA, CA, or NY. This keyword provides a nice alternative to the OR clause which would require repeating the field name.

The other use of the IN keyword is as part of the SELECT statement or FROM clause, and is called the IN clause. The IN clause is used to access external data, and can be used in place of linked tables. For example, let's say that you had a SQL Server database that is used as part of an application, but you don't want to maintain a DSN to connect. You could use the IN clause in a query that uses a DSN-less connection to quickly read data from the external table. For example:

SELECT * FROM ExternalTable
IN '' [ODBC;Driver={SQL Server}; Server=ServerName; Database=DatabaseName; Trusted_Connection=Yes]

It is possible to create a linked table that uses a DSN-less connection, but creating the table requires code. Also, unlike a SQL pass-through query, this query is executed by the Access database engine which means that the resultset may also be updateable. Furthermore, there is a certain simplicity or elegance about this technique that I think is cool. Incidentally, there is another syntax for the IN clause, but I prefer this one.

So far so good, but since the IN clause is part of the FROM clause of a query, it can also be used other places where the FROM clause can be used. For example, in a make table query to create a local copy of data in an external table:

SELECT * INTO LocalTable
FROM SourceTable
IN '' [ODBC;Driver={SQL Server}; Server=ServerName; Database=DatabaseName; Trusted_Connection=Yes]

Or, in an append query using the INSERT...INTO statement to move data from the local database into another database. Note that the connection string used in this example is to another Access database.

INSERT INTO DestinationTable (DestinationField)
IN '' [;DATABASE= C:\Users\Rob\Documents\Northwind 2007.accdb]
SELECT SourceField FROM SourceTable

You could even use an append query with multiple IN clauses to concatenate two text files:

INSERT INTO [File2.txt] (Field1)
IN '' [TEXT; FMT=Delimited; HDR=YES; DATABASE= C:\Users\Rob\Documents;TABLE=File2.txt]
SELECT Field1
FROM [File1.txt]
IN '' [TEXT; FMT=Delimited; HDR=YES; DATABASE= c:\Users\Rob\Documents;TABLE=File1.txt];

These are just a few examples of how you could use the IN clause to quickly work with external data. By using different connection strings for the external data sources, you could do some pretty cool stuff.

Paste from Excel hotfix available

Clint Covington — Wed, 18 Mar 2009 16:56:00 GMT

in mid December an Excel security fix (MS08-074) broke paste from Excel inside Access. Users would get the following error message:

The data on the Clipboard is damaged, so Microsoft Office Access can't paste it. There may be an error in the Clipboard, or there may not be enough free memory. Try the operation again.

There is a hot fix now available that will fix the issue. Luke Chung has written about how you can work around the issue if you don’t have permissions to install the hot fix.

Automate data collection forms using VBA

Clint Covington — Tue, 10 Feb 2009 09:00:47 GMT

Access 2007 has a nifty feature that allows you to collect data via email. Recently, I got the following question from a user:

Is there any way to automate the creation, sending and receiving of Emails through the Data Collection capability of A07 using VBA? The wizard is too complex for the users I am working with.

Here is the reply we got from the developer—it isn’t for the faint at heart…

There isn’t a straight-forward way to do this and it isn’t officially supported. It’s possible if you don’t mind a little reverse engineering… The key is that there are two places Data Collection uses to do its work. One is in a system table inside Access used to store information about the action, and the other is an XML file that Outlook uses when mails are received to identify Data Collection mails and associated databases.

The system table is called MSysDataCollection. There’s one entry for each data collection action that’s created in the database. A quick rundown of the fields:

Active – Controls whether the current Data Collection action should be run.
BasedOnType – This marks whether the data collection is based on a query or a table
CreatedDate – When was the data collection action originally started.
ExternalID – A unique GUID to identify the Data Collection action
FormName – Name of the form; appears in the e-mail subject
InfoPathForm – True if we sent out an InfoPath form, false if it was HTML
Mapping – An XML chunk that defines how fields in the table/query map to fields in the form. Your best bet is to create a few Data Collection actions similar to ones your users might create, and mimic the XML. Here’s some of the interesting bits

<formProperties> stores most of the properties found in the Options dialog of the Data Collection Wizard
<tables>, despite the name, only supports one table. This section stores the database column name to the form field name mapping.
<table>’s name attribute should always be “table1”, accessTable is the table name inside Access, and collectionType is either “insert” or “update”
<iterate> points to where in the InfoPath/HTML form we’re looking for data (as opposed to formatting, etc.). This doesn’t change much.
There will be one <mapitem> for each column in your form, including hidden fields. formNode is for the form, and is always “table1fieldX”, tableCell is for the Access table
The <recipients> tag stores who we sent the mail to, in case we want to only accept certain people’s responses, or limit how many times, or what rows, they can update.

OutlookFolder – This is the Outlook item ID of the Outlook folder replies should be moved to when processed.
SentDate – The last time this data collection item was mailed out (updated through the Resend feature).

The other bit is the XML file for Outlook, and lives in <AppData>\Microsoft\Access. It’s called AccessDCActionFile.xml. There’s only one file for a given user on a machine, and each Data Collection action gets added to the same file. Again, the easiest way to understand the file is to create a few actions and see what we write out, but here’s some highlights:

<outlookFolders> - Stores the Outlook ID for the default Data Collection folders in Outlook.
<mdbMap> - Each data collection action gets one <form> tag under here.
<form> - id is the GUID that matches the External ID in MSysDataCollection, moveToFolder matches OutlookFolder, and FormType is “HTML” or “InfoPath”
<path> - path to the database
<userReply> - This tracks whether the user who sent the Data Collection e-mails has replied to it themselves.
<formProperties> - Pretty much a copy of what’s in the system table’s Mapping section. By having it here, we don’t have to grab it from Access every time we need it.
<lastShutdown> - The last time Outlook was shut down.

Lastly, you have to actually generate the HTML or InfoPath form. We do this by manually building the HTML or XML for the forms. I’d recommend cracking open some Data Collection forms, looking for the nodes and GUIDs stored in the HTML or XML, and recreating them that way. I don’t have a more convenient way to do this, and it’s probably the hardest part to get right.

With this info in hand, you can do the follow to create a Data Collection action through automation:

Collect whatever information from the user you need (recipients, options, etc.)
Add a row to MSysDataCollection
Add a <form> entry to AccessDCActionFile.xml
Create the HTML/XML mail.
Use Outlook’s OM to send the e-mails.

The client version of Outlook does need to run in order to receive and process e-mails, but this will get the data collection action created and running.

Access Developer Extensions 2007 Updates

Ryan McMinn — Wed, 21 Jan 2009 01:08:22 GMT

Access Developer Extensions 2007 has been updated and is now live on Microsoft.com. Here is a link - http://www.microsoft.com/downloads/details.aspx?FamilyID=d96a8358-ece4-4bee-a844-f81856dceb67

Highlights of the updates:

Package Solution Wizard
A wizard that creates a Windows Installer Package (MSI) to install your database and any supporting files and optionally includes the Access 2007 Runtime, or prompts the user to download the Access 2007 Runtime.
- Updated for packaging databases with international character file names. Some surrogate Unicode characters are not supported due to MSI technology limitations
- Bug fix: Repairing an package install to a custom location will correctly install to the original user-specified location.
Source Code Control
Integration with Microsoft Visual SourceSafe or other source code control systems to allow check-in/check-out of queries, forms, reports, macros, modules, and data. You can also see the differences that have been made to your checked out objects.
- This is the first release of the ADE that ships the source code control components in additional languages beyond English, Japanese, French and German.
Save As Template
Enables you to create database templates (ACCDTs) that can be featured in the Access 2007 Getting Started screen.
ADE 2007 now available in additional Languages
Chinese (Traditional), Chinese (Simplified), Korean, Japanese, Spanish, French, Italian and German.

A new hot fix for Access 2007 is now available

Clint Covington — Tue, 30 Dec 2008 21:06:42 GMT

Issues fixed include:

You experience slower performance than you did in previous versions when you share a database file over a network.
You may notice your database file increase in increments of 4 KB without any user interaction when the database is open.
You may see a sub-form become blank after you set the main form’s recordset. You may also receive the following error: “Run-time error 2467 – The expression you entered does not exist”.
When you make a change in a code module in an Access 2007 database under source code control, the changes are not saved if you do the following:

Close the Visual Basic Editor without saving the changes
Check the Object back in
Use the Get Last Version feature to view the latest changes.

These fixes are available at http://support.microsoft.com/kb/960307.

Built-in Tab Names in Access Ribbons

robcooper — Wed, 10 Dec 2008 08:16:04 GMT

If you've tried to create a Ribbon customization that included one of the built-in controls in Access you've probably seen that you can use the Customize page in the Access Options dialog to get the names of groups and controls. You can also download the entire list of controls from the Microsoft web site. Unfortunately, the dialog does not include the list of built-in tabs.

For simplicity, here is the list of built-in tabs taken from this list:

TabPrintPreviewAccess
TabHomeAccess
TabCreate
TabExternalData
TabDatabaseTools
TabSourceControl
TabAddIns
TabFormToolsFormatting
TabControlLayout
TabFormToolsDesign
TabFormToolsLayout
TabReportToolsFormatting
TabReportToolsLayout
TabReportToolsPageSetupLayout
TabReportToolsDesign
TabReportToolsAlignment
TabReportToolsPageSetupDesign
TabRelationshipToolsDesign
TabQueryToolsDesign
TabMacroToolsDesign
TabPivotTableDesign
TabPivotChartDesign
TabTableToolsDatasheet
TabTableToolsDesignAccess
TabAdpFunctionAndViewToolsDesign
TabAdpStoredProcedureToolsDesign
TabAdpSqlStatementDesign
TabAdpDiagramDesign

Total Access Analyzer 2007 Preview

robcooper — Thu, 28 Aug 2008 22:21:44 GMT

One thing about being on the Access team that I enjoy is seeing some of the great work being done in the Access community. Among the forefront of this community is FMS, who is the leading developer of Access add-ins. FMS recently announced a preview version of Total Access Analyzer 2007 which is a tool that helps you create better Access databases. There are too many new features to list here, but here is a small subset that might be interesting to note:

Support for the .ACCDB file format added in Access 2007
Analysis of new macro actions including embedded macros
24 new reports!
Reports can now be viewed in Report View which provides an interactive experience for reports
Reports can be exported to PDF

Here's a link to the preview:

http://www.fmsinc.com/Products/analyzer/confprvw.asp

Enjoy!