> For the complete documentation index, see [llms.txt](https://v2.dataos.info/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://v2.dataos.info/references/engine-guide/microsoft-fabric.md).

# Microsoft Fabric

Technical reference for building and running Data Products on Microsoft Fabric Warehouse, covering connection, authentication, materialization, and troubleshooting.

Microsoft Fabric Warehouse is a SaaS T-SQL data warehouse built on top of OneLake, with Entra-ID-only authentication and warehouse lifecycle managed through the Fabric REST API rather than classic DDL. Vulcan runs against the Fabric Warehouse SQL endpoint to manage transformations with version control and gated deployments. This page is the full manual: connection and authentication, how each model kind materializes, the catalog (warehouse) creation workaround, `ALTER TABLE` limitations, and the failure modes you hit in real projects.

{% hint style="info" %}
**Community-supported adapter**

The Fabric engine adapter is a community contribution. Treat production use accordingly: validate every model kind and workaround in this page against your own Fabric capacity before depending on it for critical workloads.
{% endhint %}

## When to use

Choose Fabric Warehouse when your organization already standardizes on Microsoft Fabric for its lakehouse/warehouse estate and you want a governed SQL endpoint over OneLake-backed data without provisioning separate infrastructure. Fabric Warehouse is not a general-purpose SQL Server: it has a deliberately restricted T-SQL surface (no indexes, no explicit transactions, limited `ALTER TABLE`), and warehouse-level lifecycle operations run through an asynchronous management API rather than synchronous DDL. Vulcan's Fabric adapter is a subclass of the MSSQL adapter and inherits its `MERGE`, bulk-load, and column-introspection logic, adjusted for what Fabric Warehouse actually supports.

{% hint style="info" %}
⚠️ **Warehouse only: no Lakehouse, OneLake, or other Fabric item types**

Vulcan's fabric adapter targets only the Fabric Warehouse SQL analytics endpoint. It does not support, and this page does not cover:

Fabric Lakehouse (the Delta/Parquet-over-OneLake item type): a different storage item with its own SQL endpoint and its own semantics; not created, read, or written by this adapter.\
OneLake direct access (ADLS-style file/folder access to the underlying storage): out of scope; the adapter only talks to the Warehouse's T-SQL endpoint, never to OneLake paths directly.\
Direct Lake mode (Power BI's semantic-model layer reading Delta tables straight from OneLake): a separate Fabric/Power BI feature, not something Vulcan configures or materializes into.\
Spark notebooks / Fabric Spark compute: a different Fabric engine entirely; for Spark-based lakehouse workloads use the Spark engine guide.\
Any other Fabric item type (KQL databases, Data Factory pipelines, Eventstreams, Data Activator, ML models/experiments, etc.): none of these are provisioned or read by the fabric adapter.

If a project needs any of the above, treat it as a separate Fabric integration outside Vulcan's fabric engine adapter.
{% endhint %}

