Free Snowflake SnowPro Advanced: Architect (ARA-C01) Sample Questions

Correct answer: A — An aggregation policy that enforces a minimum group size, combining any group smaller than the threshold into a remainder group so individual records cannot be isolated.

• A. An aggregation policy enforces a minimum group size for any query against the protected object, folding undersized groups into a remainder group with nulled grouping columns so a partner cannot isolate an individual record through a narrow filter.
• B. This is incorrect because masking transforms displayed values but does not prevent a partner from filtering or grouping queries narrowly enough to isolate one customer's row within an otherwise unmasked aggregate.
• C. This is incorrect because restricting which rows are visible does not stop a partner from grouping or filtering within the allowed row set narrowly enough to isolate a single customer's contribution.
• D. This is incorrect because a secure view only hides the view's definition and DDL from unauthorized users; it does not constrain how finely a partner can group or filter the data returned by the view.

Correct answers: A, B — Create access roles per schema holding the privileges needed to query each schema, and grant both into CLAIMS_FUNCTIONAL so the row access policies evaluate against one consistent functional role.; Ensure the mapping table each row access policy references has an entry for CLAIMS_FUNCTIONAL, or for an access role it is granted, so the policy resolves the correct region scope.

• A. Building access roles per schema and granting them into the CLAIMS_FUNCTIONAL role follows the functional-role-over-access-role pattern, letting the row access policies evaluate consistently while access remains centrally auditable through the functional role.
• B. Because each row access policy resolves visibility through a mapping table keyed on the querying role, that mapping table needs an entry for whichever role, functional or access, is actually active in the session for the policy to grant the correct region scope.
• C. This is incorrect because row access policies evaluate CURRENT_ROLE() or other session context against whatever role is active; there is no requirement that the role be ACCOUNTADMIN for policy evaluation to work.
• D. This is incorrect because row access policies can evaluate against any active role, including access roles granted into a functional role; using access roles is a supported and common pattern, not one that breaks policy evaluation.
• E. This is incorrect because row access policies and role grants are independent mechanisms that coexist normally; there is no requirement to disable a policy before granting privileges on the schema it protects.

Correct answer: A — Run `ALTER SCHEMA analytics.raw SET DATA_RETENTION_TIME_IN_DAYS = 3` so every table created afterward in that schema inherits the value unless a table-level override is set.

• A. This is correct because object parameters resolve from account to database to schema to table, and setting the value at the schema level makes it the default for every table created in that schema, while still allowing an individual table to override it.
• B. This is unnecessary and contradicts how object parameters work: setting the value at the schema level is exactly the mechanism that lets child tables inherit it, so per-table configuration is not required.
• C. `DATA_RETENTION_TIME_IN_DAYS` is an object parameter, not a session parameter, so setting it in a session has no effect on the retention behavior of tables created during that session.
• D. Masking policies govern column-level data visibility, not Time Travel retention windows; retention is controlled purely through the object parameter hierarchy, not through Horizon governance policies.

Correct answers: A, B — A single account requires careful naming conventions and RBAC design to keep production and non-production objects and privileges cleanly separated, since no account boundary exists to fall back on.; Every workload in a single account shares the same top-level account parameter defaults, so a change intended for one team's environment can unintentionally affect every other team unless carefully scoped to lower objects.

• A. This is a genuine limitation because without a separate account for each environment, teams must rely entirely on naming standards, dedicated databases or schemas, and RBAC to prevent production and non-production objects from being mixed or misused.
• B. This is genuine because account parameters apply account-wide by default, so an ACCOUNTADMIN changing an account-level default must consider every downstream workload, whereas separate accounts would isolate that blast radius.
• C. Snowflake accounts support any number of independently sized and scaled virtual warehouses; a single account is not limited to one warehouse, so this does not describe a real constraint.
• D. Time Travel retention is an object parameter that can be configured independently per database, schema, or table within a single account; it is not fixed after the first database is created, so this is not a real limitation.
• E. Role-based access control is fully available and is the primary access mechanism within a single Snowflake account; a single account does not collapse all users to identical privileges, so this misdescribes how RBAC works.

