{"id":21912,"date":"2026-09-25T10:03:51","date_gmt":"2026-09-25T10:03:51","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=21912"},"modified":"2026-09-25T10:03:51","modified_gmt":"2026-09-25T10:03:51","slug":"snowflake-snowpro-advanced-data-engineer-practice-test-questions-and-exam-dumps-part5-q81-100","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/snowflake-snowpro-advanced-data-engineer-practice-test-questions-and-exam-dumps-part5-q81-100\/","title":{"rendered":"Snowflake SnowPro Advanced Data Engineer Practice Test Questions and Exam Dumps Part5 Q81-100"},"content":{"rendered":"

View Full <\/b>Snowflake SnowPro Advanced Data Engineer Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 81<\/b><\/h3>\n

Which stream type tracks only inserted rows?<\/b><\/p>\n

    \n
  1. Standard stream<\/span><\/li>\n
  2. Append-only stream<\/span><\/li>\n
  3. Update stream<\/span><\/li>\n
  4. Change-table stream<\/span><\/li>\n<\/ol>\n

    Correct Answer: 2<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    An append-only stream in Snowflake tracks newly inserted rows without recording updates or deletes. This makes it useful for ingestion pipelines where source data is continuously appended and existing records are not modified. Compared with a standard stream, append-only streams can reduce change-tracking requirements for workloads focused exclusively on new records. Data engineers commonly use them with tasks to process incremental arrivals efficiently. Choosing the appropriate stream type depends on whether downstream processing needs inserts only or must also identify changes caused by updates and deletions.<\/span><\/p>\n

    Question 82<\/b><\/h3>\n

    Which function checks whether a stream contains change data?<\/b><\/p>\n

      \n
    1. SYSTEM$STREAM_STATUS<\/span><\/li>\n
    2. SYSTEM$CHECK_STREAM<\/span><\/li>\n
    3. SYSTEM$STREAM_HAS_DATA<\/span><\/li>\n
    4. SYSTEM$DATA_CHANGED<\/span><\/li>\n<\/ol>\n

      Correct Answer: 3<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      SYSTEM$STREAM_HAS_DATA determines whether a specified stream contains change data that can be consumed. It is particularly useful in task definitions because a task can use the function in a WHEN condition to avoid unnecessary execution when no new changes exist. This pattern helps build event-driven incremental pipelines. Instead of running a transformation on every scheduled interval, the task can execute only when the stream indicates available changes. This reduces unnecessary compute usage and keeps downstream processing focused on actual source activity.<\/span><\/p>\n

      Question 83<\/b><\/h3>\n

      What happens when a stream becomes stale?<\/b><\/p>\n

        \n
      1. Its unread changes become unavailable<\/span><\/li>\n
      2. Its table automatically becomes cloned<\/span><\/li>\n
      3. Its records move into Fail-safe<\/span><\/li>\n
      4. Its definition converts into a view<\/span><\/li>\n<\/ol>\n

        Correct Answer: 1<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        A Snowflake stream can become stale when its offset cannot be advanced within the applicable data-retention period. Once stale, the stream can no longer provide the expected historical change records that were waiting to be consumed. Downstream processing therefore cannot rely on the unavailable changes and may require reinitialization or another recovery approach. Data engineers should consume streams regularly or design pipelines that prevent excessive delays. Monitoring task execution, stream consumption, and retention settings helps reduce the possibility of losing the incremental change information represented by an outdated stream.<\/span><\/p>\n

        Question 84<\/b><\/h3>\n

        Which setting lets a task run only when a condition evaluates true?<\/b><\/p>\n

          \n
        1. EXECUTE IF<\/span><\/li>\n
        2. RUN WHEN<\/span><\/li>\n
        3. WHEN<\/span><\/li>\n
        4. START CONDITION<\/span><\/li>\n<\/ol>\n

          Correct Answer: 3<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          The WHEN clause in a Snowflake task defines a Boolean condition that must evaluate to true before the task runs. It is commonly combined with system functions such as SYSTEM$STREAM_HAS_DATA for event-driven processing. For example, a scheduled task can check whether a stream contains changes and execute its SQL only when new data is available. This design avoids unnecessary transformations during idle periods. The WHEN condition is therefore useful for coordinating efficient incremental pipelines where execution should depend on the current state of upstream data.<\/span><\/p>\n

          Question 85<\/b><\/h3>\n

          Which task configuration uses Snowflake-managed compute?<\/b><\/p>\n

            \n
          1. Serverless task execution<\/span><\/li>\n
          2. Dedicated warehouse binding<\/span><\/li>\n
          3. Manual cluster assignment<\/span><\/li>\n
          4. User-managed compute pool<\/span><\/li>\n<\/ol>\n

            Correct Answer: 1<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            Serverless tasks use Snowflake-managed compute rather than requiring the task definition to reference a user-managed virtual warehouse. Snowflake determines the resources needed for execution based on the task workload and service behavior. This can simplify operational management because engineers do not need to maintain a dedicated warehouse for each serverless task. Serverless execution is especially useful for intermittent workloads where maintaining a continuously available warehouse would be unnecessary. Task design should still consider execution frequency, workload size, and resource consumption when selecting between serverless and warehouse-based execution.<\/span><\/p>\n

            Question 86<\/b><\/h3>\n

            Which clause defines a recurring task execution interval?<\/b><\/p>\n

              \n
            1. INTERVAL<\/span><\/li>\n
            2. SCHEDULE<\/span><\/li>\n
            3. FREQUENCY<\/span><\/li>\n
            4. RUN_PERIOD<\/span><\/li>\n<\/ol>\n

              Correct Answer: 2<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              The SCHEDULE clause specifies when a Snowflake task should execute. A schedule can define recurring execution using a time interval or a cron expression, depending on the required orchestration pattern. This allows engineers to automate ingestion, transformation, validation, or maintenance activities without manually starting each run. Scheduling can also be combined with a WHEN condition, allowing the task to check whether processing is actually necessary before execution. Proper scheduling is important for maintaining predictable pipeline behavior while avoiding excessive task invocations.<\/span><\/p>\n

              Question 87<\/b><\/h3>\n

              Which option allows a task to execute without a warehouse?<\/b><\/p>\n

                \n
              1. Explicit warehouse assignment<\/span><\/li>\n
              2. Multi-cluster warehouse<\/span><\/li>\n
              3. Serverless compute<\/span><\/li>\n
              4. Dedicated compute tier<\/span><\/li>\n<\/ol>\n

                Correct Answer: 3<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                Serverless compute allows eligible Snowflake tasks to execute without specifying a user-managed virtual warehouse. Snowflake manages the underlying compute resources for the task. This model is useful for automated workloads where engineers prefer not to provision and maintain warehouse resources specifically for task execution. A task using serverless compute can still have scheduling and conditional execution logic. The choice between serverless execution and a user-managed warehouse depends on workload characteristics, operational preferences, and resource-management requirements.<\/span><\/p>\n

                Question 88<\/b><\/h3>\n

                What does EXECUTE AS OWNER provide for a stored procedure?<\/b><\/p>\n

                  \n
                1. Invoker-based privileges<\/span><\/li>\n
                2. Owner-context privileges<\/span><\/li>\n
                3. Session-only authorization<\/span><\/li>\n
                4. Role-selection prompts<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  EXECUTE AS OWNER causes a stored procedure to execute using the privileges associated with its owning role rather than the caller’s active privileges. This model can be useful when a controlled procedure should perform operations that callers themselves do not directly have permission to execute. Security-sensitive procedures should be designed carefully because owner rights can provide broader access than the invoking user possesses. Developers should limit procedure functionality, protect sensitive operations, and understand exactly which privileges are available through the owning role.<\/span><\/p>\n

                  Question 89<\/b><\/h3>\n

                  What is the primary output of a user-defined function?<\/b><\/p>\n

                    \n
                  1. Warehouse configuration<\/span><\/li>\n
                  2. Task dependency graph<\/span><\/li>\n
                  3. Stage file listing<\/span><\/li>\n
                  4. Computed value<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 4<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    A user-defined function, or UDF, is designed to accept inputs and return a computed value. UDFs are useful for encapsulating reusable business logic that can be invoked within SQL expressions. They differ from stored procedures, which are generally intended for procedural operations and can perform broader workflow activities. Data engineers can use UDFs to standardize calculations, transformations, or reusable expressions across queries. Selecting a UDF is appropriate when the requirement centers on producing a value from supplied arguments rather than orchestrating a multi-step operational process.<\/span><\/p>\n

                    Question 90<\/b><\/h3>\n

                    Which metadata column identifies the source filename?<\/b><\/p>\n

                      \n
                    1. METADATA$FILENAME<\/span><\/li>\n
                    2. METADATA$SOURCE<\/span><\/li>\n
                    3. METADATA$FILEPATH<\/span><\/li>\n
                    4. METADATA$OBJECT_NAME<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      METADATA$FILENAME provides the name of the source file associated with staged data during supported file-query and loading workflows. It can help data engineers trace records back to their originating files, build ingestion auditing logic, or retain source-file information during transformations. Metadata columns are especially useful when multiple files are processed through a common pipeline. Capturing the filename can support troubleshooting and reconciliation by allowing engineers to identify which staged object contributed particular records.<\/span><\/p>\n

                      Question 91<\/b><\/h3>\n

                      Which option controls how COPY INTO handles row-level load errors?<\/b><\/p>\n

                        \n
                      1. ERROR_POLICY<\/span><\/li>\n
                      2. ON_ERROR<\/span><\/li>\n
                      3. FAILURE_MODE<\/span><\/li>\n
                      4. LOAD_EXCEPTION<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        The ON_ERROR option controls how Snowflake handles errors encountered while loading data with COPY INTO. Depending on the selected behavior, Snowflake can stop the statement, continue processing, or skip problematic files under supported settings. This option is important when designing resilient ingestion pipelines because error handling determines whether one problematic record or file interrupts broader ingestion. Engineers should select an appropriate strategy based on data-quality requirements and downstream reconciliation processes rather than simply allowing malformed input to pass unnoticed.<\/span><\/p>\n

                        Question 92<\/b><\/h3>\n

                        What does INFER_SCHEMA primarily determine?<\/b><\/p>\n

                          \n
                        1. Warehouse sizing<\/span><\/li>\n
                        2. Task dependencies<\/span><\/li>\n
                        3. File column structure<\/span><\/li>\n
                        4. Stream retention<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          INFER_SCHEMA examines supported staged files and derives structural information such as column names and data types. It is useful when building tables from semi-structured or structured files whose schema needs to be discovered automatically. Data engineers can combine schema inference with mechanisms such as USING TEMPLATE to simplify table creation. This approach reduces manual schema-definition work and can be valuable in ingestion environments where file structures are known but must be translated into Snowflake table definitions.<\/span><\/p>\n

                          Question 93<\/b><\/h3>\n

                          Which feature supports automatic column additions during loading?<\/b><\/p>\n

                            \n
                          1. Schema evolution<\/span><\/li>\n
                          2. Static column mapping<\/span><\/li>\n
                          3. Manual table revision<\/span><\/li>\n
                          4. Fixed-schema loading<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            Snowflake schema evolution can allow supported loading workflows to automatically accommodate certain source-schema changes, such as newly appearing columns, when the required configuration and privileges are in place. This capability is useful for ingestion pipelines where upstream producers may add fields over time. It reduces the need for manual table alterations for every compatible schema addition. Engineers should still establish controls around evolving structures because automatic changes can affect downstream transformations, validation rules, reporting logic, and data contracts.<\/span><\/p>\n

                            Question 94<\/b><\/h3>\n

                            Which metadata function records the row position within a source file?<\/b><\/p>\n

                              \n
                            1. METADATA$ROW_ID<\/span><\/li>\n
                            2. METADATA$POSITION<\/span><\/li>\n
                            3. METADATA$FILE_ROW_NUMBER<\/span><\/li>\n
                            4. METADATA$LINE_INDEX<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 3<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              METADATA$FILE_ROW_NUMBER identifies the row number associated with a record within its source file during supported staged-file querying and loading scenarios. This metadata can assist with troubleshooting, source tracing, and duplicate investigation. When combined with the filename metadata, engineers can obtain useful source-level identifiers for incoming records. Such information can be especially helpful when investigating malformed records or reconciling source files against loaded table contents. Metadata columns should be used according to the specific ingestion operation and supported file-processing behavior.<\/span><\/p>\n

                              Question 95<\/b><\/h3>\n

                              What does ZERO-COPY CLONING primarily avoid?<\/b><\/p>\n

                                \n
                              1. Query compilation<\/span><\/li>\n
                              2. Data duplication<\/span><\/li>\n
                              3. Role inheritance<\/span><\/li>\n
                              4. Metadata tracking<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 2<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                Zero-copy cloning creates a new database object without immediately making a separate physical copy of all underlying data. The clone initially references the existing micro-partition data, while subsequent changes can cause new storage to be created as needed. This makes cloning useful for development, testing, experimentation, and environment preparation. Engineers can create isolated objects quickly without initially duplicating the entire dataset. Although cloning avoids immediate full physical duplication, storage can increase later as the source and clone diverge through modifications.<\/span><\/p>\n

                                Question 96<\/b><\/h3>\n

                                Which command restores a dropped object within retention limits?<\/b><\/p>\n

                                  \n
                                1. RESTORE<\/span><\/li>\n
                                2. RECOVER<\/span><\/li>\n
                                3. UNDROP<\/span><\/li>\n
                                4. REINSTATE<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 3<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  The UNDROP command restores a supported dropped Snowflake object when it remains recoverable under the applicable Time Travel retention period. This capability can help recover from accidental object deletion without reconstructing the object manually. Recovery availability depends on the object’s type and retention conditions. Data engineers should understand the distinction between Time Travel and longer-term recovery mechanisms because retention windows are finite. Using UNDROP is therefore an operational recovery technique rather than a substitute for proper backup, replication, or disaster-recovery planning.<\/span><\/p>\n

                                  Question 97<\/b><\/h3>\n

                                  Which function retrieves a previous query’s result set?<\/b><\/p>\n

                                    \n
                                  1. PREVIOUS_RESULT<\/span><\/li>\n
                                  2. QUERY_OUTPUT<\/span><\/li>\n
                                  3. RESULT_SCAN<\/span><\/li>\n
                                  4. RESULT_FETCH<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 3<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    RESULT_SCAN allows Snowflake users to access the result set produced by a previous query. It can work with a query identifier or related result reference, making it useful when subsequent SQL needs to process an earlier query’s output. This can support administrative workflows, metadata analysis, and multi-step SQL processing without rerunning the original statement. Because query-result availability has applicable limits, engineers should design workflows with the relevant session and result-retention behavior in mind when relying on previous query outputs.<\/span><\/p>\n

                                    Question 98<\/b><\/h3>\n

                                    Which function returns the identifier of a previous query?<\/b><\/p>\n

                                      \n
                                    1. LAST_QUERY_ID<\/span><\/li>\n
                                    2. CURRENT_QUERY_ID<\/span><\/li>\n
                                    3. PREVIOUS_STATEMENT_ID<\/span><\/li>\n
                                    4. QUERY_REFERENCE<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 1<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      LAST_QUERY_ID() returns the identifier associated with a previously executed query in the current session context. It is commonly useful with RESULT_SCAN, where the query identifier can be used to reference a prior result set. This enables multi-step workflows in which one statement produces information and a subsequent statement processes that output. Query identifiers are also useful when troubleshooting or examining execution history. Engineers should understand session context because query identifiers and accessible results depend on how and where the statements were executed.<\/span><\/p>\n

                                      Question 99<\/b><\/h3>\n

                                      Which policy controls which rows a user can see?<\/b><\/p>\n

                                        \n
                                      1. Column masking policy<\/span><\/li>\n
                                      2. Object tagging policy<\/span><\/li>\n
                                      3. Row access policy<\/span><\/li>\n
                                      4. Encryption enforcement policy<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 3<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        A row access policy controls whether particular rows are visible to a querying user or role based on defined policy logic. Unlike column masking, which modifies or hides column values, row access policies filter the records available to the requester. This makes them useful for implementing data-isolation requirements such as regional, departmental, or tenant-specific visibility. Data engineers should design the policy conditions carefully and test them across relevant roles because incorrect row-filtering logic can expose too much data or unintentionally restrict legitimate access.<\/span><\/p>\n

                                        Question 100<\/b><\/h3>\n

                                        What does COPY INTO’s PATTERN option filter?<\/b><\/p>\n

                                          \n
                                        1. Destination columns<\/span><\/li>\n
                                        2. Source filenames<\/span><\/li>\n
                                        3. Warehouse clusters<\/span><\/li>\n
                                        4. Target partitions<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          The PATTERN option in COPY INTO uses a regular expression to select staged files whose names match the specified pattern. This allows ingestion pipelines to process only the intended subset of files from a stage. For example, a pipeline can target files belonging to a particular naming convention, date, or data domain without loading unrelated objects. Careful pattern design is important because an overly broad expression can ingest unintended files, while an overly restrictive pattern can leave expected files unprocessed.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Snowflake SnowPro Advanced Data Engineer Exam Dumps and Practice Test Dumps   Question 81 Which stream type tracks only inserted rows? Standard stream Append-only stream Update stream Change-table stream Correct Answer: 2 Explanation: An append-only stream in Snowflake tracks newly inserted rows without recording updates or deletes. This makes it useful for ingestion […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21912"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=21912"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21912\/revisions"}],"predecessor-version":[{"id":21913,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21912\/revisions\/21913"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=21912"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=21912"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=21912"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}