DAA-C01 SnowPro Advanced: Data Analyst Exam Questions and Answers

One of the standout features of the Snowsight interface is its ability to perform automatic Data Profiling. When a Data Analyst executes a query, Snowflake doesn't just return a raw grid of data; it analyzes the result set to provide immediate visual insights.

When you click on a column header in the results pane, a summary statistics panel appears. For numeric, date, and time columns, Snowflake automatically generates a histogram (Option A). This histogram provides a visual representation of the data distribution, allowing the analyst to quickly identify patterns, concentrations of values, or significant outliers without writing additional SQL code.

Evaluating the Options:

Option B: While a histogram is a type of frequency distribution, Option A is more accurate because Snowsight also provides these visualizations for date and time types, not just integers/floats.

Option C: While MIN and MAX values are displayed in the summary panel, they are text-based statistics, not the "visualized" contextual statistic (the histogram) emphasized in the question.

Option D: "Key distribution" is not a standard visualization term used in the Snowsight profiling tool.

Option A: Is the 100% correct answer. It highlights the breadth of the profiling tool (covering numbers, dates, and times) and the specific visual element (the histogram) that makes exploratory data analysis significantly faster for a Data Analyst.

Snowflake Cortex ML functions, such as the Forecasting and Anomaly Detection models, are designed to be "black boxes" that provide automated machine learning capabilities directly within SQL. However, for a Data Analyst to trust and validate these models, Snowflake provides specific Object Methods (invoked with the ! operator) to inspect the model's internal logic and performance.

The !EXPLAIN_FEATURE_IMPORTANCE() method is specifically designed to provide transparency into how the model reached its conclusions. When invoked on a trained forecast model, it returns a result set showing which features (such as exogenous variables or time-based components like seasonality and trend) had the most significant impact on the predicted values. This is a critical step in the Data Analysis workflow to ensure that the model is not relying on "noise" or irrelevant data points.

Evaluating the Options:

Option A (SHOW_EVALUATION_METRICS) is used to retrieve accuracy statistics like MSE (Mean Squared Error) or MAPE (Mean Absolute Percentage Error) from the training phase, but it does not explain the contribution of specific features.

Option B (SHOW_TRAINING_LOGS) is not a standard Cortex ML method; logging details are typically handled internally or through different system views.

Option D (FORECAST) is the primary method used to actually generate the future predictions once the model is trained; it outputs the forecast itself, not the underlying component importance.

Option C is the correct answer as it is the dedicated method for model interpretability, allowing analysts to see the "why" behind the forecast by quantifying the influence of each input variable. This aligns with Snowflake's focus on "Explainable AI" within the Data Cloud.

The ANY_VALUE function is an aggregate function used in Snowflake to bypass the requirement that all non-aggregated columns in a SELECT list must appear in the GROUP BY clause. In the provided query, the data is grouped by customer.id. Standard SQL would require customer.name to also be in the GROUP BY clause, even if every ID only has one name associated with it.

By using ANY_VALUE(customer.name), the analyst tells Snowflake to simply pick a value from the group. The core characteristic of this function is that it is non-deterministic. This means that if there are multiple different names for a single customer.id, Snowflake does not guarantee which one will be returned; it returns "any" value it finds most efficient to retrieve during processing. In most data modeling scenarios where a 1:1 relationship exists between an ID and a Name, ANY_VALUE is a performance-optimized alternative to using MIN() or MAX(), as it requires less computational overhead to identify a single representative value.

Evaluating the Options:

Option A is incorrect because ANY_VALUE only returns NULL if all values in the group are NULL.

Option C is incorrect because it describes the MIN() function, which is deterministic.

Option D is incorrect as it describes a median calculation (like MEDIAN()), which is a specific mathematical operation, not a "pick any" operation.

Option B is the 100% correct answer. It accurately defines the function's purpose: returning an arbitrary value from the group, acknowledging that the specific result is non-deterministic.

When dealing with massive datasets containing billions of rows, efficiency is paramount. Snowflake provides two primary ways to retrieve a small subset of data: Sampling and Result Set Limiting.

The SAMPLE clause is used to return a subset of rows based on a specific count or percentage. The correct syntax for specifying a fixed number of rows is SAMPLE ( ROWS). This is highly effective for exploratory data analysis where you need to see the shape of the data without the overhead of scanning the entire table. It is important to note that SAMPLE does not guarantee a truly random distribution unless specified, but it is much faster than a full table scan.