Correct answer: A — Organization Users, which let an identity be defined once at the organization level and then granted roles in any linked account instead of creating a separate local user record in each account.

• A. This is correct because Organization Users is the feature purpose-built for defining an identity once at the organization level and granting it access into any linked account, avoiding duplicate per-account user records and the sync burden that comes with them.
• B. Database replication copies table and schema data between accounts for disaster recovery or sharing purposes; it is not the mechanism used to centralize user identity, and the `SNOWFLAKE` database's user metadata is not something replication is designed to synchronize this way.
• C. Resource monitors track and control credit consumption to prevent runaway spend; they have no role in managing user identity or credentials across accounts, so they do not address this requirement.
• D. Virtual warehouses provide compute for query execution and are scoped to a single account; they do not centralize user identity or authentication across multiple linked accounts in an organization.

Correct answer: A — All three provide comparable inbound private connectivity for their respective cloud, but cross-region private connectivity is currently supported only through AWS PrivateLink.

• A. This is correct because Snowflake documents that AWS PrivateLink, Azure Private Link, and GCP Private Service Connect all deliver comparable inbound private connectivity, while cross-region private connectivity is currently an AWS-only capability.
• B. This is incorrect because each cloud's private connectivity option is independent and tied to that cloud's own networking primitives; Azure and GCP accounts do not need to provision AWS PrivateLink first.
• C. This is incorrect because all three private connectivity options require Business Critical Edition or higher; none of them is available on lower editions as a way to avoid the edition requirement.
• D. This is incorrect because Azure Private Link, like its AWS and GCP counterparts, is documented to cover UI, JDBC, and ODBC driver connections rather than being limited to Snowsight alone.

Correct answers: A, B — An administrator temporarily sets `MINS_TO_BYPASS_MFA` on the user, allowing brief access without a second factor.; An administrator generates new one-time passcodes via `ALTER USER ... ADD MFA METHOD OTP COUNT=n` for the user's later emergency use.

• A. This is correct because `MINS_TO_BYPASS_MFA` is the documented, time-bound administrative mechanism for granting temporary MFA bypass to a locked-out user.
• B. This is correct because generating one-time passcodes via `ALTER USER ... ADD MFA METHOD OTP COUNT=n` is the documented break-glass mechanism for providing emergency access codes to a user.
• C. This is incorrect because Snowflake does not support blank passwords as a valid credential, and this approach would create a broad, unmanaged security exposure rather than a scoped emergency fix.
• D. This is incorrect because deleting the account's authentication policy removes MFA protection for every user permanently, which is a drastic account-wide change disproportionate to a single user's lockout.
• E. This is incorrect because sharing a personal MFA device defeats the purpose of individual authentication factors and is not a supported or auditable Snowflake mechanism for account recovery.

Correct answer: A — The `LOGIN_HISTORY` entry for that session, where `FIRST_AUTHENTICATION_FACTOR` is recorded as `OAUTH_ACCESS_TOKEN` for OAuth logins specifically.

• A. This is correct because Snowflake documents that OAuth-based logins produce a `LOGIN_HISTORY` entry with `FIRST_AUTHENTICATION_FACTOR` set to `OAUTH_ACCESS_TOKEN`, giving auditors direct evidence of the authentication method used.
• B. This is incorrect because `GRANTS_TO_USERS` records role-to-user grant relationships, not authentication method metadata for individual login sessions.
• C. This is incorrect because `QUERY_HISTORY` records executed SQL statements and metadata, and Snowflake does not store raw bearer token values in this view for security reasons.
• D. This is incorrect because there is no `NETWORK_POLICIES` system view that logs per-session authentication method; login authentication factor is captured in `LOGIN_HISTORY` instead.

Correct answer: A — Cross-Cloud Auto-Fulfillment, which automatically replicates the listing's data into a new region or platform the first time a consumer there requests it.

• A. Correct - Cross-Cloud Auto-Fulfillment automates the replication step for listings, provisioning the data into a new region or cloud platform on demand when a consumer there requests access, instead of the provider pre-replicating everywhere manually.
• B. Incorrect - reader accounts solve the 'consumer has no Snowflake account' problem, not the 'data isn't replicated into the consumer's region or platform yet' problem this scenario describes.
• C. Incorrect - row access policies control which rows a role can see within data that is already accessible; they do nothing to move the underlying data into a new region or cloud.
• D. Incorrect - Time Travel provides point-in-time recovery of a table's own history and has no role in extending a listing's reach into new regions or clouds.

