Welcome

Welcome! Shared Forms Queries ACCDE Builder

Welcome to Access Developer 64. We will continue building the shared library database system by creating reusable dialog forms that return values, discussing shared queries and library distribution, compiling the library into an ACCDE file, and building a utility that automatically creates and replaces compiled library files while preserving a backup.

Navigation

Prev: D64
Next: Lesson 1

Keywords

Access Developer, shared library database, ACCDE builder, compile ACCDE automatically, reusable dialog form, return value from form, shared queries, library database distribution, ACCDE source code protection, trusted locations, database references

Subscribe to Welcome
Get notifications when this page is updated

More Information

Transcript

Welcome to Microsoft Access Developer Level 64, brought to you by Access Learning Zone. I'm your instructor, Richard Rost.

Today, we're going to continue building our shared library database system that we started back in Developer 63. We're going to take those reusable functions and forms a step further and learn how to get information back from a form that's running in our library.

We'll look at some questions and feedback from students from the last class, including how to share queries and distribute your library databases. Then we'll get into compiling our library into an ACCDE file, which helps protect your source code and keeps us from accidentally making changes to the library while working in another database.

And finally, we're going to build a little utility that will automatically compile our library for us with the click of a button.

By the time we're finished, we'll have a much more practical system for maintaining and updating shared library databases across multiple Access applications.

This class follows Access Developer Level 63, where we started building our shared library system. If you don't watch Level 63 first, you're not going to have a clue what we're doing today. So go get and watch Access Developer 63 first, and then come on back.

I will be using Microsoft 365. It's currently October of 2026, so the closest version is Microsoft Access 2024. But the stuff I'm teaching today should go all the way back to 2007-ish.

If you've got questions, post them on the page where the video is. Just scroll down to the bottom and post them there. It makes it easier for me and the other moderators to know what video you're talking about. And if you can, put a time index, too. Thanks.

And if you've got other questions not related to today's class, go post them in the Access forum. That way, everybody can see them.

All right, let's take a closer look at what's covered in today's class.

In lesson one, we're going to build a reusable dialogue form inside our library database. We'll pass a question to the form, let the user answer yes or no, and then return that answer to the calling database. This gives us a nice way to build shared dialogue boxes that we can use in any of our databases.

In lesson two, we're going to go through some awesome questions and feedback from the students about our library database system that were posted in Developer 63. We'll look at an easier way to copy forms into your library, how to create and use shared queries, and some things to consider when distributing your library to other users. We'll also talk about network locations, references, and trusted locations.

In lesson three, we're going to start working with compiled ACCDE library files. We'll see why it's a good idea to protect our library source code and how to compile the library manually. Then we'll start putting together a separate ACCDE builder database that will eventually do all that work for us automatically.

In lesson four, we'll finish building the automatic ACCDE builder. We'll make it so we can click a button in the master library, have Access compile a new ACCDE file, preserve the previous version just in case, and replace the old compiled library with the new one. We'll also add some error handling and status messages and get the system to reopen our master library when it's finished. This will make maintaining our shared library a whole lot easier.

By the end of this level, you'll know how to create more advanced reusable tools in your shared library, including forms that return values and queries that can be used by other databases. You'll also understand how to distribute and protect your library, and you'll have your own automatic ACCDE builder to simplify the process of updating compiled libraries. It's a nice finishing touch to the library system we've been building over the past two levels.

Now, as always, I recommend you sit back, relax, and watch each video once through completely, and then watch it a second time and follow along with the examples.

All right, sit back, relax, and let's get ready to start lesson one.

Intro

Welcome to <B>Access Developer 64</B>. We will continue building the shared library database system by creating reusable dialog forms that return values, discussing shared queries and library distribution, compiling the library into an ACCDE file, and building a utility that automatically creates and replaces compiled library files while preserving a backup.

Summary

Today's video from Access Learning Zone continues our shared library database project from Access Developer Level 63. In this class, I will show you how to make shared library components more useful across multiple Access databases, including forms that can return information to the database that opened them.

This course builds directly on Access Developer Level 63, where I introduced the shared library database concept and began creating reusable functions and forms. If you have not completed that class, I strongly recommend watching it first. The material in this lesson assumes you already understand how the library system was set up and how it is referenced from another Access database.

I am using Microsoft 365, and as of October 2026 the closest perpetual version is Access 2024. However, the techniques covered in this class should work with versions of Microsoft Access going back to approximately Access 2007.

If you have questions about a particular lesson, please post them on the page for that video. Including the time index where the question comes up is especially helpful. For general Access questions that are not related to this specific course, please use the Access forum so other students and moderators can find and respond to them.

In lesson one, I will build a reusable dialog form inside the library database. The calling database will send a question to the library form, the user will respond with a Yes or No answer, and the form will return that answer to the calling database. This gives us a practical framework for building shared dialog boxes that can be used throughout multiple Access applications.

In lesson two, I will address student questions and feedback related to the shared library system introduced in Developer 63. I will cover a simpler method for copying forms into a library database, explain how shared queries can be created and used, and discuss important considerations when distributing library databases to other users. We will also discuss network locations, Access references, and trusted locations.

In lesson three, I will begin working with compiled ACCDE library files. Compiling a library is useful because it helps protect your VBA source code and prevents accidental design or code changes while you are working in another database that uses the library. I will demonstrate how to compile the library manually, and then begin creating a separate ACCDE builder database that will eventually automate the compilation process.

In lesson four, I will complete the automatic ACCDE builder utility. We will configure the system so that a button in the master library can create a new ACCDE file, preserve the previous version as a backup, and replace the existing compiled library with the newly generated version. I will also add error handling, status messages, and a way to reopen the master library when the process is complete.

By the end of this level, you will understand how to create more advanced reusable tools for a shared Access library. You will know how to create forms that return values to another database, create and use shared queries, protect and distribute your library, and automate the creation of updated ACCDE library files. These tools make maintaining shared functionality across multiple Access applications much easier and more reliable.

I recommend watching each lesson once from beginning to end before trying the examples yourself. Then watch it again and follow along step by step in your own databases.

You can find a complete video tutorial with step-by-step instructions on everything discussed here on my website at the link below. Live long and prosper, my friends.

Topic List

Shared library database system overview

Primary Topics

reusable library dialog forms, returning values from library forms, shared queries, library distribution considerations, ACCDE compilation, source code protection, automatic ACCDE builder, library update workflow

Secondary Topics

copying forms into a library, network library locations, Access references, trusted locations, preserving prior compiled versions, error handling, status messages