SourceLace Docs
FAQOpen the app

Data platforms: Snowflake, BigQuery, Databricks, Redshift, Athena, Fabric and Synapse

How to connect Snowflake, Google BigQuery, Databricks, Amazon Redshift, Amazon Athena, Microsoft Fabric and Azure Synapse for read-only SQL. Each person signs in with their own login, so the platform's own permissions apply to every query and schema lookup. The exceptions are Amazon Athena, whose access is shared, and Amazon Redshift if your admin names one shared database user.

Status: Snowflake, Google BigQuery and Databricks are Available: built on each vendor's published APIs, and validated in your account during onboarding. Amazon Redshift, Amazon Athena, Microsoft Fabric and Azure Synapse are Pilot: new or partial, offered to pilot customers.

At a glance

Connects through Sign-in Network Status First test question
Snowflake Snowflake SQL API Personal sign-in Nothing to open, unless the account has a network policy Available "Which tables can I see in snowflake:prod?"
Google BigQuery BigQuery API Personal sign-in Nothing to open Available "Which datasets and tables can I read in bigquery:analytics?"
Databricks Databricks SQL Statement Execution API and Unity Catalog API Personal sign-in Nothing to open Available "Which tables can I see in databricks:prod?"
Amazon Redshift Amazon Redshift Data API Personal sign-in by default; shared if the admin sets db_user Nothing to open, even for a private cluster Pilot Connecting already checks that Redshift ran as the person's own database user. Then: "Which tables can I see in redshift:analytics?"
Amazon Athena Amazon Athena API, with the AWS Glue Data Catalog Shared account Nothing to open Pilot "Which tables are in athena:lake?"
Microsoft Fabric, Azure Synapse The warehouse's SQL endpoint (TDS, TCP port 1433), with Microsoft Entra sign-in Personal sign-in Fabric: nothing to open. Synapse: allow SourceLace's IP addresses in the workspace firewall Pilot "Which tables can I see in fabric:sales?"

Add each source with the usual steps. The network answers are explained in What your network needs. If the first test question fails, the error message tells you what to fix: look it up under When something goes wrong below.

What people can do

  • search_schema lists tables and views the person can see; describe_object lists a table's columns and types.
  • query (language sql) takes one SELECT or WITH ... SELECT statement in the platform's own SQL. Anything that could change data (INSERT, UPDATE, DELETE, MERGE, CREATE, DROP, ALTER, SELECT ... INTO, CALL and so on), and anything with more than one statement, is refused before it is sent. A few functions that reach outside SQL are refused too (Snowflake SYSTEM$... functions, Databricks reflect).
  • An ordinary result holds 2,000 rows (50 shown at a time); a larger answer is kept whole, up to 250,000 rows, in SourceLace's short-lived encrypted engine, and SourceLace stops reading once it has enough. Results are held for at most 30 minutes and never written to a database (see How long things are kept).
  • Every query has a time limit of about a minute. A query that runs longer is cancelled on the platform, and the person is asked to narrow it.
  • These sources never accept changes. get_record is not used: warehouse tables have no record ids, so people query with a WHERE clause.
  • SourceLace never uses a shared service account for these sources, except Amazon Athena, whose access is shared and labelled so (and Amazon Redshift only if your admin chooses a shared database user).

The redirect URL for all of them is:

https://mcp.sourcelace.ai/connect/callback

Snowflake

What your admin does in Snowflake

Once per Snowflake account. It takes about 10 minutes.

Who: a Snowflake user with the ACCOUNTADMIN role, or a role that has been granted CREATE INTEGRATION ON ACCOUNT (GRANT CREATE INTEGRATION ON ACCOUNT TO ROLE <role>;). For step 3, a role that may change the account's network policy (usually SECURITYADMIN).

Steps:

  1. Create the security integration. In Snowsight, open Projects → Worksheets (in newer Snowsight, + → SQL Worksheet), and run:

    USE ROLE ACCOUNTADMIN;
    
    CREATE SECURITY INTEGRATION SOURCELACE
      TYPE = OAUTH
      ENABLED = TRUE
      OAUTH_CLIENT = CUSTOM
      OAUTH_CLIENT_TYPE = 'PUBLIC'
      OAUTH_REDIRECT_URI = 'https://mcp.sourcelace.ai/connect/callback'
      OAUTH_ENFORCE_PKCE = TRUE
      OAUTH_ISSUE_REFRESH_TOKENS = TRUE
      OAUTH_REFRESH_TOKEN_VALIDITY = 7776000;  -- 90 days, then people sign in again
    

    The redirect URI must be exactly as shown. OAUTH_CLIENT_TYPE = 'PUBLIC' with PKCE means there is no Snowflake secret for anyone to copy or for SourceLace to store. Refresh tokens keep people connected instead of signing in every 10 minutes.

    Snowflake blocks ACCOUNTADMIN, ORGADMIN and SECURITYADMIN from OAuth sign-ins by default. Keep it that way: people should use their everyday roles.

  2. Copy the client id. Run SELECT SYSTEM$SHOW_OAUTH_CLIENT_SECRETS('SOURCELACE'); and copy only OAUTH_CLIENT_ID from the result into SourceLace's OAuth client ID. SourceLace needs neither client secret: leave them where they are.

  3. If the account has a network policy, let SourceLace in. Ask support@sourcelace.com for SourceLace's outbound IP addresses. In Snowsight, open Admin → Security → Network Policies (or Governance & security → Network policies), edit the policy that applies, and add each address under Allowed IP Addresses. Without it, sign-in fails with "... is not allowed to access Snowflake".

  4. Make sure people have a warehouse and a role. Each person needs a role that may read the data and use a warehouse. Either give the source a Warehouse (and grant USAGE on it to people's roles: GRANT USAGE ON WAREHOUSE REPORTING_WH TO ROLE ANALYST;), or give each user a default warehouse (ALTER USER ann SET DEFAULT_WAREHOUSE = REPORTING_WH;). New users often have none, and then every query fails with "No active warehouse selected".

  5. Copy the account URL. In Snowsight, open your account menu (bottom left), then View account details, and copy Account/Server URL, such as corvanta-xy12345.snowflakecomputing.com. This is SourceLace's Account URL.

Check that it worked: DESC SECURITY INTEGRATION SOURCELACE; shows ENABLED = true and your redirect URI. Then, after your SourceLace admin adds the source, one person clicks Connect, signs in with their own Snowflake login, and asks the first test question from At a glance. In Snowflake, Monitoring → Query History, filtered on the query tag sourcelace, shows what ran and as whom.

Snowflake's own guide: Snowflake documentation (search for "Configure Snowflake OAuth for custom clients" and "Network policies").

Add the source (SourceLace admin)

Kind: Snowflake (snowflake).

Option Type Default Example What it is
account Text (required) corvanta-xy12345.snowflakecomputing.com The account URL (step 5). The account identifier alone (corvanta-xy12345, or CORVANTA.XY12345 as Snowsight shows it) and the Snowsight address (app.snowflake.com/corvanta/xy12345) are turned into it for you. Only *.snowflakecomputing.com addresses are used.
client_id Text (required) AbCdEf123... OAUTH_CLIENT_ID from step 2.
warehouse Name each person's default REPORTING_WH The warehouse queries run on. Recommended: people without a default warehouse can run nothing without it (step 4).
role Name each person's default ANALYST If set, people sign in with this role only (Snowflake shows it on the consent screen).
database Name (none) SALES Default database for queries. With it, search_schema looks in that database; without it, across the account.
schema Name (none) PUBLIC Default schema for queries.
totals_at_source on or off on off on: SourceLace may ask Snowflake to work out totals; off: it reads the rows and adds them up itself (same answer, slower on big tables). Use off if a column has its own case-insensitive rule that merges "West" and "WEST". See Totals worked out by your system.

How SourceLace talks to Snowflake: sign-in at https://<account>/oauth/authorize; queries through Snowflake's SQL API with a 60-second statement timeout, MULTI_STATEMENT_COUNT = 1 (Snowflake itself refuses a second statement), and the query tag sourcelace, so your Query History shows exactly what SourceLace ran and for whom.

What runs on your warehouse, and when

SourceLace keeps no connection open to Snowflake and does not check it on a timer. It sends a statement only when someone asks a question, looks up tables or columns, or an admin tests the connection. Between those, SourceLace uses none of your Snowflake compute. To let the assistant find a column by a word, SourceLace also reads the names of your tables and columns after someone searches, at most once a day, in the background and never while someone is waiting for an answer: one statement over the columns of the source's database, run as the person who searched, on the same warehouse (which may start it), counted as a call to Snowflake, once a day per connection when everyone shares one sign-in and once a day per person when each signs in with their own account. Nothing runs when nobody searches. It reads names only. An admin can turn this off with Index field names on the source.

When a statement does run, it uses the warehouse named in the source's warehouse option (or the person's own default warehouse), like any other statement from that person: Snowflake starts the warehouse if it was suspended, and it is billed while it runs and until its auto-suspend time passes. What that costs is set by your Snowflake agreement and by the warehouse's size and auto-suspend setting, which your Snowflake admin controls; SourceLace cannot tell you the amount. A question across several systems can send more than one statement, and a total that Snowflake works out itself sends far fewer rows back (see Totals worked out by your system).