Correct answer: A — The subsidiary sees changes to the shared data almost immediately, without the provider maintaining a separate copy or storing duplicate data on the subsidiary's side.

• A. Correct - Secure Data Sharing exposes live data directly from the provider's storage, so the subsidiary sees near-real-time changes without any batch export, and no additional copy of the data is stored in the subsidiary's account.
• B. Incorrect - the consuming account runs its own warehouse to query shared data, so compute charges for those queries are billed to the subsidiary, not absorbed by the provider.
• C. Incorrect - role-based access control still governs which roles inside each account can use the share or query the resulting database; a share does not eliminate the need for RBAC.
• D. Incorrect - Secure Data Sharing removes the need for staging and file export entirely, since data is accessed directly rather than moved through an intermediate stage.

Correct answer: A — Offer a private listing scoped to the known partner's account, and a separate public listing on the Marketplace for prospective customers to discover.

• A. Correct - a private listing fits the known, contracted partner by staying restricted and out of public view, while a separate public listing gives new, unknown customers a way to discover and request the same dataset, covering both audiences without compromising either.
• B. Incorrect - a public listing is meant for open discovery, and restricting it after publication does not restore the confidentiality expected by a partner under a specific contract.
• C. Incorrect - a reader account is tied to the provider's cost and management for one consumer at a time; it is not a discovery mechanism for attracting unknown prospective customers.
• D. Incorrect - relying on the partner to redistribute access sidesteps the provider's own control over who can obtain the dataset and does not give new customers an actual discovery path.

Correct answer: A — Data Vault modeling, using hubs to anchor stable business keys and satellites to capture each source's attributes and load history as new hospital systems are added over time.

• A. Data Vault's hubs give a stable anchor for the patient business key regardless of which source supplies it, and satellites append each hospital system's attributes with load history, which is exactly the unknown-future-sources plus audit-history requirement described.
• B. Adding new columns to a wide dimension table for every hospital system's fields does not scale as unknown future systems are onboarded, and it does not preserve source-attributable history the way satellites do.
• C. Keying solely on patient name risks collisions across hospital systems and a single flat table for every attribute makes it hard to preserve which source reported which value over time.
• D. A truncate-and-reload snapshot table discards prior state on every refresh, which directly conflicts with the requirement to preserve a defensible history of every source value.

Correct answer: A — The team spends most of the two weeks designing hub, link, and satellite tables, then still needs a reporting layer before analysts can query anything, missing the deadline.

• A. Building hubs, links, and satellites for a single stable source is more modeling work than a small team needs, and the resulting structure still needs a reporting layer on top before dashboards can query it comfortably, which is likely to blow past a two-week deadline.
• B. Data Vault tables are typically not queried directly by BI tools for simple dashboards; the hub/link/satellite joins are more suited to a reporting layer built on top, so this would not deliver on time as described.
• C. Data Vault modeling is specifically designed to make adding future sources easier, not harder, so this outcome misstates what the structure does for source flexibility.
• D. Data Vault modeling generally requires more upfront table design and a derived reporting layer compared to building a single star schema mart directly, so the effort is not identical.

Correct answers: A, B — The secondary reflects a point-in-time consistent snapshot as of its most recently completed refresh, not the primary's state at query time.; Replication is asynchronous, so the secondary can lag behind the primary by however long elapses between scheduled refresh cycles.

• A. Correct - the secondary account reflects a consistent snapshot as of its last completed refresh rather than the primary's live, in-the-moment state.
• B. Correct - replication runs on a scheduled, asynchronous basis, so the secondary's staleness is bounded by the interval between refresh cycles.
• C. Incorrect - replication groups refresh on a schedule rather than synchronously, so millisecond-level lockstep with the primary is not how this works.
• D. Incorrect - the point-in-time consistency applies to the replicated objects together, not just to schema metadata while row data drifts independently.
• E. Incorrect - refreshes do provide a defined consistency guarantee, point-in-time consistency as of the completed refresh, rather than no guarantee at all.

