semantic-link-labs 0.12.8__py3-none-any.whl

sempy_labs/directlake/_directlake_schema_compare.py

@@ -0,0 +1,120 @@
+import sempy.fabric as fabric
+import pandas as pd
+from .._helper_functions import (
+    format_dax_object_name,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name,
+)
+from IPython.display import display
+from ..lakehouse import get_lakehouse_columns
+from ..directlake._dl_helper import get_direct_lake_source
+from typing import Optional
+import sempy_labs._icons as icons
+from sempy._utils._log import log
+from uuid import UUID
+
+
+@log
+def direct_lake_schema_compare(
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    **kwargs,
+):
+    """
+    Checks that all the tables in a Direct Lake semantic model map to tables in their corresponding lakehouse and that the columns in each table exist.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    """
+
+    if "lakehouse" in kwargs:
+        print(
+            "The 'lakehouse' parameter has been deprecated as it is no longer necessary. Please remove this parameter from the function going forward."
+        )
+        del kwargs["lakehouse"]
+    if "lakehouse_workspace" in kwargs:
+        print(
+            "The 'lakehouse_workspace' parameter has been deprecated as it is no longer necessary. Please remove this parameter from the function going forward."
+        )
+        del kwargs["lakehouse_workspace"]
+
+    fabric.refresh_tom_cache(workspace=workspace)
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+
+    artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
+        get_direct_lake_source(dataset=dataset_id, workspace=workspace_id)
+    )
+
+    if artifact_type == "Warehouse":
+        raise ValueError(
+            f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
+        )
+
+    dfP = fabric.list_partitions(dataset=dataset_id, workspace=workspace_id)
+
+    if not any(r["Mode"] == "DirectLake" for _, r in dfP.iterrows()):
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset_name}' semantic model within the '{workspace_name}' workspace is not in Direct Lake mode."
+        )
+
+    if artifact_type is None:
+        raise ValueError(
+            f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
+        )
+
+    lakehouse_workspace = resolve_workspace_name(workspace_id=lakehouse_workspace_id)
+    dfT = fabric.list_tables(dataset=dataset_id, workspace=workspace_id)
+    dfC = fabric.list_columns(dataset=dataset_id, workspace=workspace_id)
+    lc = get_lakehouse_columns(lakehouse_name, lakehouse_workspace)
+
+    dfT.rename(columns={"Type": "Table Type"}, inplace=True)
+    dfP_filt = dfP[dfP["Mode"] == "DirectLake"]
+    dfC = pd.merge(dfC, dfP[["Table Name", "Query"]], on="Table Name", how="inner")
+    dfC = pd.merge(
+        dfC,
+        dfT[["Name", "Table Type"]],
+        left_on="Table Name",
+        right_on="Name",
+        how="inner",
+    )
+    dfC["Full Column Name"] = format_dax_object_name(dfC["Query"], dfC["Source"])
+    dfC_filt = dfC[dfC["Table Type"] == "Table"]
+    # Schema compare
+    missingtbls = dfP_filt[~dfP_filt["Query"].isin(lc["Table Name"])]
+    missingtbls = missingtbls[["Table Name", "Query"]]
+    missingtbls.rename(columns={"Query": "Source Table"}, inplace=True)
+    missingcols = dfC_filt[~dfC_filt["Full Column Name"].isin(lc["Full Column Name"])]
+    missingcols = missingcols[
+        ["Table Name", "Column Name", "Type", "Data Type", "Source"]
+    ]
+    missingcols.rename(columns={"Source": "Source Column"}, inplace=True)
+
+    if len(missingtbls) == 0:
+        print(
+            f"{icons.green_dot} All tables exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
+        )
+    else:
+        print(
+            f"{icons.yellow_dot} The following tables exist in the '{dataset_name}' semantic model within the '{workspace_name}' workspace"
+            f" but do not exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
+        )
+        display(missingtbls)
+    if len(missingcols) == 0:
+        print(
+            f"{icons.green_dot} All columns exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
+        )
+    else:
+        print(
+            f"{icons.yellow_dot} The following columns exist in the '{dataset_name}' semantic model within the '{workspace_name}' workspace "
+            f"but do not exist in the '{lakehouse_name}' lakehouse within the '{lakehouse_workspace}' workspace."
+        )
+        display(missingcols)