The TOP <n> or LIMIT <n> clauses are used to restrict the number of rows returned in the output. The TOP syntax is commonly used in many SQL dialects and is fully supported in Snowflake to return the first "n" rows the query engine encounters. While TOP is often used with an ORDER BY clause to get the highest or lowest values, using it alone on a massive table like FCT_SALES is a standard way to quickly peak at the data.

Evaluating the Options:

Option A is incorrect syntax; the ROWS keyword and parentheses are required for a fixed count.

Option B is Correct; it uses the standard Snowflake SAMPLE syntax for a specific row count.

Option C and Option E are incorrect because ROWS is not a valid keyword within a TOP clause in Snowflake.

Option D is Correct; it uses the standard TOP syntax to limit the result set.

By using these methods, a Data Analyst ensures they are not wasting compute resources (Credits) by pulling billions of unnecessary rows into the UI or a local environment.

Working with nested semi-structured data requires a deep understanding of Snowflake's FLATTEN function and path notation. In the provided JSON exhibit, the data is hierarchical: the root contains a key named "events", which is an array containing multiple objects. Each object within that array contains the target field "f".

To transform this into a "consumable, tabular format" where each instance of "f" appears as a separate row, the Data Analyst must "explode" the array. Simply using path notation like data:events:f (Option A) will fail or return NULL because the engine cannot directly map a single path through an array structure to multiple scalar results without an explicit relational transformation.

The LATERAL FLATTEN function is the standard tool for this task. It takes a semi-structured column (or a specific path within it) as an input and returns a relational result set. By specifying input => data:events, the Analyst instructs Snowflake to look specifically at the array. For every element found in that array, FLATTEN generates a new row in the result set. The output of the flatten operation includes a column named VALUE, which represents the specific element (in this case, an object) currently being processed.

Evaluating the Options:

Option A and C are incorrect because they attempt to use direct pathing on an array. Without flattening, the query engine sees the array as a single block of data and cannot reach the "f" key inside individual array elements.

Option B is incorrect because it flattens the root data object. While this works for top-level keys, it wouldn't automatically iterate through the "events" array to expose the "f" values inside it; it would treat the entire array as a single value.

Option D is the 100% correct answer. It correctly targets the "events" array for flattening and then utilizes path notation (value:f) followed by the appropriate type casting (::number) to produce the final tabular output. This is a core competency for any SnowPro Advanced Data Analyst handling modern telemetry or event-based data.

Understanding how Snowflake aggregate functions like MIN() and MAX() handle numerical data and NULL values is fundamental for accurate Data Analysis. In this scenario, we have a table with five records distributed across two departments.

The MIN() function returns the smallest non-null value in the specified column across all rows in the group (or the entire table, if no GROUP BY is present). Looking at the salary column in the employees table, the values are: 10000, 9000, 8000, 15000, and NULL. The NULL value is ignored by the calculation. Among the remaining numerical values, 8000 is the smallest. Therefore, MIN_VAL will be 8000.

The MAX() function operates similarly, returning the largest non-null value from the set. Comparing the same list of numerical values—10000, 9000, 8000, and 15000—the largest value is clearly 15000. Consequently, MAX_VAL will be 15000.

Evaluating the Options based on the exhibit (image_8ca0df.png):

Option A incorrectly identifies the minimum and maximum based on the employee_id column (where 2000 is max and 900 is min), rather than the requested salary column.

Option B is incorrect as it seems to mix values from different columns or specific rows.

Option C is incorrect because it mistakenly suggests that MIN() returns NULL if a NULL value is present in the column. In Snowflake, standard aggregate functions (except for specialized ones like ARRAY_AGG or certain window functions with specific clauses) skip NULL values entirely.

Option D is the 100% correct output. It displays MIN_VAL as 8000 and MAX_VAL as 15000, which accurately reflects the mathematical minimum and maximum of the non-null entries in the salary column.

This behavior is consistent across all relational databases adhering to ANSI SQL standards, which Snowflake follows for these core aggregate operations.

To achieve the desired result, an analyst must understand the fundamental behavior of different JOIN types within Snowflake and how they affect the retention of records from the "left" or primary table. The goal here is to list all brokers, even those who have zero customers (like "Drew") or customers with zero orders (like "Debby").

