Microsoft SQL Server Reporting Services - Lineage

This document outlines the lineage coverage, configuration requirements, supported components, transformation support, supported use cases, partial or limited coverage, unsupported scenarios, and current functional status for lineage extraction in Microsoft SQL Server Reporting Services (SSRS).

The SSRS connector provides end-to-end lineage from backend database tables and columns through report datasets to SSRS report fields and visual elements. It supports static SQL datasets, stored procedure datasets, Shared Datasets, report parameters, and direct report-field mappings. The connector also provides lineage across report elements such as Textboxes, Tablix cells, and Charts, with production-ready coverage for core static SQL and stored-procedure scenarios.

Lineage Configuration Requirements

Successful lineage extraction depends on valid SSRS connection details, appropriate authentication, available RDL and Shared Dataset metadata, and crawled backend database objects. The following requirements apply to SSRS lineage extraction.

Configuration Requirements Table

Configuration	Required Detail
SSRS Connection	SSRS connection details must include the Host/IP, Web Port, and SSRS Web URL.
Authentication	Username, Password, and Domain are required for Windows or SQL authentication. File Authentication is supported for uploaded RDL and RSD files.
Backend Database Connection	A backend database JDBC connection must be available, and referenced database objects must already be crawled or cataloged.
RDL Metadata	RDL XML must be available as crawled source metadata for report and report-element lineage.
Shared Dataset Metadata	Shared Dataset XML must be available as crawled source metadata where Shared Datasets are used.
Report Fields and Expressions	Report fields and expressions must be extracted before lineage is built.
SQL Parsing Dialects	SQL parsing dialects can be configured where required for SQL lineage extraction.
Connection Priority	Connection priority can be configured for stored-procedure source resolution where multiple connections contain similar database objects.
JDBC Query Timeout	JDBC query timeout can be configured where required for stored-procedure processing or long-running metadata queries.

Missing SSRS metadata, unavailable backend database connections, un-crawled database objects, incomplete RDL or Shared Dataset XML, or insufficient authentication access may result in incomplete lineage generation.

Lineage Components

The following table identifies the SSRS components and lineage features supported by the connector.

Component / Feature	Supported
Reports (Chart objects)	✅
Report Fields / Textboxes / Tablix cells	✅
Backend Tables	✅
Backend Views	✅
Stored Procedures	✅ / ⚠️
Shared Datasets	✅
Report Parameters	✅
Inline SQL Datasets	✅
Aggregate / Derived Expressions	⚠️
Multi-field Expressions	⚠️
Sub Reports / Drill-through	❌ / ⚠️
Custom VB.NET <Code> Functions	❌
Dynamic / Expression-built SQL	❌
Chart / Gauge / Tablix Grouping Expressions	⚠️
File-authenticated RDL / RSD Parsing	⚠️

The ⚠️ icon indicates partially supported functionality where lineage coverage depends on expression complexity, stored-procedure result-set availability, report structure, or the quality of the RDL/RSD metadata.

Column Creation Support

This section outlines lineage support for columns created through direct report-field mappings, aggregate expressions, multi-field expressions, report parameters, stored procedure result sets, and custom expressions.

Column Creation from Lineage

Transformation Type	Supported
Direct Field Bind (=Fields!Col.Value)	✅
Aggregate Expressions (=Sum / Count / etc.)	⚠️
Multi-field / Concatenated Expressions	⚠️
Report-Parameter-Derived Columns	✅
Stored Procedure Result Columns	✅ / ⚠️
Custom Code / Expressions without Dataset Field Reference	❌

The ⚠️ icon indicates partial column-level lineage coverage. Source fields can be identified in supported expressions, but complex transformation logic may not be decomposed into individual lineage relationships.

Supported Use Cases

The SSRS connector supports lineage extraction across backend database objects, report datasets, report fields, report parameters, and supported report visual elements.

Supported Lineage Scenarios

Supported Scenario	Details
Static SQL Dataset → Report Lineage	Lineage from static SQL dataset definitions to SSRS Reports and report fields.
Stored Procedure Dataset → Report Lineage	Lineage from stored procedure datasets to Reports and report fields when result columns can be resolved.
Shared Dataset → Report Lineage	Lineage from Shared Datasets to Reports that reference the datasets.
Report Parameter → Dataset Field Lineage	Lineage between Report Parameters and associated Dataset Fields.
Direct Report-field Mapping	Direct field mappings such as Fields!Column.Value are traced from dataset fields to report fields or visual elements.
Backend Table / View → Dataset → Report → Report Field Lineage	End-to-end lineage from backend Tables and Views through Datasets and Reports to report fields.
Multi-data-source Report Lineage	Lineage across Reports that reference multiple data sources when all referenced databases are onboarded and crawled.
File-based RDL / Shared Dataset Processing	Lineage processing for standard SSRS RDL and Shared Dataset exports when the required metadata is available.
Report Field → Visual Element Lineage	Lineage from report fields to supported Textboxes, Tablix cells, Charts, and other report elements.
Report Parameter Lineage	Lineage from supported Report Parameters to associated Dataset Fields.

Lineage extraction depends on available RDL and Shared Dataset metadata, crawled backend database objects, SQL parsing, stored-procedure result-set resolution, and supported report-field mappings.

Partial or Limited Coverage