sempy_labs/directlake/_directlake_schema_sync.py

@@ -0,0 +1,161 @@
+import sempy
+import pandas as pd
+from ..lakehouse import get_lakehouse_columns
+from ._dl_helper import get_direct_lake_source
+from ..tom import connect_semantic_model
+from .._helper_functions import (
+    _convert_data_type,
+    resolve_workspace_name_and_id,
+    resolve_dataset_name_and_id,
+)
+from typing import Optional
+from sempy._utils._log import log
+import sempy_labs._icons as icons
+from uuid import UUID
+
+
+@log
+def direct_lake_schema_sync(
+    dataset: str | UUID,
+    workspace: Optional[str | UUID] = None,
+    add_to_model: bool = False,
+    remove_from_model: bool = False,
+) -> pd.DataFrame:
+    """
+    Shows/adds columns which exist in the lakehouse but do not exist in the semantic model (only for tables in the semantic model).
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    add_to_model : bool, default=False
+        If set to True, columns which exist in the lakehouse but do not exist in the semantic model are added to the semantic model. No new tables are added.
+    remove_from_model : bool, default=False
+        If set to True, columns which exist in the semantic model but do not exist in the lakehouse are removed from the semantic model. No new tables are removed.
+
+    Returns
+    -------
+    pandas.DataFrame
+        A pandas dataframe showing the status of columns in the semantic model and lakehouse (prior to adding/removing them from the model using this function).
+    """
+
+    sempy.fabric._client._utils._init_analysis_services()
+    import Microsoft.AnalysisServices.Tabular as TOM
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(dataset, workspace_id)
+
+    artifact_type, lakehouse_name, lakehouse_id, lakehouse_workspace_id = (
+        get_direct_lake_source(dataset=dataset_id, workspace=workspace_id)
+    )
+
+    if artifact_type == "Warehouse":
+        raise ValueError(
+            f"{icons.red_dot} This function is only valid for Direct Lake semantic models which source from Fabric lakehouses (not warehouses)."
+        )
+
+    if artifact_type is None:
+        raise ValueError(
+            f"{icons.red_dot} This function only supports Direct Lake semantic models where the source lakehouse resides in the same workpace as the semantic model."
+        )
+
+    lc = get_lakehouse_columns(lakehouse_id, lakehouse_workspace_id)
+
+    readonly = True
+    if add_to_model or remove_from_model:
+        readonly = False
+    df = pd.DataFrame(
+        columns=[
+            "TableName",
+            "ColumnName",
+            "SourceTableName",
+            "SourceColumnName",
+            "Status",
+        ]
+    )
+
+    with connect_semantic_model(
+        dataset=dataset_id, readonly=readonly, workspace=workspace_id
+    ) as tom:
+        # Check if the columns in the semantic model exist in the lakehouse
+        for c in tom.all_columns():
+            column_name = c.Name
+            table_name = c.Parent.Name
+            partition_name = next(p.Name for p in c.Table.Partitions)
+            p = c.Table.Partitions[partition_name]
+            if p.SourceType == TOM.PartitionSourceType.Entity:
+                entity_name = p.Source.EntityName
+                source_column = c.SourceColumn
+                lc_filt = lc[
+                    (lc["Table Name"] == entity_name)
+                    & (lc["Column Name"] == source_column)
+                ]
+                # Remove column from model if it doesn't exist in the lakehouse
+                if lc_filt.empty:
+                    new_data = {
+                        "TableName": table_name,
+                        "ColumnName": column_name,
+                        "SourceTableName": entity_name,
+                        "SourceColumnName": source_column,
+                        "Status": "Not in lakehouse",
+                    }
+                    df = pd.concat(
+                        [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+                    if remove_from_model:
+                        tom.remove_object(object=c)
+                        print(
+                            f"{icons.green_dot} The '{table_name}'[{column_name}] column has been removed from the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
+                        )
+
+        # Check if the lakehouse columns exist in the semantic model
+        for i, r in lc.iterrows():
+            lakeTName = r["Table Name"]
+            lakeCName = r["Column Name"]
+            dType = r["Data Type"]
+
+            if any(
+                p.Source.EntityName == lakeTName
+                for p in tom.all_partitions()
+                if p.SourceType == TOM.PartitionSourceType.Entity
+            ):
+                table_name = next(
+                    t.Name
+                    for t in tom.model.Tables
+                    for p in t.Partitions
+                    if p.SourceType == TOM.PartitionSourceType.Entity
+                    and p.Source.EntityName == lakeTName
+                )
+
+                if not any(
+                    c.SourceColumn == lakeCName and c.Parent.Name == table_name
+                    for c in tom.all_columns()
+                ):
+                    new_data = {
+                        "TableName": table_name,
+                        "ColumnName": None,
+                        "SourceTableName": lakeTName,
+                        "SourceColumnName": lakeCName,
+                        "Status": "Not in semantic model",
+                    }
+                    df = pd.concat(
+                        [df, pd.DataFrame(new_data, index=[0])], ignore_index=True
+                    )
+
+                    if add_to_model:
+                        dt = _convert_data_type(dType)
+                        tom.add_data_column(
+                            table_name=table_name,
+                            column_name=lakeCName,
+                            source_column=lakeCName,
+                            data_type=dt,
+                        )
+                        print(
+                            f"{icons.green_dot} The '{lakeCName}' column in the '{lakeTName}' lakehouse table was added to the '{dataset_name}' semantic model within the '{workspace_name}' workspace."
+                        )
+
+        return df

sempy_labs/directlake/_dl_helper.py

@@ -0,0 +1,274 @@
+import sempy.fabric as fabric
+import numpy as np
+import pandas as pd
+from typing import Optional, List, Union, Tuple
+from uuid import UUID
+import sempy_labs._icons as icons
+from sempy._utils._log import log
+from .._helper_functions import (
+    retry,
+    _convert_data_type,
+    resolve_dataset_name_and_id,
+    resolve_workspace_name_and_id,
+)
+
+
+@log
+def check_fallback_reason(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> pd.DataFrame:
+    """
+    Shows the reason a table in a Direct Lake semantic model would fallback to DirectQuery.
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        Name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    pandas.DataFrame
+        The tables in the semantic model and their fallback reason.
+    """
+    from sempy_labs.tom import connect_semantic_model
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    (dataset_name, dataset_id) = resolve_dataset_name_and_id(
+        dataset, workspace=workspace_id
+    )
+
+    with connect_semantic_model(
+        dataset=dataset_id, workspace=workspace_id, readonly=True
+    ) as tom:
+        if not tom.is_direct_lake():
+            raise ValueError(
+                f"{icons.red_dot} The '{dataset_name}' semantic model is not in Direct Lake. This function is only applicable to Direct Lake semantic models."
+            )
+
+    df = fabric.evaluate_dax(
+        dataset=dataset_id,
+        workspace=workspace_id,
+        dax_string="""
+            SELECT [TableName] AS [Table Name],[FallbackReason] AS [FallbackReasonID]
+            FROM $SYSTEM.TMSCHEMA_DELTA_TABLE_METADATA_STORAGES
+            """,
+    )
+
+    value_mapping = {
+        0: "No reason for fallback",
+        1: "This table is not framed",
+        2: "This object is a view in the lakehouse",
+        3: "The table does not exist in the lakehouse",
+        4: "Transient error",
+        5: "Using OLS will result in fallback to DQ",
+        6: "Using RLS will result in fallback to DQ",
+    }
+
+    # Create a new column based on the mapping
+    df["Fallback Reason Detail"] = np.vectorize(value_mapping.get)(
+        df["FallbackReasonID"]
+    )
+
+    return df
+
+
+@log
+def generate_direct_lake_semantic_model(
+    dataset: str,
+    lakehouse_tables: Union[str, List[str]],
+    workspace: Optional[str | UUID] = None,
+    lakehouse: Optional[str] = None,
+    lakehouse_workspace: Optional[str | UUID] = None,
+    schema: str = "dbo",
+    overwrite: bool = False,
+    refresh: bool = True,
+):
+    """
+    Dynamically generates a Direct Lake semantic model based on tables in a Fabric lakehouse.
+
+    Parameters
+    ----------
+    dataset : str
+        Name of the semantic model to be created.
+    lakehouse_tables : str | List[str]
+        The table(s) within the Fabric lakehouse to add to the semantic model. All columns from these tables will be added to the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the semantic model will reside.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    lakehouse : str, default=None
+        The lakehouse which stores the delta tables which will feed the Direct Lake semantic model.
+        Defaults to None which resolves to the attached lakehouse.
+    lakehouse_workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID in which the lakehouse resides.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    schema : str, default="dbo"
+        The schema used for the lakehouse.
+    overwrite : bool, default=False
+        If set to True, overwrites the existing semantic model if it already exists.
+    refresh: bool, default=True
+        If True, refreshes the newly created semantic model after it is created.
+    """
+
+    from sempy_labs.lakehouse import get_lakehouse_tables, get_lakehouse_columns
+    from sempy_labs.directlake._generate_shared_expression import (
+        generate_shared_expression,
+    )
+    from sempy_labs.tom import connect_semantic_model
+    from sempy_labs._generate_semantic_model import create_blank_semantic_model
+    from sempy_labs._refresh_semantic_model import refresh_semantic_model
+
+    if isinstance(lakehouse_tables, str):
+        lakehouse_tables = [lakehouse_tables]
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    if lakehouse_workspace is None:
+        lakehouse_workspace = workspace
+
+    dfLT = get_lakehouse_tables(lakehouse=lakehouse, workspace=lakehouse_workspace)
+
+    icons.sll_tags.append("GenerateDLModel")
+
+    # Validate lakehouse tables
+    for t in lakehouse_tables:
+        if t not in dfLT["Table Name"].values:
+            raise ValueError(
+                f"{icons.red_dot} The '{t}' table does not exist as a delta table in the '{lakehouse}' within the '{workspace_name}' workspace."
+            )
+
+    dfLC = get_lakehouse_columns(lakehouse=lakehouse, workspace=lakehouse_workspace)
+    expr = generate_shared_expression(
+        item_name=lakehouse, item_type="Lakehouse", workspace=lakehouse_workspace
+    )
+    dfD = fabric.list_datasets(workspace=workspace_id, mode="rest")
+    dfD_filt = dfD[dfD["Dataset Name"] == dataset]
+
+    if len(dfD_filt) > 0 and not overwrite:
+        raise ValueError(
+            f"{icons.red_dot} The '{dataset}' semantic model within the '{workspace_name}' workspace already exists. Overwrite is set to False so the new semantic model has not been created."
+        )
+
+    create_blank_semantic_model(
+        dataset=dataset, workspace=workspace_id, overwrite=overwrite
+    )
+
+    @retry(
+        sleep_time=1,
+        timeout_error_message=f"{icons.red_dot} Function timed out after 1 minute",
+    )
+    def dyn_connect():
+        with connect_semantic_model(
+            dataset=dataset, readonly=True, workspace=workspace_id
+        ) as tom:
+
+            tom.model
+
+    dyn_connect()
+
+    expression_name = "DatabaseQuery"
+    with connect_semantic_model(
+        dataset=dataset, workspace=workspace_id, readonly=False
+    ) as tom:
+        if not any(e.Name == expression_name for e in tom.model.Expressions):
+            tom.add_expression(name=expression_name, expression=expr)
+
+        for t in lakehouse_tables:
+            tom.add_table(name=t)
+            tom.add_entity_partition(table_name=t, entity_name=t, schema_name=schema)
+            dfLC_filt = dfLC[dfLC["Table Name"] == t]
+            for i, r in dfLC_filt.iterrows():
+                lakeCName = r["Column Name"]
+                dType = r["Data Type"]
+                dt = _convert_data_type(dType)
+                tom.add_data_column(
+                    table_name=t,
+                    column_name=lakeCName,
+                    source_column=lakeCName,
+                    data_type=dt,
+                )
+
+    if refresh:
+        refresh_semantic_model(dataset=dataset, workspace=workspace_id)
+
+
+@log
+def get_direct_lake_source(
+    dataset: str | UUID, workspace: Optional[str | UUID] = None
+) -> Tuple[str, str, UUID, UUID]:
+    """
+    Obtains the source information for a direct lake semantic model (if the source is located in the same workspace as the semantic model).
+
+    Parameters
+    ----------
+    dataset : str | uuid.UUID
+        The name or ID of the semantic model.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+
+    Returns
+    -------
+    Tuple[str, str, UUID, UUID]
+        If the source of the direct lake semantic model is a lakehouse this will return: 'Lakehouse', Lakehouse Name, SQL Endpoint Id, Workspace Id
+        If the source of the direct lake semantic model is a warehouse this will return: 'Warehouse', Warehouse Name, Warehouse Id, Workspace Id
+        If the semantic model is not a Direct Lake semantic model, it will return None, None, None.
+    """
+
+    from sempy_labs._helper_functions import get_direct_lake_sql_endpoint
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    sql_endpoint_id = get_direct_lake_sql_endpoint(dataset=dataset, workspace=workspace)
+    dfI = fabric.list_items(workspace=workspace)
+    dfI_filt = dfI[
+        (dfI["Id"] == sql_endpoint_id)
+        & (dfI["Type"].isin(["SQLEndpoint", "Warehouse"]))
+    ]
+
+    artifact_type, artifact_name, artifact_id = None, None, None
+
+    if not dfI_filt.empty:
+        artifact_name = dfI_filt["Display Name"].iloc[0]
+        artifact_id = dfI[
+            (dfI["Display Name"] == artifact_name)
+            & (dfI["Type"].isin(["Lakehouse", "Warehouse"]))
+        ]["Id"].iloc[0]
+        artifact_type = dfI[
+            (dfI["Display Name"] == artifact_name)
+            & (dfI["Type"].isin(["Lakehouse", "Warehouse"]))
+        ]["Type"].iloc[0]
+
+    return artifact_type, artifact_name, artifact_id, workspace_id
+
+    # payload = {
+    #   "artifacts": [
+    #       {
+    #           "objectId": dataset_id,
+    #           "type": "dataset",
+    #       }
+    #   ]
+    # }
+
+    # response = _base_api(request="metadata/relations/upstream?apiVersion=3", payload=payload, method="post")
+
+    # artifacts = response.json().get("artifacts", [])
+    # sql_id, sql_object_name, sql_workspace_id, artifact_type = None, None, None, None
+
+    # for artifact in artifacts:
+    #    object_type = artifact.get("typeName")
+    #    display_name = artifact.get("displayName")
+    #    if object_type in ["Datawarehouse", "Lakewarehouse"]:
+    #        artifact_type = (
+    #            "Warehouse" if object_type == "Datawarehouse" else "Lakehouse"
+    #        )
+    #        sql_id = artifact.get("objectId")
+    #        sql_workspace_id = artifact.get("workspace", {}).get("objectId")
+    #        sql_object_name = display_name
+    #        break
+
+    # return artifact_type, sql_object_name, sql_id, sql_workspace_id

sempy_labs/directlake/_generate_shared_expression.py

@@ -0,0 +1,94 @@
+from .._helper_functions import (
+    resolve_workspace_name_and_id,
+    _base_api,
+    resolve_lakehouse_name_and_id,
+    resolve_item_name_and_id,
+    _get_fabric_context_setting,
+)
+from typing import Optional
+import sempy_labs._icons as icons
+from uuid import UUID
+from sempy._utils._log import log
+
+
+@log
+def generate_shared_expression(
+    item_name: Optional[str] = None,
+    item_type: str = "Lakehouse",
+    workspace: Optional[str | UUID] = None,
+    use_sql_endpoint: bool = True,
+) -> str:
+    """
+    Dynamically generates the M expression used by a Direct Lake model for a given lakehouse/warehouse.
+
+    Parameters
+    ----------
+    item_name : str, default=None
+        The Fabric lakehouse or warehouse name.
+        Defaults to None which resolves to the lakehouse attached to the notebook.
+    item_type : str, default="Lakehouse"
+        The Fabric item name. Valid options: 'Lakehouse', 'Warehouse'.
+    workspace : str | uuid.UUID, default=None
+        The Fabric workspace name or ID used by the item.
+        Defaults to None which resolves to the workspace of the attached lakehouse
+        or if no lakehouse attached, resolves to the workspace of the notebook.
+    use_sql_endpoint : bool, default=True
+        Whether to use the SQL Endpoint for the lakehouse/warehouse.
+        If False, the expression will be generated without using the SQL Endpoint.
+
+    Returns
+    -------
+    str
+        Shows the expression which can be used to connect a Direct Lake semantic model to its SQL Endpoint.
+    """
+
+    (workspace_name, workspace_id) = resolve_workspace_name_and_id(workspace)
+    item_types = ["Lakehouse", "Warehouse"]
+    item_type = item_type.capitalize()
+    if item_type not in item_types:
+        raise ValueError(
+            f"{icons.red_dot} Invalid item type. Valid options: {item_types}."
+        )
+
+    if item_type == "Lakehouse":
+        (item_name, item_id) = resolve_lakehouse_name_and_id(
+            lakehouse=item_name, workspace=workspace_id
+        )
+    else:
+        (item_name, item_id) = resolve_item_name_and_id(
+            item=item_name, type=item_type, workspace=workspace_id
+        )
+
+    if use_sql_endpoint:
+        item_type_rest = f"{item_type.lower()}s"
+        response = _base_api(
+            request=f"/v1/workspaces/{workspace_id}/{item_type_rest}/{item_id}"
+        )
+
+        prop = response.json().get("properties")
+
+        if item_type == "Lakehouse":
+            sqlprop = prop.get("sqlEndpointProperties")
+            sqlEPCS = sqlprop.get("connectionString")
+            sqlepid = sqlprop.get("id")
+            provStatus = sqlprop.get("provisioningStatus")
+        elif item_type == "Warehouse":
+            sqlEPCS = prop.get("connectionString")
+            sqlepid = item_id
+            provStatus = None
+
+        if provStatus == "InProgress":
+            raise ValueError(
+                f"{icons.red_dot} The SQL Endpoint for the '{item_name}' {item_type.lower()} within the '{workspace_name}' workspace has not yet been provisioned. Please wait until it has been provisioned."
+            )
+
+        start_expr = "let\n\tdatabase = "
+        end_expr = "\nin\n\tdatabase"
+        mid_expr = f'Sql.Database("{sqlEPCS}", "{sqlepid}")'
+        return f"{start_expr}{mid_expr}{end_expr}"
+    else:
+        # Build DL/OL expression
+        env = _get_fabric_context_setting("spark.trident.pbienv").lower()
+        env = "" if env == "prod" else f"{env}-"
+
+        return f"""let\n\tSource = AzureStorage.DataLake("https://{env}onelake.dfs.fabric.microsoft.com/{workspace_id}/{item_id}")\nin\n\tSource"""