In SQL, an INNER JOIN only returns rows when there is a match in both tables. If we were to use an INNER JOIN between BROKER and CUSTOMER, Drew would be excluded from the results because he has no associated records in the CUSTOMER table. Similarly, an INNER JOIN with the ORDERS table would exclude any broker whose customers haven't placed an order.

Evaluating the Join Logic:

Option C is the correct solution because it utilizes a chain of LEFT JOINs. A LEFT JOIN (or LEFT OUTER JOIN) ensures that every record from the left table (BROKER) is preserved in the result set. If no matching record exists in the joined table (CUSTOMER or ORDERS), Snowflake populates the columns with NULL. This is why "Drew" appears with a CUST_COUNT of 0 and "Debby" appears with a NULL for the total order amount.

Option A fails because it uses an INNER JOIN for the CUSTOMER table, which would immediately filter out "Drew."

Option B and Option D fail because they use INNER JOINs at different stages of the query, which would strip away brokers or customers that do not have matching order activity.

Additionally, the query correctly uses COUNT(DISTINCT c.customer_id) to ensure that customers are not double-counted if they have multiple orders, and GROUP BY 1 (referencing b.broker_name) to aggregate the data at the broker level. This pattern is essential for accurate Data Analysis in Snowflake when dealing with "optional" relationships in a star or snowflake schema.

In Snowflake, "spilling" occurs when the intermediate data required to process a query exceeds the available memory (RAM) of the virtual warehouse. When this happens, Snowflake "spills" the data first to the warehouse's local SSD and, if that fills up, to remote storage (e.g., S3 or Azure Blob). This significantly degrades performance due to increased I/O latency.

To resolve this without increasing costs (i.e., without scaling up to a larger warehouse size), an analyst must reduce the memory footprint of the query.

CTEs vs. Temporary Tables: While Common Table Expressions (CTEs) are excellent for readability, they are often treated as logical entities that the optimizer may re-evaluate multiple times or struggle to keep in memory during massive joins.

Batch Processing: By splitting a single monolithic query into multiple steps and storing intermediate results in temporary tables, the analyst forces the engine to clear its memory between steps. This process acts as a "checkpoint," effectively processing the data in smaller, more manageable batches that fit within the current warehouse's memory limits.

Evaluating the Options:

Option A is incorrect because spilling is a compute-resource issue, not a storage-lock or contention issue.

Option B is incorrect because materialized views and clustering incur background credit costs for maintenance, violating the "without increasing costs" constraint.

Option C is incorrect because external tables are generally slower than native Snowflake tables due to the lack of proprietary metadata and micro-partitioning.

To determine the correct output, a Data Analyst must understand the behavior of the STRTOK_SPLIT_TO_TABLE table function and how it interacts with different delimiters.

1. Functionality of STRTOK_SPLIT_TO_TABLE:

The STRTOK_SPLIT_TO_TABLE function tokenizes a string based on a set of specified delimiters. Unlike simple SPLIT functions that often look for a literal string as a delimiter, STRTOK treats the delimiter string as a set of individual characters. Any character present in the delimiter string will trigger a split. Crucially, it skips empty tokens—if multiple delimiters appear consecutively, it does not produce a row for the space between them.

2. Evaluating the Data and Delimiters ('*-'):

'JOHN*DOE': The * character is a delimiter. This results in two tokens: JOHN and DOE.

'ALICE-SMITH': The - character is a delimiter. This results in two tokens: ALICE and SMITH.

'BOB*-JOHNSON': Both * and - are delimiters. Because they appear consecutively (*-), the function splits at each but ignores the empty space between them. This results in two tokens: BOB and JOHNSON.

3. Analyzing the Resulting Rows:

The LATERAL join produces a row for every token generated. The columns SEQ (identifying the source row sequence) and INDEX (position of the token within that sequence) are used for sorting.

Student 1: 2 tokens (JOHN, DOE) $\rightarrow$ 2 rows.

Student 2: 2 tokens (ALICE, SMITH) $\rightarrow$ 2 rows.

Student 3: 2 tokens (BOB, JOHNSON) $\rightarrow$ 2 rows.

Evaluating the Options (image_8233d8.png):

Option A incorrectly only shows results for Student 3.

Option C incorrectly implies Student 1 and 2 produce three tokens each.

Option D incorrectly interprets the consecutive delimiters in Student 3's name as creating a different sequence count.