Certain SSRS scenarios provide partial lineage coverage because expression logic, stored-procedure result sets, report navigation, or report-element metadata may not provide enough information for complete lineage resolution.

Scenarios

Scenario	Limitation Description	Recommendation / Workaround
Aggregate Expressions	Source fields are traced, but aggregation logic remains represented in the raw expression rather than as a fully decomposed transformation.	Validate aggregate transformation logic separately where expression-level lineage is required.
Multi-field / Derived Expressions	Referenced fields are linked individually, but the combined transformation is not decomposed into a detailed expression-level lineage path.	Validate complex derived expressions manually where required.
Stored Procedures with Dynamic Result Sets	Stored procedures with dynamic or unknown result sets may not provide complete source-column resolution.	Validate stored-procedure result schemas manually where required.
Sub Reports / Drill-throughs	Sub reports and drill-through relationships are inventoried, but parent-to-child lineage is not automatically propagated.	Validate parent-to-child report dependencies manually where required.
Chart / Gauge / Tablix Grouping Expressions	Grouping and series expressions are available for diagnostic purposes but are not converted into lineage edges.	Validate grouping and series dependencies separately where required.
File-authenticated RDL / RSD Parsing	Parsing provides best-effort coverage for malformed or non-standard RDL/RSD exports.	Use standard RDL/RSD exports where possible and validate affected lineage manually.
Stored Procedure Result Columns	Result-column lineage can vary when the stored procedure does not expose a stable result schema.	Ensure a resolvable result schema is available and validate affected mappings manually.

Complex expressions, dynamic stored-procedure result sets, sub reports, drill-throughs, grouping expressions, and malformed or non-standard RDL/RSD files may reduce lineage completeness and column-level accuracy.

Unsupported Scenarios

The connector does not support lineage extraction for runtime-generated SQL, custom VB.NET code, automatic parent-to-child parameter propagation, or execution-log-based lineage.

Unsupported Lineage

Not Supported	Description	Recommendation / Workaround
Dynamic SQL	SQL constructed through string concatenation or expression-built CommandText is not resolved for lineage extraction.	Use statically defined SQL where possible and validate dynamic dependencies manually.
Custom VB.NET <Code> Functions	Custom VB.NET code functions are not parsed for lineage extraction.	Validate dependencies introduced through custom code separately where required.
Automatic Parent → Sub report / Drill-through Parameter Propagation	Parameter propagation between parent Reports and Sub Reports or drill-through Reports is not automatically represented as lineage.	Validate report navigation and parameter dependencies separately.
ExecutionLog3-based Lineage	Usage or audit-log-based lineage from ExecutionLog3 is not part of the active lineage pipeline.	Use metadata-based lineage for supported SSRS dependencies and review execution information separately where required.
Custom Code / Expressions without Dataset Field Reference	Expressions that do not reference a Dataset Field are not resolved into source-column lineage.	Validate custom expression dependencies manually where required.

Unsupported scenarios do not generate complete lineage and may result in missing or disconnected lineage relationships within lineage visualization.

Current Functional Status

This section outlines the current lineage capabilities and coverage of the Microsoft SQL Server Reporting Services connector.

Status Area	Details
Overall Coverage	Production-ready coverage across core SSRS static SQL and stored-procedure dataset scenarios, Shared Datasets, Reports, report fields, and supported visual elements.
Lineage Depth	Backend table- and column-level lineage through Datasets to Reports, report fields, Textboxes, Tablix cells, and Charts.
Supported Inputs	Reports, Chart objects, Report Fields, Textboxes, Tablix cells, backend Tables and Views, Stored Procedures, Shared Datasets, Report Parameters, Inline SQL Datasets, and RDL/RSD metadata.
Functional Scope	End-to-end lineage from backend database Tables and Views through SQL or stored-procedure Datasets to SSRS Reports and report visual elements.
Transformation Support	Direct field bindings and Report-Parameter-Derived Columns are supported. Aggregate, multi-field, derived, and stored-procedure result-column transformations have partial coverage.
Limitation Areas	Aggregate and multi-field expressions, dynamic stored-procedure result sets, Sub Reports, Drill-throughs, grouping expressions, and non-standard RDL/RSD files have partial coverage.
Unsupported Areas	Dynamic SQL, custom VB.NET <Code> functions, automatic parent-to-child parameter propagation, execution-log-based lineage, and custom expressions without Dataset Field references are not supported.
Resulting Output	Reliable lineage for the core SSRS workflow from static SQL or stored-procedure Datasets through Dataset Fields to Report Fields and visual elements, with partial or unsupported coverage for dynamic and complex scenarios.

The Microsoft SQL Server Reporting Services connector provides production-ready lineage coverage for the core SSRS scenario of static SQL or stored-procedure Datasets → Dataset Fields → Report Fields and visual elements. Backend Tables, Views, Shared Datasets, Report Parameters, and direct field mappings are supported. Aggregate and multi-field expressions, dynamic stored-procedure result sets, Sub Reports, Drill-throughs, grouping expressions, and non-standard RDL/RSD files have partial coverage. Dynamic SQL, custom VB.NET code, automatic parent-to-child parameter propagation, and execution-log-based lineage are not supported and may require manual validation or lineage supplementation.

---

Copyright © 2026, OvalEdge LLC, Peachtree Corners, GA, USA.