Correct answer: A — A new schema with the same name was already created in that database, and Snowflake requires the name to be free before an UNDROP can succeed.

• A. Correct - UNDROP requires the object's name to be unused; if a new schema with the same name was created afterward, the original cannot be restored under that name until it is renamed or the new one is removed.
• B. Incorrect - UNDROP remains available for the full configured retention window, not just the first hour, so a 20-hour-old drop within a 5-day window should still be eligible.
• C. Incorrect - UNDROP supports schemas and databases in addition to tables, so schema-level restoration is a valid operation.
• D. Incorrect - a schema's retention setting covers the schema and its contained objects together, so this failure is not explained by child-table data being silently dropped.

Correct answers: A, B, C, D — A stage object that references the external or internal location where raw source files are landed before loading.; A file format object that defines how staged files such as CSV or Parquet should be parsed during a load.; A stream object that records the change data capture information for a table so downstream tasks can consume it.; A task object that runs a scheduled SQL statement or calls a stored procedure to transform newly captured changes.

• A. Correct - stages are schema-level objects and are the standard landing point for files before a COPY INTO load brings them into a table.
• B. Correct - file formats are schema-level objects that define parsing rules like delimiter or compression and are referenced by stages or COPY INTO statements.
• C. Correct - streams are schema-level objects that track row-level inserts, updates, and deletes on a source table for consumption by downstream logic.
• D. Correct - tasks are schema-level objects that execute on a schedule or trigger and commonly consume a stream's captured changes to drive transformation.
• E. Incorrect - virtual warehouses are account-level compute resources, not schema-level objects, and a warehouse is never scoped to or owned by a single schema.
• F. Incorrect - an organization is the top-most container above accounts and has no schema-level equivalent; schemas cannot group or contain organization-level constructs.

Correct answers: A, B, D — The user can query the tables covered by ANALYST_RO's SELECT grants because BI_TEAM automatically inherits the privileges of every role that is granted to it.; A user whose default role is SYSADMIN also inherits the SELECT privileges originally granted to ANALYST_RO, because SYSADMIN sits above BI_TEAM in the hierarchy.; Revoking ANALYST_RO's SELECT grant on the tables removes that inherited access from anyone under BI_TEAM or SYSADMIN, since inheritance is evaluated dynamically at query time.

• A. Correct - when a role is granted to another role, the higher role inherits all privileges of the lower role, so BI_TEAM gains ANALYST_RO's SELECT access.
• B. Correct - inheritance cascades further up the chain, so any role above BI_TEAM, including SYSADMIN here, also inherits the privileges that flowed up from ANALYST_RO.
• C. Incorrect - the entire point of role-to-role grants is that activating the higher role automatically carries the lower role's privileges, with no manual switch required.
• D. Correct - Snowflake evaluates privileges dynamically, so revoking the underlying grant removes the inherited access from every role above it in the hierarchy right away.
• E. Incorrect - Snowflake supports only one active primary role per session context for most privilege checks here, and no extra role activation step is needed since inheritance already combined the access.

Correct answers: A, B, D — Queries joining tables across business-unit databases must fully qualify each table reference, since the active session namespace can only default to one database at a time.; Granting an analyst role read access across business units requires separate USAGE and SELECT grants scoped to each database and schema, since privileges never cross boundaries automatically.; Zero-copy cloning of one business unit's database has no effect on objects in a different business unit's database, since clones apply only within the source database's namespace.

• A. Correct - with multiple databases in play, a session can only have one database active as a default, so tables outside it must be referenced with full database.schema.table qualification in the query.
• B. Correct - because privileges are scoped within the hierarchy they were granted on, cross-business-unit access requires explicit USAGE and SELECT grants repeated for each database and schema the analyst needs.
• C. Incorrect - Snowflake fully supports cross-database joins as long as references are properly qualified and the querying role holds the necessary privileges in each database involved.
• D. Correct - cloning operates on the object hierarchy rooted at the object being cloned, so cloning one database's contents does not touch or replicate objects that live in a separate database.
• E. Incorrect - Time Travel retention is configured per object or per account default and does not propagate automatically from one database to unrelated databases elsewhere in the account.