Option B is the 100% correct result set. It accurately shows that each student’s name is split into exactly two parts, properly handling the varying delimiters and the consecutive characters in the third record.

In statistical analysis, when you want to measure the strength and direction of a relationship between two continuous variables, you use Correlation. The CORR() function in Snowflake calculates the Pearson product-moment correlation coefficient for a set of pairs.

The correlation coefficient ranges from -1 to +1:

A result near +1 indicates a strong positive relationship (both variables increase together).

A result near -1 indicates a strong negative (inverse) relationship, which is exactly what the analyst is looking for: as the number of active drivers increases, the waiting time decreases.

A result near 0 indicates no linear relationship.

Evaluating the Options:

Option A only provides the sum of one variable and the variance (spread) of another. It does not show how they move together.

Option B is incorrect because VARIANCE() is a univariate function (takes one argument) measuring data dispersion; it cannot compare two variables.

Option C provides descriptive statistics for each variable independently but does not quantify the relationship between them.

Option D is the 100% correct answer. By calculating the CORR(), the analyst will get a single value for each city that proves (or disproves) the hypothesis that more drivers lead to shorter wait times. This is a vital skill for the Data Analysis domain, specifically for performing bivariate statistical analysis.

In the Snowflake data loading hierarchy, understanding the order of precedence for file format options is critical for troubleshooting and automation. Snowflake allows you to define file format options (such as CSV delimiter, header settings, or compression type) at multiple levels: as a standalone named File Format object, within a Stage definition, or directly inside a COPY INTO statement.

When data is loaded, Snowflake evaluates these definitions based on a specific override logic. The COPY INTO statement sits at the top of this hierarchy. This means that any file format options or named file formats explicitly called out in the COPY INTO command will override any conflicting settings defined at the stage or table level. For example, if a stage is defined to expect comma-separated files, but the COPY INTO command specifies a pipe delimiter, Snowflake will use the pipe delimiter for that specific load operation.

Evaluating the Options:

Options A, B, and C are incorrect because while they provide default behaviors for specific objects or namespaces, they are considered "lower-level" configurations.

Option D is the 100% correct answer. The COPY INTO statement provides the final, explicit instruction to the query engine. This design allows Data Analysts to use general-purpose stages for various file types by simply specifying the unique format requirements at the time of the execution, providing maximum flexibility in the Data Ingestion workflow.

Calculating a moving average (or rolling average) is a standard time-series analysis technique used to smooth out short-term fluctuations and highlight longer-term trends. In Snowflake, this is accomplished using Window Functions and the ROWS framing clause.

To calculate a 7-day moving average when you have one record per day, the "window" or "frame" must encompass exactly 7 rows. In SQL windowing syntax, the CURRENT ROW counts as one of those days. Therefore, to reach a total of 7, you need to look back at the 6 preceding rows ($6 + 1 = 7$).

Evaluating the Options:

Options A and B use the SUM() function. While the sum is part of an average, the question specifically asks for the average itself.

Option D is incorrect because 7 PRECEDING AND CURRENT ROW actually creates an 8-day window (the current day plus the seven days before it).

Option C is the 100% correct answer. It uses the AVG() aggregate function and correctly defines the frame as 6 PRECEDING AND CURRENT ROW, ensuring the calculation reflects exactly one week of data including the current day.

This scenario highlights the rules governing Shared Databases and Cross-Database Joins in Snowflake. When a user acquires data from the Snowflake Marketplace, it arrives in their account as a "Shared Database."

A critical restriction of shared databases is that they are read-only. Users (including Data Analysts and even AccountAdmins) cannot create new objects—such as tables, schemas, or views—directly inside a database created from a share. Therefore, Options A, C, and D are architecturally impossible because they all involve trying to write a new view into the ADDRESS_DATA database.

To combine the shared data with internal data (like the ORDERS table in GLOBAL_DWH), the Analyst must create the view in a database where they have CREATE VIEW privileges and that is writeable. Since GLOBAL_DWH is an internal database owned by the organization, it is the appropriate location to host the logic that joins local data with external enrichment data.

Evaluating the Options:

Option A and C are incorrect because you cannot create objects in a database created from a share.

Option D is incorrect because while IMPORTED_PRIVILEGES are necessary to view the data, they do not grant the ability to create objects within the share.

