Snowflake uses both Discretionary Access Control (DAC) and Role-Based Access Control (RBAC) to

manage access control. DAC allows object owners to grant access privileges to other users. RBAC

assigns permissions to roles, and roles are then granted to users, making it easier to manage

permissions based on user roles within the organization.

Snowflake Documentation: Access Control in Snowflake

Snowflake supports a variety of file formats for unloading semi-structured data, among which

Parquet and Newline Delimited JSON (NDJSON) are two widely used formats.

B . Binary file in Parquet: Parquet is a columnar storage file format optimized for large-scale data

processing and analysis. It is especially suited for complex nested data structures.

D . Newline Delimited JSON (NDJSON): This format represents JSON records separated by newline

characters, facilitating the storage and processing of multiple, separate JSON objects in a single file.

These formats are chosen for their efficiency and compatibility with data analytics tools and

ecosystems, enabling seamless integration and processing of exported data.

Snowflake Documentation: Data Unloading

In Snowflake, the CONNECT BY clause allows users to perform recursive queries. Recursive queries

are used to process hierarchical or tree-structured data, such as organizational charts or file systems.

The CONNECT BY clause is used in conjunction with the START WITH clause to specify the starting

point of the hierarchy and the relationship between parent and child rows.

Snowflake Documentation: Hierarchical Queries

Snowflake's Data Exchange allows users to create and manage a group of accounts to which they can

offer data shares. This platform facilitates secure and governed data sharing within and between

organizations.

Data Exchange Setup: Users can set up a Data Exchange and invite other Snowflake accounts to join.

Sharing Data: Within the Data Exchange, users can offer shares to the entire group or to specific

accounts.

Governance and Security: Data Exchange provides tools for data governance and security, ensuring

that shared data is only accessible to authorized accounts.

Snowflake Documentation: Snowflake Data Exchange

Snowflake Documentation: Managing a Data Exchange

In the provided exhibit, Warehouse 2 is under Resource Monitor 2, which has a credit quota of 1000

credits. However, it's important to note that warehouses can also draw from the account-level

resource monitor if they consume their dedicated monitor's quota. In this exhibit, Resource Monitor

1 is set for the account with a credit quota of 500 credits.

The exhibit does not clearly show whether Warehouse 2 is also subject to the account-level Resource

Monitor 1, but if we assume the typical case where all warehouses can draw from the account-level

monitor, the maximum limit of credits Warehouse 2 can consume would be the sum of its dedicated

resource monitor (Resource Monitor 2) and the account-level resource monitor (Resource Monitor

1).

Thus, Warehouse 2 can consume:

1000 credits from Resource Monitor 2

500 credits from Resource Monitor 1 (if applicable)

This gives a total of 1500 credits. Therefore, the maximum credit limit that Warehouse 2 can

consume, taking into account the possibility of the account-level monitor's contribution, would be

1500 credits.

However, without explicit confirmation that Warehouse 2 can use credits from Resource Monitor 1,

one would default to the specific resource monitor assigned to the warehouse, which is 1000 credits.

Given the available options, the closest and most accurate answer is B. 1500, as it represents the sum

of credits from both monitors that potentially apply to Warehouse 2.

Snowflake Documentation on Resource Monitors: Managing Resource Monitors

The Fail-safe period for a transient table in Snowflake, regardless of the edition (including Enterprise

edition and higher), is 0 days. Fail-safe is a data protection feature that provides additional retention

beyond the Time Travel period for recovering data in case of accidental deletion or corruption.

However, transient tables are designed for temporary or short-term use and do not benefit from the

Fail-safe feature, meaning that once their Time Travel period expires, data cannot be recovered.

Snowflake Documentation: Understanding Fail-safe

A materialized view in Snowflake is a database object derived from a query specification, stored for

later use, and can significantly speed up expensive aggregations on large data sets. Materialized

views store the result of their underlying query, reducing the need to recompute the result each time

the view is accessed. This makes them ideal for improving the performance of read-heavy,

aggregate-intensive queries.

Snowflake Documentation: Using Materialized Views

In Snowflake, SAMPLE (5 ROWS) ensures an exact count of 5 rows is returned from MY_TABLE,

regardless of table size. This is different from SAMPLE SYSTEM or SAMPLE BERNOULLI, which use

percentage-based sampling, potentially returning varying row counts based on probabilistic

methods.

The ROWS option is deterministic and does not depend on percentage, making it ideal when an exact

row count is required.

Snowflake does not require source data files to be no larger than 16MB. In fact, Snowflake

recommends that for optimal load performance, data files should be roughly 100-250 MB in size

when compressed. However, it is not recommended to load very large files (e.g., 100 GB or larger)

due to potential delays and wasted credits if errors occur. Smaller files should be aggregated to

minimize processing overhead, and larger files should be split to distribute the load among compute

resources in an active warehouse.

Preparing your data files | Snowflake Documentation

Snowflake’s architecture allows for the use of a query result cache that stores the results of queries

for a period of time. If the same query is run again and the underlying data has not changed,

Snowflake can retrieve the result from this cache without needing to re-run the query on an active

warehouse, thus saving on compute resources.