This feature may not be available by default and might need to be enabled upon request. Please contact your account manager for more information.
Gain complete, end-to-end visibility into how data models and shared objects connect across every project in your entire organization from a single, centralized view. With the Global Lineage view, teams can eliminate guesswork and prevent costly downstream breaking changes before making schema updates. Search, explore, discover: this unified perspective breaks down organizational silos and gives teams a single pane of glass for object sharing across logical, physical, and business domains.
The view is built from existing global references and column lineage mappings, and follows the same plan availability as Global modeling. It is read-only: to add, change, or remove a reference or a mapping, work inside the relevant project as usual.
Opening Global lineage
Click the "Global lineage" icon from the left-nav menu on the Dashboard.
Additionally, jump to the Global Lineage screen from inside a project using the shortcut provided in the "Global reference summary."
Reading the lineage view
Every project in the account that takes part in a global reference is shown, regardless of who owns it or whether you are a member of it.
Each active global reference is drawn as a dashed connection from the project that shares the object (the parent project) to the project that uses it (the child project). The arrow always points toward the project that uses the object, so you can read the flow of data along the arrows. Lineage is transitive: if project A is referenced by project B, and B is referenced by project C, you can follow the chain A → B → C in one view.
The view reflects the latest revision of every project. Inactive references, and references to objects that no longer exist in the parent project's latest revision, are not shown.
By default, every project is collapsed into a single project node. A project node shows the expand control, the database type, the project name, and three counts: shared (objects this project shares with other projects), used (global objects it brought in from other projects), and mapped (column lineage mappings defined inside the project).
When both projects are collapsed, all the object-level references between them merge into one connection. A badge on the connection shows how many references it represents; a connection without a badge represents a single reference.
Expanding and collapsing projects
Click the "+" on a project node (or double-click the node) to expand it. An expanded project shows only the objects that take part in global references or column lineage mappings: the objects it shares with other projects, the global objects it uses, and the objects connected by a mapping. Other objects are not shown. Each object node shows the object name, qualified with its schema.
When one project is expanded and the other is collapsed, the connections run from each object to the collapsed project node.
When both projects are expanded, every reference is drawn as its own object-level connection, so you can see exactly which object feeds which. Connections keep their direction at every level of collapse.
Click "−" to collapse a project back into a single node. "Expand all" and "Collapse all" in the toolbar do the same for every project at once.
Inspecting projects, objects, and connections
Click a project node to select it. Its connections are highlighted, the project is highlighted in the Projects panel, and the "Project properties" panel opens on the right. It shows the project's name, folder, and database type, the number of objects it shares and uses, and two shortcuts: "Open project in new tab" and "Expand project" (or "Collapse project" when the project is already expanded).
"Open project in new tab" works for any project in the view, including projects you don't own or belong to. If you don't have access to the project, you will see the standard "project not found" page instead.
Click an object node to open "Object properties": the object's name, database, and schema, the project it belongs to, and, under "Sharing," the project that shares the object ("Shared by") and the project that uses it ("Used by").
Click a connection, or its count badge, to open "Sharing details." It lists every reference the connection represents, with the sharing and using project for each one.
Click an empty spot on the canvas, or the » button in the panel header, to clear the selection and close the panel.
Searching
Type in the "Search projects and objects…" box above the Projects panel to find a project, object, or mapped column by name. Search is not case sensitive and matches any part of the name. The panel shows how many matches were found and lists only the matching projects and objects. On the canvas, matching objects are highlighted, and the projects that contain them expand so the objects become visible. Click a match in the list to center the canvas on it.
Navigating the canvas
Drag an empty area of the canvas to pan, and use the mouse wheel or the "+" and "−" buttons in the top-left corner of the canvas to zoom. The toolbar next to the view title offers "Reset zoom" (back to 100%), "Zoom to fit" (fit every project on the screen), and "Refresh" (reload the view with the latest references from your projects).
"Zoom to fit" is a good way to get a picture of the whole account before you drill into a particular project. The minimap in the bottom-right corner of the canvas shows which part of the diagram you are looking at; click the arrow in its corner to hide or show it.
Column lineage mapping
A column lineage mapping documents, on a relationship, which source columns feed which target columns, together with the expression that derives each target column and a comment. A mapping can be added to any relationship type: physical foreign keys, virtual identifying and non-identifying relationships, virtual joins, and virtual dependencies. Mappings work in every project that supports relationships, including logical projects, on every database.
Mappings are created and edited inside a project, on the Column lineage analysis (CLA) screen, and every change is saved immediately. Global lineage then shows them alongside global references, down to the column level, so a column can be followed from its source to every place it is used across the account.
Creating a mapping
A mapping is created on a relationship that exists in a saved revision, so save the project first. Then, on the diagram, right-click the relationship line (or click the three-dot menu on the line) and select "Create column mapping." The same button is available in the "Column mapping" section of the relationship's properties editor.
The mapping screen opens in CLA with the target object (the child, or the right side of a join) on the right and the source object (the parent, or the left side) on the left, labeled with its alias. All columns of both objects are shown. If the source or the target takes part in other mappings, the full chain is drawn too: the sources of your source and the targets of your target.
Add rows to the mapping in any of three ways:
Drag a column from one object onto a column of the other. Dragging works in either direction; the row always runs from source to target.
Auto-map columns by name, from the three-dot menu in the source object's header. Every source column with an exact, case-insensitive name match in the target gets a row. Existing rows, expressions, and comments are left untouched, and a toast reports how many columns were mapped.
Map by name, from the right-click menu of a single source column, to match just that column.
Each row draws an arrow between the two columns and appends the source, as alias.column, to the target column's expression. A column fed by dimCustomer.firstName and dimCustomer.lastName starts with the expression "dimCustomer.firstName dimCustomer.lastName," ready to be edited into the real formula.
Once a relationship has a mapping, the menu item becomes "Open column mapping," a subtle marker appears on the relationship line on the diagram, and the target object is listed under "Mappings" in the CLA explorer. Creating and editing mappings requires edit rights on the project; other users can open the mapping screen read-only.
Editing a mapping
Open the mapping from the relationship line, from the relationship's properties editor, or from the "Mappings" section of the CLA explorer. Any mapping visible on the canvas can be edited; click a target object to switch the grid to it.
The "Mapping" tab in the bottom panel lists every column of the selected target object, including columns that have no source yet. For each target column it shows the sources as removable chips, an editable "Expression," and an editable "Comment." Above the grid, a "Mapping comment" field holds a note about the mapping as a whole, one field per source object. Fields are saved when you leave them.
Several source columns can map to one target column, and one source column can map to several target columns.
A target column can have an expression and a comment with no source at all, for constants and surrogate keys. It draws no arrow.
To remove a row, select its arrow on the canvas and press Delete, or remove the source chip in the grid. When the last source of a target column is removed, its expression is cleared.
Expressions are plain text. Renaming a column, an object, or an alias does not rewrite them, so update the expression yourself after a rename.
To change how the source object is labeled in this mapping, select "Edit alias" from the three-dot menu in its header. The alias is used for new rows and in Global lineage; existing expressions keep the old name.
"Remove mapping," in the same menu, deletes the mapping with all its rows. On a virtual dependency the item is "Clear mapping": the rows are removed, but the mapping itself stays (see the next section).
Hover over or click an arrow to highlight its row in the grid, and the reverse. Use "Hide unmapped columns" on the canvas menu to see only the columns that take part in a mapping. There is no undo: removing a row or clearing a field is the reversal. The relationship's properties editor shows the mapping comment and the rows read-only, as alias.column → target column.
Virtual dependencies: from table-level to column-level lineage
A virtual dependency relationship records that one object feeds another, which is table-level lineage inside the project. You can draw one yourself, and SqlDBM creates them automatically when you run "Analyze view" or "Analyze dynamic table": one dependency from each referenced object to the analyzed object.
Every virtual dependency gets a mapping as soon as the relationship is saved. The mapping starts empty, which is enough to place both objects on the lineage graph. To extend the lineage to column level, open the mapping and add rows as described above: drag columns, or use "Auto-map columns by name." Because the mapping belongs to the dependency, it cannot be removed, only cleared.
Column pairs that were defined on existing virtual dependencies have been carried into their mappings. The properties editor of a dependency now shows the mapping read-only instead of the column pair editor; other relationship types keep their column pairs as before.
Mappings in Global lineage
Global lineage reads the mappings of every project in the account (from the main branch) and draws them alongside global references. A mapping is a connection from the source object to the target object inside one project, so it appears when that project is expanded. Global references stay object-level connections between projects, as before.
Project nodes show a third count, mapped, next to shared and used: the number of mappings in the project.
An expanded project shows every object that takes part in a global reference or in a mapping.
Object nodes can be expanded too. An expanded object lists only the columns that take part in a mapping. "Expand all" and "Collapse all" apply to objects as well as projects.
When both objects are expanded, every row is drawn as its own column-to-column connection. When either object is collapsed, the rows merge into one object-level connection with a badge showing the number of rows.
A connection backed by mapped columns is drawn slightly differently from one without rows (an empty mapping or a global reference), so you can tell at a glance where column-level lineage exists.
A source object that reaches the same target through two relationships appears twice, once per alias.
Click a mapped column, or a column-to-column connection, to open its properties: the target column, each source as alias.column with its project, the expression, the column comment, the mapping comment, the relationship name, and who created or last updated the mapping and when. Click an object-level mapping connection to see the source and target objects, the alias, the mapping comment, the relationship name, the number of rows, and the same audit details. The panel is read-only: to change a mapping, open it in the project.
Searching columns
The search box above the Projects panel matches column names as well as project and object names. When a column matches, its project and object expand, the column is highlighted, and the canvas centers on it. Click the column to read its sources, expression, and comments in the properties panel. Search matches names, not expression text: look up a column by name, then read its expression in the panel.
When there are no global references yet
If no project in the account uses global references or column lineage mappings, the view is empty and explains how to get started: enable Global modeling on a project and reference its objects from another project, or create a column mapping on a relationship. See the "Global Modeling - Overview" article for the steps.