To see exactly what SourceLace ran, ask your Snowflake admin to look at Snowflake's query history for statements with the query tag sourcelace.

When something goes wrong with Snowflake

What you see What it means What to do
"That is the Snowsight address. In Snowsight, open your account menu..." The Account URL is the address of Snowsight in your browser, which Snowflake does not sign people in at. Copy Account/Server URL from View account details (step 5).
"The Snowflake account option must be the account URL, such as corvanta-xy12345.snowflakecomputing.com..." The Account URL is not a Snowflake address. Copy it as in step 5.
"Set the Snowflake client_id option: the OAUTH_CLIENT_ID of the account's SourceLace security integration..." OAuth client ID is empty or not a client id. Copy OAUTH_CLIENT_ID (step 2).
"The Snowflake warehouse option must be a plain name such as ANALYTICS." (or role, database, schema) The option has quotes, dots or spaces. Use a plain name.
"Sign-in was not completed: ... If your default Snowflake role is ACCOUNTADMIN, SECURITYADMIN or ORGADMIN, Snowflake blocks it for OAuth..." Snowflake refused the sign-in because of the role: a blocked admin role, or a role the person does not have. Set the person's default role to an everyday role (ALTER USER ann SET DEFAULT_ROLE = ANALYST;), or set the source's Role to a role people have.
"Snowflake sign-in failed: Snowflake: Incoming request with IP/Token ... is not allowed to access Snowflake. Your Snowflake network policy blocks SourceLace..." A network policy blocks SourceLace (Snowflake error 390422). Add SourceLace's addresses to the policy (step 3).
"Snowflake sign-in failed: Snowflake: invalid_client" or "... redirect_uri ..." The client id is wrong, or the integration's redirect URI is not exactly SourceLace's. Check OAUTH_CLIENT_ID and DESC SECURITY INTEGRATION SOURCELACE; (steps 1 and 2).
"Snowflake has no warehouse to run this on: your user has no default warehouse and the source names none..." Snowflake error 000606: no warehouse to run the query. Set the source's Warehouse and grant USAGE on it, or set the user's default warehouse (step 4).
"Snowflake: SQL compilation error: Object '...' does not exist or not authorized." Snowflake error 002003: the table does not exist, or the person's role cannot see it. Check the name with search_schema; grant the role SELECT (and USAGE on its database and schema) if they should see it.
"Snowflake: Insufficient privileges to operate on warehouse ..." The role may not use that warehouse. GRANT USAGE ON WAREHOUSE ... TO ROLE ...;
"Your Snowflake session has expired." or "Your Snowflake sign-in has expired." The access or refresh token ended (Snowflake errors 390303, 390318). SourceLace refreshes it itself. After OAUTH_REFRESH_TOKEN_VALIDITY (90 days above) people connect again.
"Snowflake is limiting how fast SourceLace can call it. Wait a few seconds and try again." Snowflake throttled the calls (HTTP 429). Try again shortly.
"Snowflake took too long to run this query, so it was stopped. Try a narrower query." The query ran past its time limit. Narrow the query, or use a larger warehouse.
"Snowflake: ..." (another message) Snowflake's own words about the query. The AI usually fixes the query itself.
"Snowflake has no table or view ... that you can read. Try search_schema." The name is wrong, or your Snowflake role has no privilege on it. Use a name from search_schema, and ask your Snowflake admin about your role.
"Snowflake returned an unexpected statement handle." or "SourceLace refused to call an unexpected Snowflake address." Snowflake's answer was not in the form SourceLace expects. Try again shortly. If it repeats, contact support.

Google BigQuery

Sign-in asks only for https://www.googleapis.com/auth/bigquery.readonly, plus openid and email (to show who is connected). SourceLace provides the Google app people sign in with: nothing is registered in Google Cloud.

What your admin does in Google Cloud

Once per project. It takes about 10 minutes.