Correct answers: A, B, C — Use separate databases, or separate accounts for stricter isolation, for production, development, and sandbox, giving each its own namespace and access boundary.; Scope roles and grants so that only the production role can write to production schemas, while development and sandbox roles are confined to their own databases.; Refresh development and sandbox environments from production using zero-copy clones on a defined cadence so testing reflects realistic data volumes and shapes.

• A. Separate databases or accounts give each environment its own object namespace and grant boundary, which is the foundation of preventing development work from touching production objects.
• B. Scoping grants so only the production role can write to production schemas enforces the isolation the separate namespaces are designed to provide, rather than leaving it to convention.
• C. Refreshing lower environments from production clones keeps test data realistic in volume and shape without duplicating storage or waiting on a separate ETL pipeline to populate them.
• D. Sharing one database across all three environments and relying on naming conventions removes any real access boundary and makes accidental cross-environment writes likely.
• E. Granting the production role broad access into development and sandbox schemas collapses the isolation boundary in the other direction and increases the blast radius of a compromised production credential.

Correct answers: A, B — Configure the workflow to authenticate to Snowflake using workload identity federation with GitHub's OIDC provider instead of a stored static credential.; Pin the Snowflake CLI deployment step to run only after the change is merged into the main branch, not on every feature-branch push.

• A. Using OIDC-based workload identity federation removes the need for a static, long-lived credential in the workflow, aligning with the CI/CD security practices Snowflake recommends.
• B. Restricting the deployment step to merges into main, rather than every feature-branch push, keeps changes flowing through review before they reach any real environment.
• C. Deploying to production before development inverts the normal promotion order and removes the chance to catch problems in a lower environment first.
• D. Granting the CI identity ACCOUNTADMIN violates least-privilege practice by giving a pipeline far more access than deployment tasks require, increasing the impact of a compromised runner.
• E. Leaving role and warehouse context unspecified makes the deployment's behavior depend on whatever context the service identity last used, which is unpredictable and hard to audit.

Correct answers: A, B — The forecasting function includes preprocessing options that can handle missing or irregularly spaced time steps in the historical training data.; The forecasting function is designed to predict future values of a time-series metric, such as per-SKU demand, based on its own historical trend.

• A. Snowflake's forecasting function includes preprocessing features for specifying event frequency and inferring missing data, which is exactly the kind of imperfect real-world time series described here.
• B. Forecasting is built to project a metric's future values forward from its historical trend, which matches predicting per-SKU demand from past daily sales.
• C. The function is a managed, built-in Snowflake ML capability; it trains its own model from the SQL-provided data and does not require an externally trained PyTorch model.
• D. The function can be applied per grouping key, such as per SKU, rather than being limited to a single global series across the account.
• E. No forecasting model guarantees perfect accuracy; sparse or irregular input data still limits how reliable the resulting predictions are, even with preprocessing support.

Correct answer: A — Create a storage integration object referencing an IAM role, and point the external stage at that integration instead of embedding keys.

• A. Correct - a storage integration holds an IAM role reference that Snowflake assumes at access time, so the external stage never stores long-lived static credentials, which is the documented secure pattern.
• B. Incorrect - hardcoding an access key and secret key in the stage definition stores long-lived static credentials in plain sight, which is exactly the outcome the team wants to avoid.
• C. Incorrect - a pre-signed URL still embeds credential material and typically expires, making it an unsuitable and fragile substitute for a durable, credential-free storage integration.
• D. Incorrect - session variables are not a supported or secure mechanism for stage authentication, and referencing keys through them still keeps long-lived secrets present in the account.

Correct answer: A — Run ALTER EXTERNAL TABLE ... REFRESH on a schedule after the nightly mirror job completes, since automatic notifications are not configured.

