Erik's ToolBox Documentation
Index

Symbols Overview

What Are Symbols?

Symbols are structured metadata descriptions of all objects in your Business Central environment. They contain detailed information about tables, pages, reports, codeunits, enums, and other AL objects that are part of the base application and any installed extensions.

When you work with AL code in Erik's ToolBox, symbols provide the foundation for intelligent editing features. Instead of requiring you to memorize exact object names, field names, method signatures, and option values, the toolbox reads this metadata and offers context-aware suggestions as you type.

Without symbols loaded, you would need to manually look up and type every table name, field name, method call, and enum value exactly as defined. With symbols, the toolbox can auto-complete these for you, validate references, and surface relevant options in real time.

In practical terms, symbols are extracted from the compiled .app packages of installed extensions. Each extension publishes a symbol file that describes every object the extension defines or extends. The toolbox downloads these symbol files, parses them, and stores the extracted metadata in a set of local Business Central tables optimized for fast querying.

Why Symbols Matter

Symbols unlock several key capabilities in Erik's ToolBox:

  • IntelliSense and Auto-Completion. As you type AL code in the interactive code editor, the toolbox uses symbol data to suggest matching table names, field names, page controls, methods, and enum values. This dramatically reduces typing errors and speeds up development.
  • Validation. When you reference an object or field, the toolbox can verify that it exists and that the data type is correct. This catches mistakes before you compile or deploy.
  • Object Discovery. You can browse all available objects, fields, and methods without leaving the toolbox. This is especially valuable when working with unfamiliar extensions or exploring the base application.
  • Cross-Reference Navigation. Symbols enable the toolbox to understand relationships between objects. For example, you can see which pages are associated with a given table, or which reports consume specific data items.
  • Consistent Development Experience. Because symbols are stored locally and queried in real time, every developer using the toolbox against the same environment sees the same set of objects and definitions. This promotes consistency across teams and reduces the chance of referencing objects that exist only in one developer's local build.

What Information Is Stored

When symbols are downloaded and processed, the toolbox extracts metadata into several dedicated tables. Each table captures a specific category of object information. The following sections describe what each table holds and how the data is used.

Tables and Fields

The Table Metadata table stores high-level information about every table object, including the table ID, name, and the extension it belongs to. The Field Metadata table stores the individual fields within each table, including the field ID, name, data type, and length. Together, these two tables give you a complete picture of the data model for any extension.

Field metadata includes all standard AL data types: Code, Text, Integer, Decimal, Boolean, Date, Time, DateTime, Option, Enum, GUID, BLOB, Media, MediaSet, RecordID, BigInteger, and others. Knowing the exact type of a field is essential when writing filter expressions, performing calculations, or passing values to procedures.

Pages, Controls, and Actions

The Page Metadata table records each page object along with its type (Card, List, Worksheet, and so on) and source table. The Page Control Metadata table captures the controls on each page, including field mappings and control types. The Page Action Metadata table stores the actions defined on each page, such as navigation actions, processing actions, and promoted actions.

Control metadata lets you understand the user interface structure of any page without opening the page in the client. This is helpful when building integrations or writing test code that interacts with page controls programmatically.

Action metadata shows you the full set of actions available on a page, including the objects they run, which helps you trace navigation paths through the application.

Reports and Data Items

The Report Metadata table holds report-level information including the report ID, name, and processing-only flag. The Report DataItem table stores the data items within each report, describing which tables the report reads from and the relationships between data items.

Data item metadata captures the hierarchical structure of report data items. Parent-child relationships between data items define how the report loops through records, which is critical information when you need to understand a report's data flow or extend it with additional data items.

Codeunit Methods

The Object Method Metadata table captures the public methods (procedures and triggers) exposed by codeunits and other objects. This includes the method name, parameters, and return type, enabling IntelliSense to suggest method calls with correct signatures.

Method metadata covers both user-defined procedures and standard triggers. For procedures, the parameter list includes each parameter's name, data type, and whether it is passed by reference or by value. For triggers, the metadata captures the trigger name and the event it responds to.

Enum Values

Enum definitions are captured as part of the symbol extraction process. When you reference an enum type in your code, the toolbox can show you the complete list of defined values, making it easy to select the correct member without consulting the source code or documentation.

Installed Extensions

The Installed Extension table maintains a cached list of all extensions installed in the target Business Central environment. This table drives the symbol download process by identifying which extensions have symbols available for extraction.

Each extension record includes the app ID, name, publisher, version, and scope. This information helps you identify which extensions contribute symbols and manage which ones should be included in or excluded from the download.

How Symbols Are Organized