Who: a Google Cloud user who may grant roles on the project (Project IAM Admin or Owner), and on the datasets (BigQuery Admin, or the dataset's owner). For step 4, a Google Workspace super admin.

  1. Choose the project that runs queries. Queries are billed to it, so billing must be linked and the BigQuery API on (it is on for new projects; check APIs & Services → Enabled APIs & services → BigQuery API). Copy its project ID from the project picker's ID column, such as corvanta-data: not its name, and not its number. This is SourceLace's Project ID. If the data lives in another project, copy that one's ID too, for Data project.
  2. Let people run queries there. In the Google Cloud console, IAM & Admin → IAM → Grant access: add the people (or, better, a Google group), and give them BigQuery Job User (roles/bigquery.jobUser). Save.
  3. Let people read the data. In BigQuery → Explorer, open each dataset they should read, then Sharing → Permissions → Add principal, and give the same people or group BigQuery Data Viewer (roles/bigquery.dataViewer). (Or grant it on the whole data project in IAM.) Note the dataset's Data location under Details, such as EU: if queries later say "not found in location", that goes in Location.
  4. Only if your Google Workspace restricts third-party apps: in the Google Admin console → Security → Access and data control → API controls → Manage third-party app access, click Add app → OAuth App Name or Client ID, enter SourceLace's Google client ID (ask support@sourcelace.com), and choose Trusted (or Limited with BigQuery allowed). Without it, sign-in stops with "admin_policy_enforced".

Check that it worked: one person runs a query on a dataset in the BigQuery console with their own login. Then, after your SourceLace admin adds the source, they click Connect, tick the BigQuery box on Google's consent screen, and ask the first test question from At a glance. In BigQuery, Job history shows the query with the label source=sourcelace.

Google's own guides: BigQuery documentation (search for "BigQuery IAM roles" and "Control access to datasets") and Google Workspace Admin Help (search for "Control which third-party apps access Google Workspace data").

Add the source (SourceLace admin)

Kind: Google BigQuery (bigquery).

Option Type Default Example What it is
project Text (required) corvanta-data The Google Cloud project ID that runs, and pays for, queries (step 1).
data_project Text the project option corvanta-warehouse The project that holds the datasets, if it is not the one that pays for queries. Its tables are then named project.dataset.table.
location Text (found by BigQuery) EU, europe-west2 Leave empty: BigQuery finds it from the tables. Set it only if queries say "not found in location": the dataset's Data location (step 3).
max_bytes_billed Number of bytes 10000000000 (10 GB) 50000000000 The most one query may scan.
totals_at_source on or off on off on: SourceLace may ask BigQuery to work out totals; off: it reads the rows and adds them up itself (same answer, slower on big tables). Use off if a column has its own case-insensitive rule that merges "West" and "WEST". See Totals worked out by your system.

Cost protection: every query is first sent as a dry run, which is free. If it would scan more than max_bytes_billed, it is refused with the size it would have scanned, before anything is billed. The real query is then sent with maximumBytesBilled set, so BigQuery enforces the cap too, and with the label source=sourcelace. Tables are named dataset.table (or `project.dataset.table`).

What runs on your project, and when

To let the assistant find a table or column by a word, SourceLace reads the names of your datasets, tables and columns after someone searches, at most once a day per connection or per person (as for Snowflake), in the background and never while someone is waiting for an answer. It uses BigQuery's metadata calls (one call for each table, as the person who searched), which are not queries and bill no bytes. It reads names only. An admin can turn this off with Index field names on the source.

When something goes wrong with BigQuery

What you see What it means What to do
"Set the BigQuery project option to a Google Cloud project id, such as corvanta-data." Project ID is empty. Copy the project ID (step 1).
"The BigQuery project option looks like the project number..." or "... looks like the project name..." The project's number or name was entered. Copy the ID column from the project picker.
"The BigQuery location option must be a location such as US, EU or europe-west2." Location is not a BigQuery location. Leave it empty, or copy the dataset's Data location.
"Google did not grant read access to BigQuery. Connect again and tick the BigQuery box on Google's consent screen." The person unticked BigQuery on Google's consent screen. Connect again and tick the box.
"Sign-in was not completed: ... (error admin_policy_enforced)." Your Google Workspace blocks apps it does not trust. A Workspace super admin trusts SourceLace's app (step 4).
"Sign-in was not completed: ... (error access_denied)." The person clicked Cancel, or your Workspace refused the app. Connect again and allow; if it repeats, see step 4.
"Google sign-in failed: ..." or "Your Google session has expired." Google refused or ended the sign-in. Connect again.
"BigQuery: Access Denied: Project ...: User does not have bigquery.jobs.create permission..." The person lacks BigQuery Job User on the project. Grant it (step 2).
"BigQuery: Access Denied: Table ...: User does not have permission to query table..." The person lacks BigQuery Data Viewer on the dataset. Grant it (step 3).
"BigQuery: BigQuery API has not been used in project ... before or it is disabled..." The BigQuery API is off in the project (accessNotConfigured). Turn on BigQuery API in APIs & Services (step 1).
"BigQuery: ... billing ..." (billingNotEnabled) The project has no billing account linked. Link one in Billing, or use a project that has one.
"BigQuery looked for dataset ... in location US, but it is not there..." The dataset lives in another location than the one used. Set Location to the dataset's Data location, or leave it empty (step 3).
"BigQuery: Not found: Dataset ..." or "... Table ..." The name is wrong, or the dataset is in another project. Check the name with search_schema; if the data is in another project, set Data project.
"This query would scan ..., more than this source's limit of .... Select fewer columns, filter on the partition column, or ask an admin to raise max_bytes_billed." The free dry run showed the query would scan more than the source allows. Narrow the query, or raise Most bytes one query may scan.
"BigQuery: Query exceeded limit for bytes billed: ..." (bytesBilledLimitExceeded) The query scanned more than the cap after all. As above.
"BigQuery: Quota exceeded..." or "... rateLimitExceeded" A Google Cloud quota on the project was reached. Try again later, or raise the quota in IAM & Admin → Quotas.
"BigQuery took too long to run this query..." The query ran past the time limit. Narrow it.
"BigQuery: ..." (another message) Google's own words about the query, such as an unknown column. The AI usually fixes the query itself.
"The BigQuery max_bytes_billed option must be a number of bytes, such as 10000000000 for 10 GB." The cost limit in the source holds something other than a plain number. An admin enters the limit in bytes, digits only.
"BigQuery returned an unexpected job id." or "SourceLace refused to call an unexpected BigQuery address." BigQuery's answer was not in the form SourceLace expects. Try again shortly. If it repeats, contact support.

Databricks

Works on AWS (*.cloud.databricks.com), Azure (*.azuredatabricks.net) and Google Cloud (*.gcp.databricks.com).

What your admin does in Databricks

Once per Databricks account. It takes about 10 minutes.

Who: a Databricks account admin (on Azure, the first account admin is an Entra Global Administrator), for the app connection. A workspace admin, or the warehouse's owner, for the warehouse; the catalog's owner or a metastore admin for the data grants.

Before you start, check: the workspace uses Unity Catalog (in the workspace, Catalog shows your catalogs; if it only shows hive_metastore, an account admin assigns a metastore to the workspace in the account console, Catalog). SourceLace reads tables through Unity Catalog.

  1. Open the account console, not the workspace: accounts.cloud.databricks.com (AWS), accounts.azuredatabricks.net (Azure) or accounts.gcp.databricks.com (Google Cloud).
  2. Add the app connection. Settings → App connections → Add connection. Name: SourceLace. Redirect URLs: https://mcp.sourcelace.ai/connect/callback, exactly.
  3. Access scopes: All APIs. SourceLace itself only calls the SQL statement and Unity Catalog read endpoints; each person's own grants still decide what they can see. Sign-in asks for all-apis and offline_access, so refresh tokens must be allowed.
  4. Untick "Generate a client secret". SourceLace signs in as a public client with PKCE, so there is no secret to store. Left ticked, every sign-in fails with "Client authentication failed".
  5. Token lifetimes: leave them as they are, or set the refresh token to 90 days (how long people stay connected). Click Add, then copy the Client ID into SourceLace's OAuth client ID.
  6. Pick the SQL warehouse. In the workspace, SQL Warehouses → (the warehouse) → Overview: copy the warehouse ID (16 characters, such as 1234567890abcdef) into SourceLace's SQL warehouse ID. Then Permissions: give the people (or a group) Can use. A stopped serverless warehouse starts on the first query, which can take a few seconds.
  7. Let people read the data. In Catalog, open the catalog, then Permissions → Grant, and give the group USE CATALOG, USE SCHEMA and SELECT (or run GRANT USE CATALOG, USE SCHEMA, SELECT ON CATALOG main TO \analysts`;`).
  8. Copy the workspace address from your browser's address bar while in the workspace, such as corvanta.cloud.databricks.com or adb-1234567890123456.7.azuredatabricks.net. (Anything after the host, such as ?o=..., is removed for you.)

Check that it worked: after your SourceLace admin adds the source, one person clicks Connect, signs in with their own Databricks login, and asks the first test question from At a glance. In the workspace, Query History on the warehouse shows the query and who ran it.

Databricks' own guide: Databricks documentation (search for "Enable custom OAuth applications", "SQL warehouse permissions" and "Unity Catalog privileges").

Add the source (SourceLace admin)

Kind: Databricks (databricks).

Option Type Default Example What it is
host Text (required) corvanta.cloud.databricks.com The workspace address (step 8), not the account console. Only Databricks addresses are accepted.
client_id Text (required) 1a2b3c4d-... The app connection's Client ID (step 5).
warehouse_id Text (required) 1234567890abcdef The SQL warehouse ID (step 6). The HTTP path from Connection details (/sql/1.0/warehouses/...) works too.
catalog Name (none) main Default catalog. With it, search_schema looks only in that catalog.
schema Name (none) sales Default schema.
totals_at_source on or off on off on: SourceLace may ask Databricks to work out totals; off: it reads the rows and adds them up itself (same answer, slower on big tables). Use off if a column has its own case-insensitive rule that merges "West" and "WEST". See Totals worked out by your system.

Tables are named catalog.schema.table. A query still running after 50 seconds is cancelled rather than left running.

What runs on your warehouse, and when

SourceLace keeps no connection open to Databricks and does not check it on a timer. It sends a statement only when someone asks a question, looks up tables or columns, or an admin tests the connection. Between those, SourceLace uses none of your Databricks compute.

To let the assistant find a table or column by a word, SourceLace also reads the names of your tables and columns after someone searches, at most once a day per connection or per person (as for Snowflake), in the background and never while someone is waiting for an answer, through Databricks' catalog (Unity Catalog) calls, which do not start a SQL warehouse, one call for each table. It reads names only. An admin can turn this off with Index field names on the source.

When a statement does run, it runs on the SQL warehouse named in the source's warehouse_id option, as the person who asked. If that warehouse was stopped, Databricks starts it according to the warehouse's own settings, and bills it while it runs and until it stops again. What that costs is set by your Databricks agreement and by the warehouse's type, size and auto-stop setting, which your Databricks admin controls; SourceLace cannot tell you the amount. A statement still running after 50 seconds is cancelled, never left running in the background. A question across several systems can send more than one statement.

When something goes wrong with Databricks

What you see What it means What to do
"That is the Databricks account console. Use the workspace address..." Workspace host is the account console's address. Copy the workspace's address (step 8).
"The Databricks host option must be a host name such as corvanta.cloud.databricks.com." Workspace host is not a Databricks address. Copy it from the workspace (step 8).
"Set the Databricks client_id option..." or "Set the Databricks warehouse_id option..." The option is empty. Fill it in (steps 5 and 6).
"The Databricks warehouse_id option must be the warehouse's ID only..." The warehouse's name or connection address was entered. Copy the ID from the warehouse's Overview (step 6).
"The Databricks catalog option must be a plain name such as main." (or schema) The option has quotes or dots. Use a plain name.
"Databricks refused SourceLace as a public client: the app connection was probably created with a client secret..." The app connection has a client secret. Add it again with Generate a client secret unticked (step 4), and enter the new client ID.
"Sign-in was not completed: ... (error invalid_scope). SourceLace's app connection does not allow the scopes..." The app connection's scopes are narrower than All APIs, or refresh tokens are off. Set Access scopes to All APIs (step 3).
"Sign-in was not completed: ... redirect_uri ..." The app connection's redirect URL is not exactly SourceLace's. Fix it in App connections (step 2).
"This Databricks workspace has no Unity Catalog metastore..." The workspace only has hive_metastore (error METASTORE_DOES_NOT_EXIST). An account admin assigns a metastore (see Before you start).
"Databricks: PERMISSION_DENIED: ..." The person lacks Can use on the warehouse, or a Unity Catalog grant. Give Can use (step 6) and USE CATALOG, USE SCHEMA, SELECT (step 7).
"Databricks: TABLE_OR_VIEW_NOT_FOUND: ..." The table does not exist, or the person cannot see it. Check the name with search_schema (catalog.schema.table); grant SELECT if they should see it.
"Your Databricks session has expired." or "Your Databricks sign-in has expired." The token ended. SourceLace refreshes it itself; after the refresh token's lifetime, people connect again.
"Databricks is limiting how fast SourceLace can call it. Wait a few seconds and try again." Databricks throttled the calls (HTTP 429). Try again shortly.
"Databricks took too long to run this query, so it was stopped. Try a narrower query, or check that the SQL warehouse is running." The query ran past 50 seconds, or the warehouse was starting. Narrow the query, or start the warehouse.
"Databricks: ..." (another message) Databricks' own words about the query. The AI usually fixes the query itself.
"SourceLace refused to call an unexpected Databricks address." A link in Databricks' answer led outside your workspace; SourceLace never follows those. Try again. If it repeats, contact support.

Amazon Redshift

Kind: Amazon Redshift (redshift). Works with provisioned clusters and Redshift Serverless.

Each person runs as their own Redshift database user, so Redshift's own grants decide what they can read. Redshift has no sign-in page SourceLace could send people to, but it can hand out short-lived database credentials for a named user to an AWS role you trust. SourceLace asks for credentials as the database user named exactly like the person's SourceLace email (lower case, such as jane.doe@corvanta.com), which SourceLace knows because the person signed in to SourceLace. People never type a database password, and SourceLace stores none.

SourceLace reaches Redshift through the Amazon Redshift Data API, over HTTPS. It needs no network path to your cluster, so private clusters work without opening them to the internet, and you allow-list nothing.

What your admin does in AWS (Amazon Redshift)

Once per cluster or workgroup, then one database user per person. About 20 minutes the first time.

Who: a Redshift admin (a superuser, or a user who may CREATE USER and grant) for the database users, and an AWS admin who may create IAM roles and policies (IAM full access, or a permission boundary that allows it) for the access.

Before you start, write down:

  • the region of the cluster or workgroup: the code at the top right of the Redshift console, such as us-east-1 (Ireland is eu-west-1). A wrong region is the most common first mistake: Redshift then says the cluster does not exist.
  • for a provisioned cluster, its cluster identifier (Clusters, the name in the list, such as corvanta-analytics); for Serverless, the workgroup name (Serverless dashboard → Workgroup configuration).
  • the database name (often dev).
  • your organization's external ID: SourceLace sets it, and it looks like sourcelace-corvanta. You find it on Connections, on any AWS source after saving (aws_external_id in admin_sources). SourceLace's AWS account, which the trust policy names, comes from support@sourcelace.com.

Steps:

  1. Create a database user per person (Redshift admin). In the Redshift console, Query editor v2, connected as an admin, for each person:

    CREATE USER "jane.doe@corvanta.com" PASSWORD DISABLE;
    -- Grant what this person may read, ideally through a role:
    CREATE ROLE sales_readers;
    GRANT USAGE ON SCHEMA sales TO ROLE sales_readers;
    GRANT SELECT ON ALL TABLES IN SCHEMA sales TO ROLE sales_readers;
    GRANT ROLE sales_readers TO "jane.doe@corvanta.com";
    

    The name is the person's SourceLace email in lower case, in double quotes, at most 64 characters. PASSWORD DISABLE means the user can only get in with short-lived credentials from AWS. Never make these users superusers.

  2. Create the role's permissions (AWS admin). IAM → Policies → Create policy → JSON, and paste this for a provisioned cluster (change the region, account 123456789012, corvanta-analytics, dev and corvanta.com to yours). Name it, for example, sourcelace-redshift.

    {
      "Version": "2012-10-17",
      "Statement": [
        {"Effect": "Allow",
         "Action": ["redshift-data:ExecuteStatement", "redshift-data:ListTables", "redshift-data:DescribeTable"],
         "Resource": "arn:aws:redshift:us-east-1:123456789012:cluster:corvanta-analytics"},
        {"Effect": "Allow",
         "Action": ["redshift-data:DescribeStatement", "redshift-data:GetStatementResult", "redshift-data:CancelStatement"],
         "Resource": "*",
         "Condition": {"StringEquals": {"redshift-data:statement-owner-iam-userid": "${aws:userid}"}}},
        {"Effect": "Allow", "Action": "redshift:GetClusterCredentials",
         "Resource": ["arn:aws:redshift:us-east-1:123456789012:dbuser:corvanta-analytics/*@corvanta.com",
                      "arn:aws:redshift:us-east-1:123456789012:dbname:corvanta-analytics/dev"]}
      ]
    }
    

    The dbuser line only allows users whose name ends in @corvanta.com, so the role can never get credentials for your admin user.

    For Redshift Serverless, use the workgroup's ARN (arn:aws:redshift-serverless:us-east-1:123456789012:workgroup/<workgroup id>, shown on the workgroup's page) in the first statement, and instead of GetClusterCredentials allow redshift-serverless:GetCredentials on that same workgroup ARN.

  3. Create the role (AWS admin). IAM → Roles → Create role → Custom trust policy, and paste (with SourceLace's account from support and your external ID):

    {
      "Version": "2012-10-17",
      "Statement": [{
        "Effect": "Allow",
        "Principal": {"AWS": "arn:aws:iam::<SourceLace's account, from support>:user/sourcelace"},
        "Action": ["sts:AssumeRole", "sts:TagSession"],
        "Condition": {"StringEquals": {"sts:ExternalId": "sourcelace-corvanta"}}
      }]
    }
    

    sts:TagSession is required for Redshift Serverless: SourceLace sends the person's database user as the session tag RedshiftDbUser, which Serverless uses to pick the database user. Then attach the policy from step 2, name the role (such as sourcelace-redshift), and copy its ARN from the role's summary (arn:aws:iam::123456789012:role/sourcelace-redshift) into SourceLace's Role to assume. SourceLace names each role session after the person, so your CloudTrail shows who asked.

    Instead of a role, a provisioned cluster can use your own access keys (an IAM user with the policy from step 2: IAM → Users → Security credentials → Create access key). Redshift Serverless always needs a role.

Check that it worked: after your SourceLace admin adds the source, one person whose database user exists clicks Connect. SourceLace runs SELECT current_user as them and connects only if Redshift really ran as their own database user. In Redshift, Query editor v2 or SYS_QUERY_HISTORY shows the query under their user name, and CloudTrail shows the role session named after them.

Amazon's own guide: Amazon Redshift documentation (search for "Using the Amazon Redshift Data API" and "Authorizing access to the Data API"), and IAM documentation for roles and trust policies.

Add the source (SourceLace admin)

Option Type Default Example What it is
region Text (required) us-east-1 The cluster's or workgroup's AWS region, as the Redshift console shows it at the top right.
cluster_identifier Text (none) corvanta-analytics A provisioned cluster. Set this or workgroup.
workgroup Text (none) corvanta-analytics A Redshift Serverless workgroup's name. Set this or cluster_identifier.
database Name (required) dev The database to read.
access_key_id, secret_access_key, role_arn (none) Your AWS access (step 3). The secret is stored encrypted and shown only as (saved).
db_user Text (none) reporting Shared access. If set, everyone who uses the source runs as this one database user instead of their own. Leave it empty unless you cannot create a user per person; list_sources then shows it as "shared database user ...". If you set db_user, allow its dbuser ARN in the role's policy too.
max_plan_cost Number (none) 5000000 Refuse queries whose cost, as Redshift's EXPLAIN estimates it, is higher.
totals_at_source on or off on off on: SourceLace may ask Redshift to work out totals; off: it reads the rows and adds them up itself (same answer, slower on big tables). See Totals worked out by your system.

Tables are named schema.table (public when the schema is left out).

Cost and load: before each query SourceLace asks Redshift for the plan (EXPLAIN, which runs nothing). It refuses very large nested-loop joins (every row compared with every row, over a million rows), and plans above max_plan_cost if you set one. Redshift's cost figures are relative, not money, so there is no default: look at EXPLAIN for your usual queries before choosing a number. Every query has the organization's time limit and is cancelled on Redshift (CancelStatement) when it runs out; on Serverless, that limit is what bounds a query's RPU cost. You can add your own guard rails in Redshift too: usage limits and query limits on a Serverless workgroup, or query monitoring rules on a provisioned cluster.

When something goes wrong with Amazon Redshift

What you see What it means What to do
"... needs a valid region, ... in its options." An option is empty or malformed. Fill in the option it names (see Before you start).
"... is a Redshift Serverless source, so it needs a role for SourceLace to assume (role_arn) ..." Serverless was set up with access keys. Create the role (step 3) and enter its ARN in Role to assume.
"... has no AWS access of its own. Enter your organization's own access keys ... or a role ..." Neither keys nor a role is set. Enter the role's ARN (step 3).
"Amazon Redshift has no cluster ... in us-east-1 ..." (or "no workgroup") AWS has no such cluster or workgroup in that region. Usually the region is wrong. Set Region to the code at the top right of the Redshift console, and check the cluster identifier or workgroup name.
"AWS refused to let SourceLace assume the source's role (AccessDenied: ...). Check that role_arn is exactly the role's ARN, and that its trust policy names SourceLace's AWS account ..." The role does not exist, or its trust policy does not trust SourceLace, or the external ID condition is wrong. Copy the ARN from the role's summary; fix the trust policy (step 3) with SourceLace's account and your external ID exactly.
"... (AccessDenied: ... sts:TagSession ...). The role's trust policy must also allow sts:TagSession ..." Serverless needs the session tag, and the trust policy only allows sts:AssumeRole. Add sts:TagSession to the trust policy's actions (step 3).
"... AWS STS is turned off in ...: turn it on in IAM, Account settings ..." AWS's sign-in service for roles is turned off in that region in your account. IAM → Account settings → Security Token Service (STS): turn the region on.
"... AWS did not accept the source's own access keys ..." The access key was mistyped, deleted or deactivated. Create a new access key (step 3) and enter both parts again, or remove the keys and use the role alone.
"AWS refused ... access to Amazon Redshift cluster ... as the database user ..." The role's policy lacks a Data API action, or may not get credentials for that database user. Check the policy against step 2, including the dbuser line (your email domain) and dbname.
"Amazon Redshift did not let SourceLace in as the database user ...: ..." The person's database user does not exist, or the role may not get credentials for it. Create the user (step 1) with the person's email in lower case, and check the policy's dbuser line.
"Amazon Redshift ran as ..., not as the database user ..." Redshift ran the check as someone else (for example a shared db_user was mistyped). Check db_user, or empty it so each person runs as themselves.
"Amazon Redshift could not open the database ... The cluster may be paused, or that database user may not exist." The cluster or workgroup is paused, or the database or user is missing. Resume the cluster, check Database, and create the user (step 1).
"Your SourceLace email ... cannot be a Redshift database user name ..." The email has characters Redshift does not allow, or is over 64 characters. Set a shared db_user for this source.
"Amazon Redshift is running too many queries for this source right now ..." The Data API's limit on statements running at once was reached. Wait a moment and try again.
"Amazon Redshift would compare every row with every row to run this query ..." The query joins tables without a join condition. Join the tables on a column, or filter them first.
"Amazon Redshift estimates this query's cost at ..., above this source's limit ..." The plan is above max_plan_cost. Narrow the query, or raise max_plan_cost.
"Amazon Redshift took too long to run this query, so it was stopped." The query ran past the organization's time limit. Narrow the query.
"Amazon Redshift could not run the query: ..." Redshift's own words about the query, such as an unknown column. The AI usually fixes the query itself.
"Amazon Redshift stopped the query before it finished. Try again." Redshift cancelled or aborted the statement. Try again, with a narrower query if it repeats.
"Amazon Redshift returned an unexpected statement id." or "SourceLace could not tell Amazon Redshift who is asking. Try again." Redshift's answer was not in the form SourceLace expects, or the person's identity did not reach it. Try again. If it repeats, contact support.

Amazon Athena

Kind: Amazon Athena (athena). Read-only SQL over your data lake (tables in the AWS Glue Data Catalog, or another Athena catalog).

Athena access is shared, per source. Athena has no per-person sign-in SourceLace could use: the only per-user route, IAM Identity Center trusted identity propagation, needs Identity Center workgroups, Lake Formation and S3 Access Grants set up for Identity Center users, and an identity token from your identity provider for each person, and AWS lists federated access to the Athena API as unsupported for those workgroups. So each Athena source reads with one role (or key pair) of your organization's own, the same for everyone who uses it, as with Amazon S3. The IAM policy behind it (and Lake Formation, if you use it) decides what the source can see. To give groups different data, add one Athena source per role and narrow who can use each with access by group, or give each group read rules for the rows it may see. Each role session is named after the person, so your CloudTrail shows who asked.

What your admin does in AWS (Amazon Athena)

Once per source. About 15 minutes.

Who: an AWS admin who may create Athena workgroups and IAM roles and policies. With Lake Formation, also a data lake administrator.

Before you start, write down: the region your tables are in (top right of the Athena console, such as us-east-1); the Glue database and the S3 bucket that hold the tables; your organization's external ID (on Connections, on any AWS source after saving, such as sourcelace-corvanta); and SourceLace's AWS account for the trust policy, from support@sourcelace.com.

Steps:

  1. Create a workgroup for SourceLace. In the Athena console, Workgroups → Create workgroup, named for example sourcelace:

    • Query result configuration: choose Athena managed if you can. Athena then keeps results in its own storage and deletes them after 24 hours, with no bucket of yours. Otherwise, choose an S3 location and add an S3 lifecycle rule on that prefix that expires objects after 1 day (the shortest S3 lifecycle allows). Either way, query results are written in your own AWS account, not SourceLace's: SourceLace only reads them back through the Athena API. A workgroup with neither is refused, because every query would fail.
    • Per query data usage control: set a limit, such as 10 GB. SourceLace refuses to run queries in a workgroup without one. Athena itself cancels any query that scans more.
    • Turn on Override client-side settings, so the workgroup's settings always apply.
    • Leave IAM Identity Center off: SourceLace cannot use such a workgroup.
  2. Create the role's permissions. IAM → Policies → Create policy → JSON, and paste (change the region, account, workgroup, sales database and corvanta-lake bucket to yours):

    {
      "Version": "2012-10-17",
      "Statement": [
        {"Effect": "Allow",
         "Action": ["athena:StartQueryExecution", "athena:GetQueryExecution", "athena:GetQueryResults",
                    "athena:StopQueryExecution", "athena:GetWorkGroup"],
         "Resource": "arn:aws:athena:us-east-1:123456789012:workgroup/sourcelace"},
        {"Effect": "Allow",
         "Action": ["athena:ListDatabases", "athena:ListTableMetadata", "athena:GetTableMetadata"],
         "Resource": "arn:aws:athena:us-east-1:123456789012:datacatalog/AwsDataCatalog"},
        {"Effect": "Allow",
         "Action": ["glue:GetDatabase", "glue:GetDatabases", "glue:GetTable", "glue:GetTables",
                    "glue:GetPartition", "glue:GetPartitions"],
         "Resource": ["arn:aws:glue:us-east-1:123456789012:catalog",
                      "arn:aws:glue:us-east-1:123456789012:database/sales",
                      "arn:aws:glue:us-east-1:123456789012:table/sales/*"]},
        {"Effect": "Allow", "Action": ["s3:GetObject", "s3:ListBucket", "s3:GetBucketLocation"],
         "Resource": ["arn:aws:s3:::corvanta-lake", "arn:aws:s3:::corvanta-lake/sales/*"]}
      ]
    }
    

    With an S3 result location instead of Athena managed results, also allow s3:GetBucketLocation, s3:ListBucket, s3:GetObject, s3:PutObject and s3:AbortMultipartUpload on that result prefix, and kms:GenerateDataKey and kms:Decrypt on its key if the bucket is encrypted with KMS. With Lake Formation, grant the role SELECT (and DESCRIBE) on the tables in Lake Formation → Data permissions instead of relying on S3 permissions alone.

  3. Create the role. IAM → Roles → Create role → Custom trust policy, and paste the trust policy from Amazon Redshift, step 3 (sts:TagSession is optional for Athena). Attach the policy from step 2, name the role (such as sourcelace-athena) and copy its ARN into SourceLace's Role to assume. Or use an IAM user's access keys with that policy.

Check that it worked: after your SourceLace admin adds the source, click Connect: SourceLace reads the workgroup and refuses it if it has no data limit or nowhere to put results. Then ask the first test question from At a glance. In the Athena console, Recent queries in the sourcelace workgroup shows the query.

Amazon's own guide: Amazon Athena documentation (search for "Using workgroups", "Managed query results" and "Identity and access management in Athena").

Add the source (SourceLace admin)

Option Type Default Example What it is
region Text (required) us-east-1 Athena's AWS region, as the Athena console shows it at the top right.
workgroup Text (required) sourcelace The workgroup from step 1.
catalog Text AwsDataCatalog AwsDataCatalog The data catalog.
database Name (none) sales Default database for queries. With it, search_schema looks only there; without it, in the catalog's first 25 databases.
access_key_id, secret_access_key, role_arn (none) Your AWS access (step 3).
max_bytes_scanned Number of bytes 10000000000 (10 GB) 50000000000 The most one query may scan, at least 10 MB.

Tables are named database.table. describe_object marks partition columns: filtering on them makes Athena scan less. Queries that reach outside the data lake through Lambda (federated lambda: catalogs, USING EXTERNAL FUNCTION) are refused, as are Redshift functions that end sessions or change settings (pg_terminate_backend, set_config and similar).

Cost protection: Athena bills by data scanned, so SourceLace checks three times. Before the query, it asks Athena for its own estimate (EXPLAIN (TYPE IO), which Athena does not charge for) and refuses the query if the estimate is over the lower of max_bytes_scanned and the workgroup's limit; Athena often has no estimate for tables without statistics, and then this step is skipped. While the query runs, SourceLace watches the bytes scanned and stops the query (StopQueryExecution) once they pass the limit. And the workgroup's own per-query limit stops it in Athena regardless. Every query also has the organization's time limit, after which it is stopped.

When something goes wrong with Amazon Athena

What you see What it means What to do
"Amazon Athena has no workgroup ... in us-east-1 ..." The workgroup name or the region is wrong. Check Workgroup against the Athena console, and Region against the code at its top right.
"The Athena workgroup ... has no per-query data usage limit ..." The workgroup has no Per query data usage control. Set one, such as 10 GB (step 1).
"The Athena workgroup ... has nowhere to put query results ..." The workgroup has neither Athena managed results nor an S3 result location. Edit the workgroup's Query result configuration (step 1).
"The Athena workgroup ... is turned off." The workgroup is disabled. Workgroups, select it, Actions → Enable.
"The Athena workgroup ... uses IAM Identity Center ..." SourceLace cannot use Identity Center workgroups. Create a workgroup without it (step 1).
"Amazon Athena could not save the results (...)..." The role may not write to the workgroup's S3 result location, or its KMS key. Add the S3 and KMS permissions from step 2, or switch the workgroup to Athena managed results.
"AWS refused to let SourceLace assume the source's role (...)..." As for Redshift: the role, its trust policy or the external ID. See the Redshift table for each AWS code.
"AWS refused ... access to Amazon Athena ..." The role's policy (or Lake Formation) lacks a permission. Check the policy against step 2, and Lake Formation grants.
"Amazon Athena could not read the data catalog ..." The role may not read the Glue catalog, or the catalog name is wrong. Check the glue: lines in step 2, and Catalog.
"Athena estimates this query would read ..." or "This query had already scanned ..., so SourceLace stopped it." The query would scan more than the limit. Select fewer columns and filter on partition columns, or raise max_bytes_scanned (and the workgroup's limit).
"Amazon Athena took too long to run this query, so it was stopped." The query ran past the organization's time limit. Narrow the query.
"Amazon Athena could not run the query: ... Fix the query ..." Athena's own words about the query, such as an unknown column. The AI usually fixes the query itself.
"Amazon Athena stopped this query (...)." Athena cancelled or failed the query; the reason is in the brackets. Fix what the reason names, or try again with a narrower query.
"Amazon Athena returned an unexpected query id." Athena's answer was not in the form SourceLace expects. Try again shortly. If it repeats, contact support.

Microsoft Fabric and Azure Synapse

Status: Pilot. New or partial, offered to pilot customers; not yet used on a customer's live account.

One kind of source, fabric, reads with T-SQL from:

  • Microsoft Fabric warehouses and lakehouse SQL analytics endpoints,
  • Azure Synapse dedicated SQL pools (including a standalone dedicated SQL pool, formerly SQL DW),
  • Azure Synapse serverless SQL pools.

Not covered: Microsoft's sovereign clouds (Azure Government and Azure China), which use different sign-in and SQL addresses, and Fabric SQL databases (addresses ending in database.fabric.microsoft.com), which are operational databases rather than warehouses. SourceLace refuses those addresses as host.

Each person signs in with their own Microsoft work account. SourceLace passes that person's Microsoft Entra sign-in to Fabric or Synapse, which then applies that person's own workspace roles and SQL permissions. There is no shared login and no password.

What your admin does in Microsoft Entra, Fabric and Synapse

Once per tenant for consent, then per warehouse or database for access. About 15 minutes.

Who: a Microsoft Entra admin who may grant tenant-wide consent (Global Administrator, Cloud Application Administrator or Application Administrator), once. For data access: a Fabric workspace Admin or Member, or for Synapse a Synapse Administrator (and an Azure Owner or Contributor on the workspace for its firewall).

Before you start, write down:

  • the SQL connection string's server. Fabric: open the warehouse or lakehouse's SQL analytics endpoint, Settings → SQL endpoint (or ...→ Copy SQL connection string), such as abc123xyz.datawarehouse.fabric.microsoft.com. Synapse: the workspace's Overview in the Azure portal, Dedicated SQL endpoint (corvanta.sql.azuresynapse.net) or Serverless SQL endpoint (corvanta-ondemand.sql.azuresynapse.net).
  • the database: the warehouse, lakehouse, dedicated SQL pool or serverless database name.
  • your tenant: your domain (such as corvanta.com) or the Tenant ID on the Entra admin center's Overview. Always set it if anyone signs in as a guest from another organization.

Steps:

  1. Approve SourceLace once (Entra admin). Sign-in asks for one Microsoft permission: Azure SQL Database, user_impersonation ("Access Azure SQL DB and Data Warehouse"), plus offline_access so people stay signed in. Most organizations do not let people consent to apps themselves, so the first person to connect sees "Need admin approval". To approve it: connect once yourself and tick Consent on behalf of your organization, or afterwards in the Entra admin center → Enterprise applications → SourceLace → Permissions → Grant admin consent.
  2. Give people access to the data (Fabric workspace admin, or Synapse admin).
    • Fabric: share the warehouse or lakehouse with each person or group (Share, tick Read all data using SQL), or give them a workspace role (Manage access: Viewer is enough to read). SQL permissions such as GRANT SELECT and row-level security apply as usual.
    • Synapse dedicated or serverless: in each database, create a user per person or Entra group and grant read access, for example CREATE USER [Sales Analysts] FROM EXTERNAL PROVIDER; ALTER ROLE db_datareader ADD MEMBER [Sales Analysts];. A paused dedicated pool must be resumed before people can query it.
    • Serverless: SourceLace does not allow OPENROWSET (it can read any storage address), so publish what people should read as external tables or views in a serverless database. Readers also need read access to the files behind them (such as Storage Blob Data Reader), unless the external data source uses a database scoped credential.
  3. Synapse only: open the firewall. In the Azure portal, the Synapse workspace, Networking → Firewall rules: add SourceLace's outbound IP addresses (ask support@sourcelace.com for the current list) and Save. SourceLace connects to the SQL endpoint on TCP port 1433. Fabric needs nothing here.
  4. Optional: your own Entra app, for example if your policy allows only apps registered in your tenant:
    1. Entra admin center → App registrations → New registration. Name: SourceLace. Supported account types: this organization only. Redirect URI: platform Web, https://mcp.sourcelace.ai/connect/callback.
    2. API permissions → Add a permission → APIs my organization uses → Azure SQL Database → Delegated → user_impersonation. Then Grant admin consent.
    3. Certificates & secrets → New client secret. Copy its Value (not the Secret ID), shown only once.
    4. Copy the Application (client) ID and your Directory (tenant) ID from the Overview page. They go in the source's options below, with the secret.

Check that it worked: after your SourceLace admin adds the source, one person clicks Connect, signs in with their work account, and asks the first test question from At a glance. SourceLace shows the account Fabric or Synapse saw, under their name on the source.

Microsoft's own guides: Microsoft Fabric documentation, Azure Synapse Analytics documentation and Microsoft Entra documentation (search for "Grant tenant-wide admin consent").

Add the source (SourceLace admin)

Kind: Microsoft Fabric and Azure Synapse (fabric).

Option Type Default Example What it is
host Text (required) abc123xyz.datawarehouse.fabric.microsoft.com The SQL connection string's server (see Before you start). Only Fabric and Synapse addresses are accepted.
database Text (required) Sales The warehouse, lakehouse, SQL pool or serverless database name.
tenant Text your SourceLace server's corvanta.com Your Entra tenant id or domain. Recommended, so people (and guests) sign in to the tenant that owns the data.
client_id Text (none) aaaaaaaa-bbbb-... Only with your own Entra app: its Application (client) ID. Needs client_secret and tenant too.
client_secret Secret (none) Only with your own Entra app. Stored encrypted and never shown again.
max_scan_gb_per_day Number of GB, or off 1000 200 Serverless pools only. See cost protection below.
totals_at_source on or off on off on: SourceLace may ask Fabric to work out totals; off: it reads the rows and adds them up itself (same answer, slower on big tables). See Totals worked out by your system.

Cost protection:

  • Every query has the organization's query time limit (about a minute unless your admin changed it). When it runs out, SourceLace cancels the query on the server, not only on its side. When a query reaches the row cap, SourceLace cancels the rest, so the server stops reading.
  • Serverless pools bill by data processed (at least 10 MB per query), and Synapse offers no way to estimate a query before it runs. So before each query SourceLace reads the workspace's own count of data processed today, and refuses to start once it reaches max_scan_gb_per_day (1000 GB unless set, about US$5 at Microsoft's list price). That count is for the whole workspace, not only SourceLace, and a query already running is not stopped by it. Also set Synapse's own limits, which Synapse enforces itself, for example EXEC sp_set_data_processed_limit @type = N'daily', @limit_tb = 1; (and weekly, monthly). To rely on those alone, set max_scan_gb_per_day to off.
  • Fabric and dedicated pools are paid by capacity, not per query, so the time limit is what protects them. A long query still uses capacity while it runs.

Tables are named schema.table, such as dbo.orders. Write T-SQL: SELECT TOP 100 ... rather than LIMIT. Refused before anything is sent: OPENROWSET, OPENQUERY and similar, system procedures (sp_..., xp_...), WAITFOR, locking hints and SELECT ... INTO.

When something goes wrong with Fabric or Synapse

What you see What it means What to do
"Sign-in was not completed: AADSTS65001 ... Your Microsoft Entra admin approves SourceLace once ..." (or AADSTS90094, "Need admin approval") Your tenant does not let people consent to apps, and no admin has approved SourceLace yet. An Entra admin grants admin consent (step 1).
"Microsoft sign-in failed: AADSTS7000215 ..." Your own Entra app's secret is wrong: often the Secret ID was entered instead of its Value. Create a new secret and enter its Value (step 4).
"Microsoft sign-in failed: AADSTS50011 ..." Your own Entra app's redirect URI does not match SourceLace's. Set it exactly as in step 4.
"Microsoft Fabric did not accept your Microsoft sign-in. Ask an admin to give your account access to ..." The person has no access to the warehouse or database. If they are a guest, they may have signed in to their own tenant. Give access (step 2). For guests, set the source's Entra tenant to the tenant that owns the workspace.
"...: your account cannot open .... Check the database option ..." The database name is wrong, or the person has no user in it. Fix Warehouse or database, or create the user (step 2).
"...: the Synapse or Azure SQL firewall does not allow SourceLace ..." The workspace's firewall refused SourceLace (error 40615). Add SourceLace's IP addresses (step 3).
"... could not be reached. Check the host option, that the SQL pool is running ..." The address is wrong, the dedicated pool is paused, or a network rule blocks it. Check SQL endpoint, resume the pool, and check step 3.
"The host option of ... must be a Fabric or Synapse SQL address ..." The value is not a Fabric or Synapse SQL endpoint (often the workspace's web address). Copy the SQL connection string's server (see Before you start).
"The tenant option of ... must be your Microsoft Entra tenant id or a domain ..." The tenant is not a GUID or a domain. Enter corvanta.com or the Tenant ID.
"To sign in to ... through your own Entra app, set client_id ..., client_secret and tenant ... together." Only part of your own app's details is filled in. Fill all three, or empty all three to use SourceLace's app.
"This Synapse workspace has already processed ... GB today, which reaches ...'s daily limit ..." The daily limit is reached. Wait until tomorrow (UTC), or raise max_scan_gb_per_day.
"SourceLace could not read today's data processed ..." People cannot read sys.dm_external_data_processed. Let them read it, or set Synapse's own limit and max_scan_gb_per_day to off.
"Your Microsoft sign-in has expired." The sign-in ended. Click Connect again.
"... refused the query: ..." Fabric's or Synapse's own words about the query. The AI usually fixes the query itself.
"Set the database option of ...: the warehouse, lakehouse or SQL pool name, such as Sales." The source has no database name. An admin enters the warehouse, lakehouse or SQL pool name.
"The max_scan_gb_per_day option of ... must be a whole number of gigabytes, such as 1000, or "off"." The daily limit holds something other than a whole number. An admin enters whole gigabytes, or off.
"... did not finish the query in time, so SourceLace stopped it." or "... did not answer in time, so the query was stopped." The query ran longer than SourceLace allows, or the pool is busy or paused. Narrow it (fewer columns, a WHERE clause, TOP) and try again.
"There is no table or view ... in ... that you can read." The name is wrong, or your account has no permission on it. Use a name from search_schema, and ask the database's admin about your access.
"... has no Entra app to sign in through: SourceLace's Microsoft sign-in is not set up yet." The source has no client_id, client_secret and tenant of its own, and SourceLace's own Microsoft app is not available for it. An admin enters your own Entra app's values (see What your admin does in Microsoft Entra, Fabric and Synapse), or contacts support.
"Microsoft Fabric and Synapse sources are not available on SourceLace yet." The connector is not switched on for this SourceLace server. Contact support.

When something goes wrong

Each data platform has its own table: Snowflake, BigQuery, Databricks, Amazon Redshift, Amazon Athena and Fabric and Synapse. For every one of them:

What you see What to do
"'...' is not allowed in a read-only ... query." or "SELECT ... INTO is not allowed in a read-only query." Only plain reads are allowed.