• A. Correct - without cloud storage event notifications wired up, external table metadata only updates through a manual or scheduled ALTER EXTERNAL TABLE REFRESH, so scheduling one after the mirror job closes the gap.
• B. Incorrect - external tables support metadata refresh without recreating the object, so dropping and rebuilding the table daily is unnecessary operational churn for solving a refresh timing problem.
• C. Incorrect - external tables are a distinct read-only construct and do not have a Snowpipe Streaming mode; streaming ingestion writes into ordinary tables, not external table metadata.
• D. Incorrect - warehouse size affects query compute, not how often external table file metadata is synchronized, so resizing the warehouse has no effect on staleness.

Correct answers: A, B — Leave the default multi-file behavior in place so Snowflake automatically splits output across several files.; Set MAX_FILE_SIZE to bound each output file's size, keeping individual files at a manageable, parallelizable size for Spark.

• A. Correct - Snowflake's default unload behavior already distributes output across multiple automatically named files rather than one giant file, which is a prerequisite for multiple Spark executors to read in parallel.
• B. Correct - MAX_FILE_SIZE caps how large each individual output file can grow, letting the team keep files at a size that is reasonable for a single executor to process, directly supporting balanced parallel reads.
• C. Incorrect - SINGLE = TRUE forces the entire unload into one file, which is the opposite of what is needed here and would force one executor to handle the entire 200 GB output alone.
• D. Incorrect - PARTITION BY organizes output into a directory structure based on the specified column's values, and choosing a column unrelated to the read pattern does not help executors divide work evenly, so it is not the mechanism for bounding file size.
• E. Incorrect - most common compressed formats used for unloading are splittable by big data engines like Spark, and disabling compression would only increase storage and transfer cost without helping executors divide the file count evenly.

Correct answer: A — `SYSTEM$ALLOWLIST`, since its output enumerates the hostnames and ports, including Snowsight and MFA-related endpoints, that the PrivateLink configuration must expose.

• A. This is correct because `SYSTEM$ALLOWLIST` enumerates the hostnames and ports the deployment depends on, including Snowsight and MFA-related endpoints, which is exactly the information needed to confirm a PrivateLink configuration resolves and exposes what it must.
• B. The Spark connector has no built-in connectivity test mode for validating PrivateLink endpoint reachability; its scope is moving DataFrames between Spark and Snowflake tables, not network topology diagnostics.
• C. SnowSQL has no `!system` command that queries the OS DNS resolver for PrivateLink endpoint validation; SnowSQL's built-in commands are focused on session and query management, not network diagnostics.
• D. Enabling verbose ODBC driver logging surfaces details about the specific connection attempt being made, not a comprehensive, deployment-independent enumeration of every required PrivateLink endpoint the account needs.

Correct answer: A — Switching offers little benefit here, because the row-level Python logic cannot be pushed down to Snowflake's engine, so Snowpark would still execute that portion client-side just as the Python connector does today.

• A. This is correct because Snowpark's pushdown advantage only applies to logic expressible as Snowflake operations; row-level Python logic with no SQL equivalent still has to run outside Snowflake's engine, so the bottleneck this job has today would persist under Snowpark as well.
• B. Snowpark does not automatically translate arbitrary row-level Python code into pushed-down SQL; only operations expressible through its DataFrame API and supported functions are pushed down, so this guarantee is inaccurate.
• C. The Python connector's core function is fetching query results from Snowflake into a Python process, which is exactly what the described job already does successfully; the claim that this is impossible is factually wrong.
• D. Writing results to a local file, such as a CSV, is unrelated to Snowpark's DataFrame execution model and can be done in ordinary Python code after retrieving results; this is not a documented limitation that would cause the job to fail.

Correct answer: A — The default table has two VARIANT columns: one holding the raw Kafka message content and one holding metadata such as topic, partition, offset, and timestamp.

• A. This is correct because the connector's documented default schema is exactly two VARIANT columns, one for the raw message content and one for metadata including topic, partition, offset, and timestamps.
• B. The connector does not automatically infer and flatten the message schema into individual columns by default; it lands the raw content as-is in a VARIANT column, leaving flattening as a downstream transformation step.
• C. The default table is not reduced to a single offset column; it retains the full message content and metadata directly in Snowflake, with no need for a downstream join back to Kafka to see the message body.
• D. Metadata is not discarded by design; the connector explicitly stores metadata such as topic, partition, offset, and timestamp in a dedicated VARIANT column alongside the raw message content.