Symbols are grouped by extension. Each installed extension in your Business Central environment publishes its own set of symbols. When the toolbox downloads symbols, it processes each extension independently. This means you can download symbols for specific extensions, clear symbols for extensions you no longer need, and refresh individual extensions without affecting the rest.

The symbol metadata tables use the extension app ID as a key relationship field. This allows the toolbox to filter and display symbols scoped to a particular extension when needed, or to search across all extensions for a global view.

Because each extension's symbols are stored independently, updating symbols for one extension does not require re-downloading or re-processing any other extension. This design keeps refresh operations fast and targeted.

Symbol Scope

The symbols available to you depend on what is installed in the target Business Central environment. This typically includes:

  • The Base Application. All standard Business Central tables, pages, reports, codeunits, and enums. This is the largest symbol set and includes core objects like Customer, Vendor, Item, Sales Header, Purchase Header, General Ledger Entry, and thousands more.
  • The System Application. Lower-level system objects and interfaces, including codeunits for HTTP communication, JSON handling, encryption, email, and other platform services.
  • Microsoft First-Party Extensions. Extensions published by Microsoft, such as AMC Banking, Late Payment Prediction, Envestnet Yodlee Bank Feeds, and others included in the standard Business Central deployment.
  • Third-Party and Custom Extensions. Any ISV or custom extensions installed in your environment. These often add industry-specific objects, custom tables, and specialized processing codeunits.

Each of these contributes its own set of symbols. The more extensions you have installed, the richer the symbol data available for IntelliSense and object browsing.

The Symbol Management Codeunit

All symbol operations are handled by the Symbol Management codeunit. This codeunit provides the following core functions:

Function Purpose
DownloadSymbols() Downloads symbol files from the Business Central environment for all configured extensions.
ProcessSymbols() Parses downloaded symbol files and extracts metadata into the local tables.
ClearSymbolsFor() Removes all stored symbol data for a specific extension.
ExtractFromFields() Extracts field metadata from table symbols.
ExtractFromPageControls() Extracts page control metadata from page symbols.
ExtractFromPageActions() Extracts page action metadata from page symbols.
ExtractFromDataItems() Extracts data item metadata from report symbols.

You do not need to call these functions directly in most cases. The toolbox provides user-facing actions that invoke these functions behind the scenes. However, understanding the codeunit structure can be helpful if you are extending the symbol system or troubleshooting issues.

The extraction functions are called internally by ProcessSymbols(). They are separated into distinct functions so that each category of metadata (fields, page controls, page actions, data items) is handled by focused, maintainable logic. If you are building custom integrations on top of the symbol system, you can call these functions individually.

When to Refresh Symbols

Symbols represent a snapshot of the objects available at the time of download. They do not update automatically when extensions are installed, updated, or removed. You should refresh symbols in the following situations:

  • After installing a new extension in your environment.
  • After updating an existing extension to a new version that adds, removes, or changes objects.
  • After removing an extension, so that stale symbol data is cleared.
  • When you notice that IntelliSense suggestions are missing objects you expect to find.
  • Periodically, as part of routine environment maintenance, to catch any changes you may have missed.

Refreshing symbols is a lightweight operation for most environments, though the time required scales with the number and size of installed extensions. See Symbols Usage for details on how to trigger a refresh and monitor progress.

Symbol Metadata Tables at a Glance

The following table summarizes all of the metadata tables that the symbol system uses. Each table is populated during the symbol download and processing workflow.

Table Stores
Table Metadata Table objects (ID, name, extension)
Field Metadata Fields within tables (ID, name, type, length)
Page Metadata Page objects (ID, name, type, source table)
Page Control Metadata Controls on pages (field mappings, control types)
Page Action Metadata Actions on pages (action type, target)
Report Metadata Report objects (ID, name, processing flags)
Report DataItem Data items within reports (source table, relationships)
Object Method Metadata Public methods on objects (name, parameters, return type)
Installed Extension Cached list of installed extensions
Symbols Setup Configuration for symbol download and processing

These tables are standard Business Central tables and can be queried, filtered, and sorted like any other table in the system. The toolbox provides dedicated list pages for browsing each table, but you can also access them through the standard Business Central table viewer if needed.

Next Steps

If you have not yet configured your symbol source, start with the Symbols Setup guide. That chapter walks you through configuring your connection to the Business Central environment for both SaaS and on-premises deployments.

If your setup is already complete and you want to download or manage symbols, proceed to Symbols Usage. That chapter covers the download process, browsing metadata, clearing symbols, and using symbols in the code editor and Object Inspector.

For a quick reference on how symbols power the code editing experience, see the Interactive Code Editor documentation.