{% hint style="info" %}
This page covers the Fabric **Warehouse** SQL endpoint only. Fabric Lakehouse, Spark notebooks, OneLake direct access, and Direct Lake mode are separate Fabric surfaces not driven by this adapter; for lakehouse-style Spark workloads, use the [Spark engine guide](https://v2.dataos.info/references/engine-guide/spark-1.md) instead.
{% endhint %}

### Supported model kinds

`FULL`, `SEED`, `VIEW`, `INCREMENTAL_BY_TIME_RANGE`, `INCREMENTAL_BY_UNIQUE_KEY`, `INCREMENTAL_BY_PARTITION`, `INCREMENTAL_UNMANAGED`, `SCD_TYPE_2`, `SCD_TYPE_2_BY_TIME`, `SCD_TYPE_2_BY_COLUMN`, and `EMBEDDED` are inherited from the base MSSQL adapter. `MANAGED` models and table cloning are not supported.

### Engine characteristics

| Property            | Value                                                                |
| ------------------- | -------------------------------------------------------------------- |
| Engine adapter type | `fabric`                                                             |
| Model dialect       | `fabric`, a dedicated sqlglot dialect distinct from `tsql`           |
| Support level       | Community contribution with limited community support                |
| Connection endpoint | Fabric Warehouse SQL analytics endpoint                              |
| Compute             | No separate driver or executor cluster to size                       |
| Warehouse lifecycle | Fabric REST API manages asynchronous warehouse creation and deletion |
| Tested Vulcan image | `tmdcio/vulcan-fabric:0.228.1.30` on the Draco 1.38 series           |

Once you choose Microsoft Fabric as your Data Product engine, use this guide to explore **Authorize, Connect, Build, Serve, Operate, and Troubleshoot**: covering access, connectivity, model development, data serving, performance, and issue resolution.

Depending on where you are starting from, you may enter this path at a different point.

## Authorize

Provision Fabric and DataOS access before configuring a gateway or deploying a Data Product.

For role design, grant requirements, and DataOS permissions, see [Permissions and grants](https://v2.dataos.info/references/engine-guide/microsoft-fabric/permissions-and-grants.md).

## Connect

This is the first hands-on step after access provisioning.

For connection options, gateway configuration, local development, and production deployment, see [Connect to Microsoft Fabric](https://v2.dataos.info/references/engine-guide/microsoft-fabric/connect-to-microsoft-fabric.md).

## Build models

Choose a model strategy after you validate the connection.

For model-kind behavior, catalog lifecycle, schema changes, and Fabric constraints, see [Materialization behavior](https://v2.dataos.info/references/engine-guide/microsoft-fabric/materialization-behavior.md).

## Serve

Use these sections after model deployment. They cover consumer access, catalog visibility, and Fabric-specific capabilities.

### Endpoints

Every deployed Data Product gets REST, GraphQL, and MySQL-wire endpoints, all pushing down to the same Fabric gateway. Large result sets are buffered before streaming; size `api.resources.limits.memory` for expected payloads, with 3 GiB a practical starting point for high-row responses.

### Metadata scanning and catalog

DataOS scans `INFORMATION_SCHEMA` and the subset of `sys.*` catalog views exposed by Fabric Warehouse. Lineage comes primarily from parsed model definitions and Vulcan's model graph, since Fabric's query-history surface for warehouse workloads is more limited than Snowflake's `ACCOUNT_USAGE`. Use a scanner service principal with the **Viewer** workspace role, separate from the Vulcan service principal used for `rw`.

Scanner cadence is commonly every 6 to 12 hours. If lineage is missing after `vulcan apply`, verify `inputs.yaml`, then wait for the next scan.

### Engine-native feature support

| Feature                               | How                                                      | Notes                                                           |
| ------------------------------------- | -------------------------------------------------------- | --------------------------------------------------------------- |
| Warehouse (catalog) creation/deletion | Fabric REST API, driven by the adapter                   | Asynchronous; the adapter polls until ready.                    |
| Schema                                | Referenced by model names                                | Created automatically when the service principal has privilege. |
| Regular / incremental table           | FULL and incremental models                              |                                                                 |
| View                                  | `kind VIEW`                                              | `CREATE OR ALTER VIEW`.                                         |
| SCD history                           | `SCD_TYPE_2_BY_TIME` / `SCD_TYPE_2_BY_COLUMN`            |                                                                 |
| Unique-key upsert                     | `INCREMENTAL_BY_UNIQUE_KEY`                              | Native `MERGE INTO`, same as MSSQL.                             |
| Time-range / partition overwrite      | `INCREMENTAL_BY_TIME_RANGE` / `INCREMENTAL_BY_PARTITION` | `DELETE` + `INSERT`, not `MERGE`.                               |
| Column type change                    | Guarded `ALTER TABLE`                                    | Four-step rewrite workaround; see above.                        |
| Indexes                               | Not supported                                            | No index DDL path on this adapter.                              |
| Explicit transactions                 | Not supported                                            | `SUPPORTS_TRANSACTIONS` is off.                                 |
| Materialized view                     | Not supported by this adapter                            |                                                                 |
| Table cloning                         | Not supported                                            |                                                                 |
| MANAGED model kind                    | Not supported                                            |                                                                 |

Boundaries: indexing, explicit multi-statement transactions, materialized views, table cloning, MANAGED models, and the Lakehouse/Spark/OneLake side of Fabric (a separate surface not driven by this adapter). Treat workspace capacity assignment, Fabric admin-portal settings, and cross-workspace sharing as Fabric admin boundaries.

## Operate safely

Set workload limits before scaling consumers or production schedules.

For capacity, concurrency, scheduling, and performance guidance, see [Limits & performance](https://v2.dataos.info/references/engine-guide/microsoft-fabric/limits-and-performance.md).

## Troubleshooting

Use these checks when configuration, deployment, or runtime behavior needs investigation.

For failure modes, health checks, and recovery procedures, see [Troubleshooting](https://v2.dataos.info/references/engine-guide/microsoft-fabric/troubleshooting.md).

## Full implementation example

Use this complete Data Product as a production-shaped starting point.

{% file src="/files/DbABYU9YV4Pc3SagPUPJ" %}

## Related

* [MSSQL manual](https://v2.dataos.info/references/engine-guide/sql-server.md) for the adapter this engine subclasses (grants, MERGE tuning, and general T-SQL behavior carry over except where this page calls out a difference).
* [Engine guide overview](https://v2.dataos.info/references/engine-guide/engine-guide.md) for the cross-engine rules.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://v2.dataos.info/references/engine-guide/microsoft-fabric.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