Correct answers: A, B, C — Rows are split into batches sent as separate HTTP requests, so the added network round-trip latency for each batch accumulates across the full row count.; Each batch response is capped at a maximum size, so overly wide result rows can force smaller batches and therefore more total round trips overall.; The call chain passes through a proxy service before reaching the remote service, adding an extra network hop compared to a function running natively inside Snowflake.

• A. Correct - external functions batch rows into HTTP requests, and each batch requires a network round trip to the remote service, so per-batch latency accumulates in a way that a purely in-Snowflake UDF never incurs.
• B. Correct - each batch's response has a maximum size limit, so if individual rows or returned values are large, Snowflake must use smaller batches to stay under that cap, increasing the total number of round trips needed.
• C. Correct - external functions route through a proxy service layer before reaching the actual remote service code, which is an additional network hop compared to code that executes directly inside Snowflake's compute.
• D. Incorrect - external functions do batch rows for parallelism rather than processing the entire table in one strictly serial stream, so claiming there is no parallelism at all misstates how batching works.
• E. Incorrect - warehouse compute is still consumed to prepare, batch, and send rows to the proxy service and to process the returned results, so external function usage does not eliminate warehouse credit consumption.

Correct answer: A — A standard view selecting only the permitted columns, since it re-executes its query against the current table state on every reference and never introduces staleness.

• A. Correct - a standard view has no stored copy of its own; it re-executes its defining query against the base table's current state every time it is referenced, so it inherently has zero staleness while still restricting the visible columns to the permitted subset.
• B. Incorrect - materialized views store a physical copy of their result and refresh asynchronously in the background as the base table changes, so they can lag behind the true current state rather than guaranteeing synchronous, zero-staleness reads.
• C. Incorrect - a dynamic table's TARGET_LAG is a best-effort freshness goal, not a guarantee; even a tight one-minute target can be exceeded under load, so it does not guarantee zero staleness the way a standard view does.
• D. Incorrect - a stream represents an offset of changes since it was last consumed rather than the full current table state, and exposing it directly does not give a reporting role a simple, always-current view of permitted columns the way a view does.

Correct answers: A, B, C — A UDTF's handler code runs inside Snowflake's own compute, avoiding the network round trips to a proxy and remote service that an external function call requires.; An external function can invoke libraries or languages that no Snowflake UDF handler supports, at the cost of added per-batch network latency for every call.; A UDTF can be referenced with a LATERAL join so its per-input-row table output can be combined with the other columns from the row that produced it.

• A. Correct - a UDTF executes using one of Snowflake's supported handler languages inside Snowflake's own compute, so it does not incur the proxy-service and remote-service network hops that make external functions slower per batch.
• B. Correct - external functions exist specifically to reach languages, libraries, or services unavailable to any Snowflake UDF handler, and that capability comes with the documented tradeoff of added network latency per batch.
• C. Correct - a LATERAL join is the standard way to call a UDTF so that its expanded table output for each input row can be joined back with the other columns of that same row.
• D. Incorrect - external functions are scalar only, returning a single value per input row, unlike a UDTF which can return multiple rows and columns per input row; this is a documented limitation of external functions.
• E. Incorrect - external functions are documented as unusable inside a COPY INTO transformation clause; a UDTF is likewise not a valid expression in that specific clause, so neither object type works there.

Correct answer: A — Resize the warehouse to a larger size so more memory per node is available, since remote spilling means the operation's intermediate data exceeded both memory and local disk.

• A. Remote spilling is the most severe memory-pressure signal, meaning the operation overflowed both memory and local disk; increasing warehouse size raises the memory available per node and is the direct lever to relieve that specific bottleneck.
• B. Clustering improves how many partitions must be scanned and read, but it does not change how much intermediate state an aggregation operator needs to hold in memory once the relevant rows are already selected, so it does not directly fix spillage.
• C. Auto-suspend governs how quickly an idle warehouse shuts down between sessions; it has no bearing on the memory available to an operator during an active, currently spilling execution.
• D. Snowpark-optimized warehouses provide extra memory for Snowpark workloads with large memory or specific CPU requirements; ordinary SQL spillage is resolved by standard warehouse resizing, not by switching warehouse types.