Option B is the 100% correct answer. By creating the view in the GLOBAL_DWH database (or any other local, non-shared database), the Analyst can successfully reference ADDRESS_DATA.OPENADDRESS and GLOBAL_DWH.PUBLIC.ORDERS in a single SQL statement, effectively creating an enriched data layer for the organization.

Descriptive analytics is the process of using historical data to understand "what happened." This typically involves summarizing large datasets into interpretable chunks using central tendency, dispersion, and frequency measures.

AVG (Average) is a cornerstone of descriptive statistics. It provides the arithmetic mean of a numeric column, allowing an analyst to understand the "typical" value within a dataset (e.g., Average Order Value).

APPROX_COUNT_DISTINCT is a descriptive tool used to understand the volume of unique entities within a dataset (e.g., "How many unique customers visited the site?"). Similar to HLL mentioned earlier, this function provides a fast summary of data volume and variety, which is a primary goal of the descriptive phase of analysis.

Evaluating the Options:

Options A and B (REGR_INTERCEPT and REGR_SLOPE) are used for linear regression. These fall under Predictive Analytics, as they are used to model relationships and predict future outcomes, rather than just describing current data.

Option C (ROW_NUMBER) is a window function used for data ranking and ordering, but it does not provide a descriptive summary of the dataset's characteristics.

Options D and E are correct because they provide summary statistics (mean and cardinality) that define the "state" of the data, which is the definition of descriptive analytics.

To achieve the desired result, an analyst must understand the fundamental behavior of different JOIN types within Snowflake and how they affect the retention of records from the "left" or primary table. The goal here is to list all brokers, even those who have zero customers (like "Drew") or customers with zero orders (like "Debby").

In SQL, an INNER JOIN only returns rows when there is a match in both tables. If we were to use an INNER JOIN between BROKER and CUSTOMER, Drew would be excluded from the results because he has no associated records in the CUSTOMER table. Similarly, an INNER JOIN with the ORDERS table would exclude any broker whose customers haven't placed an order.

Evaluating the Join Logic:

Option C is the correct solution because it utilizes a chain of LEFT JOINs. A LEFT JOIN (or LEFT OUTER JOIN) ensures that every record from the left table (BROKER) is preserved in the result set. If no matching record exists in the joined table (CUSTOMER or ORDERS), Snowflake populates the columns with NULL. This is why "Drew" appears with a CUST_COUNT of 0 and "Debby" appears with a NULL for the total order amount.

Option A fails because it uses an INNER JOIN for the CUSTOMER table, which would immediately filter out "Drew."

Option B and Option D fail because they use INNER JOINs at different stages of the query, which would strip away brokers or customers that do not have matching order activity.

Additionally, the query correctly uses COUNT(DISTINCT c.customer_id) to ensure that customers are not double-counted if they have multiple orders, and GROUP BY 1 (referencing b.broker_name) to aggregate the data at the broker level. This pattern is essential for accurate Data Analysis in Snowflake when dealing with "optional" relationships in a star or snowflake schema.

The INFER_SCHEMA function is a powerful tool in the Snowflake ingestion toolkit, specifically designed to bridge the gap between semi-structured data and relational tables. In modern data engineering, files like Parquet, Avro, and ORC are "self-describing," meaning they contain their own schema definitions (field names and data types) within the file header.

Before INFER_SCHEMA existed, a Data Analyst had to manually inspect a Parquet file, identify the keys, determine their data types, and then manually write a CREATE TABLE statement with the matching columns. INFER_SCHEMA automates this by scanning a set of files in a stage and returning a result set that describes the detected schema. This allows for the dynamic creation of tables that perfectly match the incoming data files.

Evaluating the Options:

Option A is incorrect because "unstructured data" (like PDFs or Images) does not have a schema that can be "inferred" in a relational sense.

Option C is incorrect because INFER_SCHEMA operates on files in a Stage, not on data already sitting in a table cell. To parse JSON in a table, you would use functions like FLATTEN or simple path notation.

Option D is incorrect because the DESCRIBE TABLE or GET_DDL commands are used to retrieve definitions for existing tables.

Option B is the Correct answer. It specifically identifies the role of the function: detecting metadata (schema) from staged semi-structured files. This function is often used in conjunction with GENERATE_COLUMN_DESCRIPTION and CREATE TABLE ... USING TEMPLATE to fully automate the schema evolution and ingestion process.