The COF-C03 blueprint is split across 5 domains. Weights are the official share of the exam; see the official exam guide for the authoritative breakdown.
What you must be able to do. Given a description of how Snowflake is structured or a schema-object need, identify the right layer, object, table or view type, warehouse setting, or developer feature - the three independent layers, the correct schema object such as a sequence, the right table type, and managed AI through Snowflake Cortex - and reject the option that names a real feature doing the wrong job.
In one sentenceThe largest domain: knowing the three-layer architecture, the object hierarchy, table and view types, warehouse configuration, micro-partitions, and the developer and AI features, then matching each to the need.
Recall check: answer these from memory first
- Name the three independent Snowflake layers and state which one you would scale to make a single heavy query stop spilling, and why the other two do not fix it.
- An administrator needs one schema object that hands successive unique integers to several tables for surrogate keys. Which object is it, and why are a stage, a materialized view, and a file format wrong?
- An analyst needs a per-row sentiment score in SQL with no model training, deployment, or data movement. Which Snowflake feature delivers it, and why are Snowpark, a Notebook, and Streamlit in Snowflake heavier wrong answers?
What it tests. Understanding what Snowflake is made of and which object does which job. Describing the three independent layers - database storage, query processing through virtual warehouses, and cloud services - and that each scales on its own. Comparing editions and the credit-based consumption model for compute and storage. Identifying the interfaces and tools including Snowsight, SnowSQL, and the connectors and drivers. Knowing the object hierarchy and core objects: databases, schemas, tables, views, stages, sequences, user-defined functions, and stored procedures, including that a sequence is the schema object that hands out successive unique integers to several tables and that UDFs can be overloaded by argument signature. Configuring virtual warehouses - size, multi-cluster, scaling policy, auto-suspend, and auto-resume. Explaining micro-partitions, pruning, and clustering. Distinguishing table types (permanent, transient, temporary, external, dynamic, and Apache Iceberg) and view types (standard, secure, and materialized). Describing the developer and AI features including Snowpark, Snowflake Notebooks, Streamlit in Snowflake, and Snowflake Cortex, where a built-in function such as SENTIMENT scores text per row in SQL with no model training or deployment.
How to study it. Anchor everything on the three-layer model and rehearse it until you can narrate which layer a scenario stresses: storage holds the micro-partitions, compute is the virtual warehouse running the query, cloud services coordinate metadata, security, and the result cache. Drill the object hierarchy by job, not by name: a sequence generates surrogate keys for several tables, a stage holds files, a file format is reusable load options, a stored procedure runs procedural logic. Practise the table-type decisions out loud - transient for no Fail-safe and a one-day Time Travel maximum, temporary for session-scoped scratch, external and Iceberg for data living outside Snowflake's native storage. For warehouses, separate size (memory and local disk per cluster, the lever for a single heavy query) from multi-cluster (added clusters for concurrency). Learn the managed-AI shortcut: when a scenario wants a per-row score in SQL with no training or deployment, the answer is a Snowflake Cortex function, not Snowpark, a Notebook, or Streamlit in Snowflake. Read the explanation on every practice question, including the ones you got right.
Easy to confuse
- Transient table versus temporary table. A transient table persists across sessions and is visible to other users but has no Fail-safe and at most one day of Time Travel, so it suits low-cost staging data you can reload; a temporary table exists only for the session that created it and vanishes when that session ends, so it suits per-session scratch. Persistence and visibility are what separate them, not the storage saving alone.
- Scale up (larger warehouse size) versus scale out (multi-cluster warehouse). Scaling up to a larger size adds memory and local disk per cluster, which is what relieves a single heavy query that is spilling; scaling out to a multi-cluster warehouse adds whole clusters to serve more concurrent queries, which does nothing for one query running alone. Match size to query weight and clusters to concurrency.
Worked example from the COF-C03 bank
lock_openFree sampleSnowflake AI Data Cloud Features and Architecturemedium
An analyst has a table of free-text customer reviews and needs to derive a numeric sentiment score for each row using SQL, without training or deploying any model and without moving the data out of Snowflake. Which approach meets this requirement with the least setup?
- ABuild a Snowpark Python user-defined function that loads an external sentiment library at query time, because that is the supported managed path for scoring text per row in SQL
- BDeploy the reviews to a Streamlit in Snowflake application that classifies each row, because Streamlit is the managed feature that returns sentiment scores directly inside a SQL query
- CCall the built-in Snowflake Cortex SENTIMENT function inside a SQL query, because it returns a sentiment score per row from a managed model with no training or deployment requiredcheck_circle Correct
- DTrain a classification model in a Snowflake Notebook and register it as a stored procedure, because a trained model is required before any sentiment scoring can run in SQL
Recognise that the Snowflake Cortex SENTIMENT function scores text per row from SQL using a managed model with no training or deployment. Snowflake Cortex exposes managed AI functions, including SENTIMENT, that can be called directly in a SQL statement and run against a managed model inside Snowflake, so the analyst gets a per-row score without training, deploying, or exporting any data.
Why A is wrong: A Snowpark UDF can score text but requires writing code and packaging a library, so it is more setup than the built-in Cortex function and is not the least-effort path.
Why B is wrong: Streamlit in Snowflake builds interactive applications and cannot be invoked as a per-row scoring function inside a SQL query, so it does not fit this requirement.
Why C is correct: The Snowflake Cortex SENTIMENT function is a managed AI function callable from SQL that scores text per row, so it meets the requirement with no model training or deployment.
Why D is wrong: Training a model is unnecessary because Cortex offers a ready managed sentiment function, so this adds work the requirement explicitly rules out.
What you must be able to do. Given an access, governance, or cost-control requirement, choose the least-privilege role placement in the hierarchy, the right policy type, and the correct usage schema - granting object-creating roles under SYSADMIN, choosing a row access policy versus a masking policy by whether the requirement is about rows or column values, and querying ORGANIZATION_USAGE for cross-account roll-ups.
In one sentenceThe governance domain: role-based access control and the system role hierarchy, authentication and network security, masking and row access policies, tagging and auditing, and consumption monitoring through the usage schemas.
Recall check: answer these from memory first
- A new custom role must create and own databases and warehouses while a senior operations role above it can still manage everything it builds. Under which system role do you grant it, and why not ACCOUNTADMIN, SECURITYADMIN, or PUBLIC?
- Salesperson row visibility must track an ENTITLEMENTS table that changes often, with no policy edit per change. Which control and pattern deliver this, and why is a masking policy or a per-territory secure view wrong?
- Finance needs total credit and storage usage rolled up across every account in one organisation. Which schema exposes this, and why are ACCOUNT_USAGE and INFORMATION_SCHEMA too narrow?
What it tests. Governing a Snowflake account with least privilege and the right control. Explaining role-based access control: system-defined roles, custom roles, the hierarchy, securable objects, and grants, including that a custom object-creating role should be granted to SYSADMIN so the object-management branch stays intact, and that SECURITYADMIN manages grants while ACCOUNTADMIN sits at the top. Describing authentication and network security - multi-factor authentication, single sign-on, key-pair authentication, and network policies. Applying governance controls: dynamic data masking and column-level security transform what a column value shows, while a row access policy decides which rows appear and can join a mapping table so visibility tracks an external entitlements table without editing the policy. Using object tagging, data classification, access history, and object dependencies to govern and audit. Using resource monitors, budgets, and the ACCOUNT_USAGE and ORGANIZATION_USAGE schemas to monitor consumption, where ORGANIZATION_USAGE rolls up metering across every account in an organisation.
How to study it. Memorise the role hierarchy as a branch diagram and reason about it from least privilege. ACCOUNTADMIN is the top and is reserved; SECURITYADMIN manages users, roles, and grants; SYSADMIN owns the object-creation branch, so custom roles that build and own databases and warehouses are granted to SYSADMIN; ORGADMIN handles organisation-level work such as the Marketplace provider profile. Drill the policy split until it is automatic: if the requirement is about which rows are visible, it is a row access policy; if it is about how a column value appears, it is a masking policy, and tokenisation is for substituting stored values. Learn the mapping-table pattern - a row access policy body that joins an entitlements table evaluates per row at query time, so changing an assignment changes visibility with no policy edit. For consumption, separate the usage schemas by scope: INFORMATION_SCHEMA is one database, ACCOUNT_USAGE is one account, ORGANIZATION_USAGE rolls up across all accounts in the organisation. Practise picking resource monitors and budgets as the credit-control levers.
Easy to confuse
- Masking policy versus row access policy. A masking policy transforms how a column value appears - redacting or nulling it for some roles while the row itself stays in the result; a row access policy decides whether the whole row appears at all for the querying context. Column value visibility is the masking policy; row presence in the result set is the row access policy.
- SYSADMIN versus SECURITYADMIN. SYSADMIN owns the object-creation branch, so it creates and owns databases, schemas, and warehouses and is where custom object-creating roles are granted; SECURITYADMIN manages users, roles, and the grants between them but does not sit above object-owning roles in the standard hierarchy. Object ownership is SYSADMIN; grant administration is SECURITYADMIN.
Worked example from the COF-C03 bank
lock_openFree sampleAccount Management and Data Governancehard
A data steward must choose between a masking policy and a row access policy for several governance requirements on the same SALES table. For which TWO requirements is a row access policy, rather than a masking policy, the correct Snowflake control? Select TWO.
- AAn auditor role must be able to read full unmasked salary figures while every other role sees a redacted placeholder in that column.
- BEach regional manager must see only the order rows for the territory codes assigned to their role, with all other rows absent from the result set.check_circle Correct
- CRows for closed accounts must be suppressed from analyst queries while remaining queryable by the compliance role that the policy maps to those rows.check_circle Correct
- DCard numbers must be stored only as non-sensitive tokens, with the raw values held by an external provider and detokenised on demand for authorised roles.
Row access policies decide which rows appear per query, whereas masking policies transform column values and tokenisation substitutes stored values. A row access policy is evaluated for each row to keep or remove it based on the querying context, so requirements that turn on row visibility belong to it, while column transformation and stored-value substitution belong to masking policies and tokenisation respectively.
Why A is wrong: Tempting because access depends on the role, but transforming a single column's value while keeping every row is a masking policy task, not row filtering.
Why B is correct: Correct, because deciding which rows appear based on the querying context is exactly what a row access policy evaluates per row to permit or remove it.
Why C is correct: Correct, because conditionally including or excluding whole rows based on the active role and row data is the defining behaviour of a row access policy.
Why D is wrong: Tempting because it protects sensitive data, but this token-in, value-out pattern is external tokenisation invoked from a masking policy, not row filtering.
What you must be able to do. Given a load, unload, or connectivity need, pick the right stage, the COPY INTO option that meets a stated constraint, the in-load transformations COPY INTO actually supports, the right pipeline feature, and the correct connector or driver - for example the implicit table stage for files bound to one table, SINGLE = TRUE for one output file, and the Snowflake Connector for Python for programmatic access.
In one sentenceThe loading domain: internal and external stages, COPY INTO for bulk load and unload, the limited in-load transformations, continuous pipelines with Snowpipe, streams, tasks, and dynamic tables, and the connectors and drivers.
Recall check: answer these from memory first
- An engineer wants to stage local files for exactly one target table without creating any stage object. Which stage and reference syntax, and why is a user stage, a named stage, or an external stage wrong here?
- A downstream tool must ingest an unloaded result as a single object. Which COPY INTO location option guarantees one file, and why do MAX_FILE_SIZE and OVERWRITE not?
- Name two transformations COPY INTO supports during load and two it does not, and state where the unsupported ones must happen instead.
What it tests. Getting data in and out of Snowflake with the right mechanism. Describing internal stages (user as @~, table as @%table_name, and named) and external stages, and file format options for loading and unloading, including that the implicit table stage needs no CREATE STAGE and suits files bound to exactly one target table. Using COPY INTO to bulk load with validation, error handling, and the limited in-load transformations - column reordering, casting, and omission over the staged $n columns, but not joins, WHERE filtering, or aggregation. Unloading with COPY INTO location, where SINGLE = TRUE forces one output file instead of the default multiple, and choosing file format and compression. Building continuous pipelines with Snowpipe for micro-batch file ingestion, streams for change tracking, tasks for scheduling, and dynamic tables. Identifying connectors and drivers, including the Snowflake Connector for Python for a program that connects, runs SQL, and fetches rows, and the Kafka connector for streaming ingestion.
How to study it. Fix the stage decision first because it is a common trap: the implicit table stage at @%table_name needs no object and suits files for one table, the user stage at @~ is personal scratch, a named internal stage is reusable and shareable, and an external stage points at cloud storage you own. Drill the COPY INTO transformation limit as a hard boundary - it permits reordering, casting, and dropping staged columns through a simple SELECT over the $n positions, and explicitly excludes joins, WHERE, and GROUP BY, which must happen after load. Learn the unload options precisely: SINGLE = TRUE collapses output to one file, MAX_FILE_SIZE controls size, OVERWRITE controls replacement, and only SINGLE guarantees one object for a downstream single-read consumer. For pipelines, separate the roles cleanly: Snowpipe loads files as they arrive, a stream records what changed, a task schedules work, and a dynamic table declaratively maintains a transformed result. For programmatic access, the Snowflake Connector for Python is the client library; the Kafka connector is for streaming sources, not for fetching rows into a script.
Easy to confuse
- Snowpipe versus COPY INTO. COPY INTO is a bulk load you run on a virtual warehouse to ingest a defined set of staged files in one statement; Snowpipe is the serverless service that continuously loads new files in micro-batches as they land, billed per usage rather than on your warehouse. Choose COPY INTO for a known batch on demand, Snowpipe for ongoing automatic ingestion of arriving files.
- Table stage (@%table_name) versus named internal stage (@my_stage). A table stage is an implicit area Snowflake provides for every table with no CREATE STAGE step, scoped to loading that one table; a named internal stage is an object you create explicitly and can reuse across many tables and grant access to. For files tied to a single table with no setup, it is the table stage.
Worked example from the COF-C03 bank
lock_openFree sampleData Loading, Unloading, and Connectivitymedium
A team is loading a staged file whose columns do not line up with the target table and wants to apply transformations inside a single COPY INTO statement, without first staging the data into an intermediate table. Which TWO transformations are supported directly within COPY INTO during a load? Select TWO.
- AReordering and casting the staged source columns, for example selecting $3, $1 and CAST($2 AS NUMBER) so they map onto the target table columns.check_circle Correct
- BJoining the staged file to an existing dimension table inside the COPY INTO statement to enrich each row before it is loaded.
- COmitting an unwanted staged column from the load by simply not referencing it in the column list of the COPY INTO transformation.check_circle Correct
- DFiltering out rows with a WHERE clause and aggregating the survivors with GROUP BY inside the COPY INTO statement before loading.
COPY INTO supports simple in-load transformations such as column reordering, casting, and omission, but not joins, filtering, or aggregation. The COPY INTO transformation feature applies a limited SELECT over the staged $n columns, which permits reordering, casts, and dropping columns; it deliberately excludes joins to other tables, WHERE filtering, GROUP BY, and aggregate functions, which must be handled after loading.
Why A is correct: Correct: COPY INTO supports column reordering and simple casts on the staged $n columns within the SELECT-style transformation.
Why B is wrong: Tempting because joins are common in ELT, but COPY INTO transformations cannot join to other tables; only the staged data is referenced.
Why C is correct: Correct: COPY INTO lets you drop a source column by leaving it out of the projected column list, so only the wanted columns load.
Why D is wrong: Tempting because these are core SQL clauses, but COPY INTO does not support WHERE, GROUP BY, or aggregate functions during the load.
What you must be able to do. Given a slow query or a transformation need, read what Query Profile shows and pick the matching fix - scale up for spilling, the right cache, a materialized view, a clustering key, the search optimization service, or the query acceleration service - and write the correct SQL for semi-structured expansion such as LATERAL FLATTEN.
In one sentenceThe performance and querying domain: reading Query Profile, the three caches, the optimisation features, warehouse sizing and concurrency, SQL transformation, and querying semi-structured VARIANT data.
Recall check: answer these from memory first
- Query Profile shows large bytes spilled to local storage on a query running alone. Which single change removes the spilling, and why are a clustering key, a multi-cluster warehouse, and the result cache all wrong?
- An hourly dashboard reruns the same expensive aggregation over a slowly changing append-only table and wants always-current results with no refresh job. Which feature fits, and why not the result cache, a clustering key, or a task-rebuilt summary table?
- You must expand a VARIANT array into one row per element so its fields can be projected. Which construct does this and which column exposes each element, and why are SPLIT_TO_TABLE and OBJECT_KEYS wrong?
What it tests. Diagnosing performance and writing correct transformation SQL. Using Query Profile and query history to interpret performance, including reading bytes spilled to local and remote storage as a memory shortfall best fixed by a larger warehouse size. Explaining the caches - the result cache that returns a prior identical result, the metadata cache, and the warehouse local disk cache - and when each applies. Optimising with clustering keys for pruning, materialized views that Snowflake keeps current with serverless maintenance for repeated expensive aggregations, the search optimization service for highly selective point lookups and configured substring or full-text searches, and the query acceleration service for broad scans. Improving performance by sizing warehouses, scaling up versus out, and managing concurrency and queuing. Transforming data with aggregate functions, window functions, joins, and cardinality-estimation functions. Querying semi-structured data with VARIANT, OBJECT, and ARRAY, dot and bracket notation, and LATERAL FLATTEN to expand an array into one row per element exposed through the value column.
How to study it. Practise reading Query Profile like a diagnosis: spilled bytes mean the operators ran out of memory, so the fix is a larger size, never a clustering key, more clusters, or the result cache. Drill the optimisation-feature decisions as a four-way split - clustering key for range and pruning on a sort column, materialized view for a repeated expensive aggregation over a slowly changing table, search optimization service for selective equality and configured substring lookups, query acceleration service for broad scans - and learn which resource each trades (storage, serverless credits) for speed. Separate the caches by what they serve: the result cache returns an identical prior result with no compute, the local disk cache holds recently read micro-partitions on the warehouse, and the metadata cache serves statistics. Memorise that a materialized view is the always-current precomputed answer, unlike the result cache, a clustering key, or a task-rebuilt summary table. For semi-structured SQL, make LATERAL FLATTEN with the value column your reflex for one-row-per-array-element expansion, and reject SPLIT_TO_TABLE, ARRAY_AGG, and OBJECT_KEYS as the wrong tools.
Easy to confuse
- Result cache versus warehouse local disk cache. The result cache returns the entire result of an identical earlier query with no compute and lives in the cloud services layer, available across warehouses; the warehouse local disk cache holds recently read micro-partition data on a running warehouse and speeds re-reads of the same data within that warehouse, not whole-result reuse. One reuses a result, the other caches scanned data.
- Clustering key versus search optimization service. A clustering key physically co-locates data on a chosen column so range scans and pruning improve and is best for ordered or range access; the search optimization service maintains separate search access paths that accelerate highly selective point lookups and configured substring or full-text searches, and does not reorder the table. Range pruning is the clustering key; selective equality and text lookups are the search optimization service.
Worked example from the COF-C03 bank
lock_openFree samplePerformance Optimization, Querying, and Transformationhard
A platform engineer is deciding which query patterns the search optimization service will accelerate before enabling it on a large table. Which TWO query patterns does the search optimization service speed up? Select TWO.
- ABroad full-table scans that read most micro-partitions for a monthly aggregation, because the service rewrites the scan to read the whole table from serverless compute faster.
- BHighly selective equality predicates on a high-cardinality column, where each query returns only a handful of rows from a table holding hundreds of millions of rows.check_circle Correct
- CSubstring and regular-expression searches on text columns when the appropriate search method is configured, so selective pattern matches prune to the relevant micro-partitions.check_circle Correct
- DRange scans over an ordered date column for time-series reporting, because the service maintains a sorted physical layout that keeps recent dates co-located for fast ranges.
Identify that the search optimization service accelerates selective equality lookups and configured substring or full-text searches, not broad scans or range ordering. The search optimization service maintains a persistent set of search access paths that let highly selective point-lookup queries skip micro-partitions that cannot match, and it supports equality, in-list, substring and full-text search methods on suitable columns. It does not help broad scans, which suit the query acceleration service, and it does not physically order data for range pruning, which is the role of a clustering key.
Why A is wrong: Search optimization helps queries that touch a small fraction of rows, not broad scans that read most of the table, and it does not offload scans to serverless compute, so this confuses it with the query acceleration service.
Why B is correct: Selective equality and in-list lookups on high-cardinality columns are the core case the search optimization service is built for, pruning to the few micro-partitions that can match, which is exactly what the stem asks about.
Why C is correct: The service supports a substring and full-text search method in addition to equality, so configured pattern searches on text columns are accelerated, making this a correct supported pattern.
Why D is wrong: Maintaining a sorted physical layout for ranges is the job of a clustering key, not the search optimization service, which builds separate access paths and does not reorganise the table, so this attributes clustering behaviour to the wrong feature.
What you must be able to do. Given a sharing, recovery, or continuity requirement, choose the right collaboration feature - a reader account for a consumer with no Snowflake account, live in-place querying of a Marketplace listing with no storage cost, zero-copy cloning, Time Travel versus Fail-safe, and read-only secondary databases promoted through failover - and the role that performs provider setup.
In one sentenceThe collaboration domain: secure data sharing including reader accounts, the Snowflake Marketplace and Native Apps, zero-copy cloning, Time Travel and Fail-safe, and replication with failover and failback.
Recall check: answer these from memory first
- A partner with no Snowflake account and no plan to buy one must run live SQL against a share without the provider exporting files. Which mechanism delivers this, and who pays for the compute?
- A consumer obtains a free Marketplace listing. What storage does the shared data occupy in their account and what do they pay for, and why are COPY INTO loading and replication wrong descriptions?
- A developer's INSERT and UPDATE statements are rejected against a replicated secondary database. Why, and what single action would make it writable?
What it tests. Sharing, recovering, and protecting data without copying it needlessly. Describing secure data sharing - shares, providers and consumers, reader accounts, and what can be shared - including that a reader account created and paid for by the provider gives a consumer with no Snowflake account live SQL access. Using the Snowflake Marketplace, where a listing is queried live as a read-only shared database so the consumer stores no copy and pays only for their own compute, and the Native Apps Framework, with ORGADMIN performing the organisation-level provider setup. Using zero-copy cloning to duplicate objects with no extra storage until data diverges, Time Travel to query or restore data within a retention window, and Fail-safe as the non-configurable Snowflake-managed recovery period after Time Travel ends. Describing database and account replication and failover and failback, including that a secondary database is read-only and accepts writes only after being promoted to primary through failover.
How to study it. Drill the sharing decisions by who the consumer is: a direct share goes to another Snowflake account, a reader account is provisioned and paid for by the provider for a consumer with no account, and a Marketplace listing publishes to discoverable consumers who query it live. Fix the storage and billing fact - a listing or share is queried in place as a read-only shared database, so the consumer stores no copy and pays only for their own compute, never for storage or the provider's compute. Separate recovery clearly: Time Travel is the user-configurable window for querying, cloning, or restoring past data, and Fail-safe is the fixed seven-day Snowflake-managed period after Time Travel that only Snowflake can recover from, not you. Learn zero-copy cloning as instant duplication with no added storage until the clone diverges, the cheap answer when a scenario wants a copy for testing. For continuity, remember a secondary replicated database is read-only and writes are rejected regardless of privileges until failover promotes it to primary. Tie provider setup to ORGADMIN, not the account-scoped admin roles.
Easy to confuse
- Time Travel versus Fail-safe. Time Travel is a user-configurable retention window during which you can query, clone, or restore historical data yourself; Fail-safe is a fixed, non-configurable Snowflake-managed period after Time Travel ends from which only Snowflake support can recover data, at their discretion. You control and use Time Travel; you cannot query or configure Fail-safe.
- Direct secure share versus Snowflake Marketplace listing. A direct secure share targets a specific known consumer account by its locator and is mounted privately; a Marketplace listing publishes a data product so any eligible consumer can discover and obtain it, and provider setup is an organisation-level task done by ORGADMIN. Both query data live in place, but one is a private point-to-point grant and the other is a discoverable public or limited listing.
Worked example from the COF-C03 bank
lock_openFree sampleData Collaborationmedium
A provider wants to share a curated dataset with a business partner who does not have a Snowflake account and has no plan to buy one. The provider wants the partner to be able to run SQL queries against the shared data without the provider exporting files or standing up a separate database for them. Which approach lets the provider deliver this access?
- ACreate a reader account from the provider account and attach the share to it, so the partner queries the shared data through a Snowflake account the provider manages and pays forcheck_circle Correct
- BCreate a direct share and grant it to the partner's Snowflake account by its account locator, so the partner mounts the shared database immediately in their own existing account
- CUnload the dataset to an external stage as Parquet files and send the partner a signed URL, so they download the curated data and load it into their own analytics tooling
- DPublish the dataset as a public listing on the Snowflake Marketplace, so any partner can discover the data and consume it without the provider provisioning anything for them
Use a provider-managed reader account to give a consumer with no Snowflake account live SQL access to a share. A reader account is a Snowflake account created and paid for by the provider specifically so an organisation that does not have its own Snowflake account can log in and run queries against the share, with all compute billed back to the provider rather than the consumer.
Why A is correct: A reader account is provisioned and billed by the provider so a consumer with no Snowflake account can query the share directly, which is exactly the partner's situation.
Why B is wrong: A direct share to a consumer account requires the partner to already hold a Snowflake account, but the partner here has none, so there is no account locator to grant to.
Why C is wrong: Unloading to files is exactly the export the provider wants to avoid, and it produces a static copy rather than live queryable access to the shared data.
Why D is wrong: A Marketplace listing still requires the consumer to have a Snowflake account to get the data, so it does not serve a partner who has no account at all.