Correct answers: A, B — The query acceleration service offloads eligible portions of a query's execution to serverless compute resources managed by Snowflake, separate from the warehouse's own compute here.; The query acceleration service is best suited to queries with large scans and selective filters, where a small number of operators dominate the entire query's overall execution time.

• A. This is accurate: the service offloads eligible scan and filter work to Snowflake-managed serverless compute that is separate from and in addition to the warehouse's own compute resources.
• B. This is accurate: the service is most effective when a query has large scans and selective filters that dominate execution time, since those are the operator types it can offload.
• C. The query acceleration service is enabled as a warehouse-level parameter, not through a per-query hint, and Snowflake's eligibility logic then decides which queries on that warehouse can benefit.
• D. The service only offloads specific scan- and filter-heavy portions of eligible queries; it does not offload the full range of operators such as joins and shuffles, so it does not universally eliminate the need to resize a warehouse.
• E. The speedup depends on how much of a given query's time is spent in operators eligible for offload; queries dominated by non-eligible operators see little or no benefit, so no fixed guaranteed speedup applies.

Correct answers: A, B, E — Define or adjust a clustering key so it leads with the column that carries the most selective, frequently used filter predicate.; Ensure ingestion loads data in an order reasonably close to how it will later be filtered, so natural clustering starts closer to ideal.; Periodically monitor `SYSTEM$CLUSTERING_INFORMATION` to confirm the table's overlap metrics stay low as new data arrives.

• A. Correct — designing the clustering key around the dominant, selective filter is the direct lever for improving how many partitions a typical query can eliminate.
• B. Correct — loading data in an order close to the eventual filter pattern reduces how much reclustering work is needed to reach good pruning, and can prune reasonably well even before a key is added.
• C. Incorrect — warehouse size affects how fast the partitions that are scanned get processed, not how many partitions the optimizer eliminates through pruning.
• D. Incorrect — splitting a single filter column into several narrower columns doesn't change the underlying value distribution or how partition metadata is organized; it just complicates the query.
• E. Correct — regularly checking clustering metrics catches degradation early, letting the team intervene with reclustering or a key change before pruning noticeably worsens.

Correct answers: A, B, D — Economy auto-scale policy favors fewer running clusters and tolerates queuing, while standard policy starts clusters more readily to minimize it.; Every cluster in a multi-cluster warehouse must run at the same size, since warehouse size is configured once for the whole warehouse.; Scaling out with more clusters increases capacity for concurrent queries, but it doesn't make any single running query itself faster.

• A. Correct — economy mode accepts more queuing before adding a cluster to save credits, while standard mode adds clusters more aggressively to reduce queuing, and choosing between them is a real cost/latency tradeoff.
• B. Correct — a warehouse, and by extension every cluster within it, is provisioned at one size; you cannot mix cluster sizes within the same multi-cluster warehouse.
• C. Incorrect — Snowflake's storage layer already separates compute from storage, so table data is not replicated per cluster; each cluster reads the same underlying storage independently.
• D. Correct — additional clusters increase concurrent query capacity by letting more queries run in parallel across clusters, but each individual query still executes on a single cluster at that cluster's size.
• E. Incorrect — multi-cluster warehouses are available starting on Enterprise Edition, not restricted to Business Critical Edition or higher.

Correct answer: A — Search Optimization Service on `ticket_uuid`, since it builds a persisted access path for point lookups on high-cardinality, unclustered columns.

• A. Search Optimization Service is purpose-built for exactly this pattern: selective equality or substring lookups on high-cardinality columns that don't naturally cluster well, and it maintains its own access path independent of the table's physical ordering.
• B. Clustering keys are still range/value-range organizational structures; adding more columns to a key does not reliably fix equality lookups on a column with essentially random values like a UUID.
• C. More compute processes a broad scan faster, but it does not reduce how much data has to be scanned when clustering-based pruning isn't working for this access pattern.
• D. A fully duplicated, sorted copy of a 3 TB table adds major storage and maintenance overhead and does not directly provide the fast point-lookup access path that a purpose-built search structure does.