{"id":21934,"date":"2026-09-25T10:08:12","date_gmt":"2026-09-25T10:08:12","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=21934"},"modified":"2026-09-25T10:08:12","modified_gmt":"2026-09-25T10:08:12","slug":"snowflake-snowpro-advanced-data-engineer-practice-test-questions-and-exam-dumps-part16-q301-320","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/snowflake-snowpro-advanced-data-engineer-practice-test-questions-and-exam-dumps-part16-q301-320\/","title":{"rendered":"Snowflake SnowPro Advanced Data Engineer Practice Test Questions and Exam Dumps Part16 Q301-320"},"content":{"rendered":"

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

 <\/p>\n

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

Which command creates a stream on an existing table?<\/b><\/p>\n

    \n
  1. BUILD STREAM<\/span><\/li>\n
  2. CREATE CHANGE STREAM<\/span><\/li>\n
  3. CREATE STREAM<\/span><\/li>\n
  4. MAKE STREAM<\/span><\/li>\n<\/ol>\n

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

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

    CREATE STREAM creates a stream object that records changes occurring on a supported source object. Streams are important for incremental data pipelines because they allow downstream processes to identify newly inserted, deleted, or updated records without repeatedly comparing complete table snapshots. Engineers can then consume those changes through SQL statements and tasks. When creating a stream, the source object, initialization behavior, and required privileges should be considered carefully. Proper stream design can significantly reduce unnecessary processing in large-scale transformation workflows.<\/span><\/p>\n

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

    Which statement consumes stream records in a transformation?<\/b><\/p>\n

      \n
    1. MERGE<\/span><\/li>\n
    2. READ STREAM<\/span><\/li>\n
    3. APPLY STREAM<\/span><\/li>\n
    4. PROCESS CHANGES<\/span><\/li>\n<\/ol>\n

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

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

      A MERGE statement can consume stream records and apply inserts, updates, or deletes to a target table according to matching conditions. This pattern is widely used for incremental data pipelines because only changed records need to be processed rather than rebuilding the complete target dataset. Engineers can combine stream metadata with MERGE logic to distinguish different change types. The target transformation should be designed carefully so that duplicate processing, unmatched records, and business-key behavior are handled consistently during repeated pipeline executions.<\/span><\/p>\n

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

      Which stream property defines whether updates are represented as separate changes?<\/b><\/p>\n

        \n
      1. APPEND_ONLY<\/span><\/li>\n
      2. UPDATE_TRACKING<\/span><\/li>\n
      3. CHANGE_MODE<\/span><\/li>\n
      4. CAPTURE_UPDATES<\/span><\/li>\n<\/ol>\n

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

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

        APPEND_ONLY determines whether a stream is configured to capture only newly appended rows for supported source workloads. An append-only stream does not provide the same update and delete change information as a standard stream. This can simplify processing when the source table is naturally append-only, such as certain event or log datasets. Engineers should select this mode only when the source behavior matches the intended semantics. Using append-only processing on mutable data can cause downstream consumers to miss important changes.<\/span><\/p>\n

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

        Which task condition can prevent execution when no changes exist?<\/b><\/p>\n

          \n
        1. WHEN HAS_ROWS<\/span><\/li>\n
        2. WHEN STREAM_HAS_DATA<\/span><\/li>\n
        3. IF CHANGES_EXIST<\/span><\/li>\n
        4. WHEN DATA_READY<\/span><\/li>\n<\/ol>\n

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

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

          The WHEN condition of a task can use SYSTEM$STREAM_HAS_DATA to determine whether a stream contains relevant change information before executing downstream processing. This pattern helps event-driven pipelines avoid unnecessary task runs when there is nothing new to process. Engineers commonly combine this condition with a scheduled task so the task periodically checks for changes. The approach can reduce unnecessary compute consumption while maintaining automated processing. Task scheduling, stream retention, and processing frequency should still be designed according to freshness requirements.<\/span><\/p>\n

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

          Which command resumes a suspended task?<\/b><\/p>\n

            \n
          1. START TASK<\/span><\/li>\n
          2. ALTER TASK … RESUME<\/span><\/li>\n
          3. ENABLE TASK<\/span><\/li>\n
          4. ACTIVATE TASK<\/span><\/li>\n<\/ol>\n

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

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

            ALTER TASK … RESUME changes a suspended task to a resumed state so that its configured scheduling or dependency-based execution can proceed. Resuming a task is an administrative operation and does not itself redesign the task’s SQL logic or dependencies. Engineers should verify the task definition, predecessor relationships, schedule, and target objects before resuming production workloads. In task graphs, dependency states should also be reviewed because resuming one task does not necessarily mean every related task has been activated.<\/span><\/p>\n

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

            Which command suspends a running task?<\/b><\/p>\n

              \n
            1. ALTER TASK … SUSPEND<\/span><\/li>\n
            2. STOP TASK EXECUTION<\/span><\/li>\n
            3. DISABLE TASK NOW<\/span><\/li>\n
            4. PAUSE TASK<\/span><\/li>\n<\/ol>\n

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

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

              ALTER TASK … SUSPEND suspends a task so that its scheduled or dependency-driven executions do not continue normally. This can be useful during maintenance, troubleshooting, schema changes, or controlled deployment activities. Engineers should understand that suspending a task is different from deleting it because the task definition remains available. Before suspending a production pipeline, teams should consider downstream dependencies and determine whether queued or dependent processing requires additional operational handling.<\/span><\/p>\n

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

              Which object can coordinate dependent task execution?<\/b><\/p>\n

                \n
              1. Task graph<\/span><\/li>\n
              2. Pipeline table<\/span><\/li>\n
              3. Workflow schema<\/span><\/li>\n
              4. Execution chain<\/span><\/li>\n<\/ol>\n

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

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

                A task graph coordinates execution among related Snowflake tasks by defining dependencies between parent and child tasks. This allows data engineers to organize multi-step workflows such as ingestion, validation, transformation, and publishing. Dependencies can establish the required execution order without requiring every stage to be controlled externally. Engineers should keep task graphs understandable and avoid unnecessary complexity. Clear dependency design makes failures easier to diagnose and helps ensure that downstream tasks do not process incomplete upstream data.<\/span><\/p>\n

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

                Which Snowflake object supports automated file ingestion logic?<\/b><\/p>\n

                  \n
                1. Pipe<\/span><\/li>\n
                2. Stream<\/span><\/li>\n
                3. Task<\/span><\/li>\n
                4. View<\/span><\/li>\n<\/ol>\n

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

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

                  A pipe stores the loading definition used by Snowpipe for continuous file ingestion. Its definition generally contains a COPY INTO statement that describes how staged files should be loaded into a target table. Pipes can operate with automatic cloud notifications when configured for automated ingestion. Engineers should carefully configure stages, file formats, permissions, notification infrastructure, and target tables because an error in any component can prevent expected files from being processed.<\/span><\/p>\n

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

                  Which function reports the status of a Snowpipe pipe?<\/b><\/p>\n

                    \n
                  1. SYSTEM$PIPE_STATUS<\/span><\/li>\n
                  2. PIPE_STATUS<\/span><\/li>\n
                  3. SYSTEM$INGESTION_STATE<\/span><\/li>\n
                  4. GET_PIPE_STATUS<\/span><\/li>\n<\/ol>\n

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

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

                    SYSTEM$PIPE_STATUS returns status information for a Snowpipe pipe and is useful when investigating ingestion activity. Engineers can use the function to inspect operational details and determine whether a pipe has pending or problematic processing. This information can be combined with loading history and cloud-storage checks during troubleshooting. Monitoring pipe status is particularly important in automated ingestion architectures because files may arrive continuously without a human initiating each load operation.<\/span><\/p>\n

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

                    Which setting enables automatic Snowpipe ingestion?<\/b><\/p>\n

                      \n
                    1. AUTO_LOAD<\/span><\/li>\n
                    2. AUTO_INGEST<\/span><\/li>\n
                    3. CONTINUOUS_LOAD<\/span><\/li>\n
                    4. EVENT_INGEST<\/span><\/li>\n<\/ol>\n

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

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

                      AUTO_INGEST = TRUE enables supported Snowpipe configurations to use cloud event notifications for automated file ingestion. When new files arrive in the configured external storage location, notification events can cause Snowpipe to process those files. This reduces the need for repeatedly executing manual loading commands. Engineers must configure both Snowflake and the cloud provider correctly, including notification services, storage permissions, stages, and pipe definitions. Monitoring should verify that incoming files generate the expected ingestion activity.<\/span><\/p>\n

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

                      Which object defines parsing rules for staged files?<\/b><\/p>\n

                        \n
                      1. File format<\/span><\/li>\n
                      2. Storage integration<\/span><\/li>\n
                      3. Pipe<\/span><\/li>\n
                      4. Directory table<\/span><\/li>\n<\/ol>\n

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

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

                        A file format defines how Snowflake interprets staged files during loading or unloading operations. Depending on the format, settings can describe delimiters, compression, quotation characters, null handling, encoding, and other parsing behavior. Named file formats can be reused across multiple stages and pipelines, promoting consistent ingestion configuration. Engineers should validate file-format definitions against actual producer output because even a small mismatch can produce incorrect columns, parsing errors, or unexpected null values.<\/span><\/p>\n

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

                        Which object provides metadata about files stored in a stage?<\/b><\/p>\n

                          \n
                        1. Stage stream<\/span><\/li>\n
                        2. Directory table<\/span><\/li>\n
                        3. File catalog<\/span><\/li>\n
                        4. Storage view<\/span><\/li>\n<\/ol>\n

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

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

                          A directory table provides metadata describing files associated with a stage. This can support workflows that need to inspect staged objects, identify available files, or build metadata-driven processing logic. Directory information is different from the contents of the files themselves because it represents file-level metadata rather than materialized source rows. Engineers can use directory metadata alongside loading mechanisms when designing controlled ingestion workflows, especially where source-file discovery and processing status need to be incorporated into pipeline logic.<\/span><\/p>\n

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

                          Which integration provides controlled access to external cloud storage?<\/b><\/p>\n

                            \n
                          1. Storage integration<\/span><\/li>\n
                          2. Cloud credential object<\/span><\/li>\n
                          3. External access integration<\/span><\/li>\n
                          4. Storage permission profile<\/span><\/li>\n<\/ol>\n

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

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

                            A storage integration provides Snowflake with a managed configuration for accessing supported external cloud storage. It allows cloud authorization details to be centralized rather than embedding long-lived credentials directly into individual external stages. Engineers can then reference the integration when configuring stages that point to cloud storage locations. Proper cloud-side permissions remain essential because the Snowflake integration and provider authorization must work together. Storage integrations help make external-stage configurations more consistent and easier to govern.<\/span><\/p>\n

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

                            Which object defines allowed outbound network locations?<\/b><\/p>\n

                              \n
                            1. External access integration<\/span><\/li>\n
                            2. Network rule<\/span><\/li>\n
                            3. Secret<\/span><\/li>\n
                            4. API integration<\/span><\/li>\n<\/ol>\n

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

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

                              A network rule identifies approved network locations that can be referenced by Snowflake configurations supporting controlled external connectivity. Depending on the rule type, it can represent supported hostnames, IP ranges, or other network identifiers. Network rules help establish explicit boundaries for outbound access rather than allowing unrestricted destinations. Engineers should keep these definitions appropriately scoped and review them as external service requirements change. Network rules are typically combined with other security objects when configuring external access.<\/span><\/p>\n

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

                              Which object securely stores credentials for external services?<\/b><\/p>\n

                                \n
                              1. Secret<\/span><\/li>\n
                              2. Credential table<\/span><\/li>\n
                              3. Password stage<\/span><\/li>\n
                              4. Authentication record<\/span><\/li>\n<\/ol>\n

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

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

                                A Snowflake secret securely stores supported authentication information used by external access configurations and compatible code. Secrets help prevent credentials from being embedded directly in SQL procedures or function definitions. Depending on the secret type, they can hold information such as passwords, tokens, or other authentication material. Engineers should apply strict privileges to secrets because access may provide authentication to an external service. External access integrations can reference approved secrets when establishing controlled connectivity.<\/span><\/p>\n

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

                                Which feature allows Snowflake SQL to invoke a remote API service?<\/b><\/p>\n

                                  \n
                                1. External function<\/span><\/li>\n
                                2. Remote table<\/span><\/li>\n
                                3. API view<\/span><\/li>\n
                                4. Service procedure<\/span><\/li>\n<\/ol>\n

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

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

                                  An external function allows Snowflake SQL to invoke a remotely hosted service through an appropriate integration and endpoint configuration. This capability is useful when a transformation requires specialized processing or an external service that does not run directly inside Snowflake. Engineers should consider latency, availability, authentication, data-transfer costs, and failure handling before placing external function calls inside high-volume transformations. External dependencies should be monitored because service interruptions can affect otherwise healthy Snowflake pipelines.<\/span><\/p>\n

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

                                  Which object can expose data through a reusable query definition?<\/b><\/p>\n

                                    \n
                                  1. View<\/span><\/li>\n
                                  2. Pipe<\/span><\/li>\n
                                  3. Stage<\/span><\/li>\n
                                  4. Stream<\/span><\/li>\n<\/ol>\n

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

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

                                    A standard view stores a SQL query definition and exposes its resulting dataset to authorized consumers. Views are useful for abstraction, reusable transformations, security-oriented presentation layers, and simplified access to complex joins or filters. Because a standard view does not independently store a materialized result, its queries generally execute against the underlying objects when accessed. Engineers should use views when logical abstraction is more important than maintaining a physically stored query result.<\/span><\/p>\n

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

                                    Which object automatically maintains a stored query result?<\/b><\/p>\n

                                      \n
                                    1. Dynamic table<\/span><\/li>\n
                                    2. Materialized view<\/span><\/li>\n
                                    3. Standard view<\/span><\/li>\n
                                    4. External table<\/span><\/li>\n<\/ol>\n

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

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

                                      A materialized view maintains a stored representation of a query result that Snowflake can maintain automatically. This can improve performance for suitable recurring query patterns because users may avoid recalculating the complete underlying transformation each time. Materialized views differ from standard views, which store only query definitions. Engineers should evaluate query patterns, supported SQL constructs, maintenance behavior, and workload benefits before selecting materialized views for production data-serving requirements.<\/span><\/p>\n

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

                                      Which command creates a zero-copy clone?<\/b><\/p>\n

                                        \n
                                      1. CREATE CLONE<\/span><\/li>\n
                                      2. CREATE TABLE … CLONE<\/span><\/li>\n
                                      3. CLONE TABLE USING<\/span><\/li>\n
                                      4. COPY TABLE METADATA<\/span><\/li>\n<\/ol>\n

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

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

                                        CREATE TABLE … CLONE creates a zero-copy clone of a supported source table. Initially, the clone shares underlying micro-partition storage rather than creating an immediate physical duplicate of every source record. This makes cloning useful for development environments, testing, rapid recovery workflows, and controlled transformation experiments. As the source or clone changes, Snowflake manages storage according to its copy-on-write architecture. Engineers should still consider retention, permissions, and downstream object dependencies when using clones.<\/span><\/p>\n

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

                                        Which command restores a previously dropped schema?<\/b><\/p>\n

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

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

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

                                          UNDROP SCHEMA restores a previously dropped schema when it remains available under Snowflake’s applicable retention rules. This can recover the schema and supported objects that existed within it at the time of deletion. Engineers should act promptly when accidental deletion occurs because historical recovery depends on retention and object availability. Before restoring the schema, teams should also check whether an object with the same name already exists and understand how the recovery affects dependent workloads.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Snowflake SnowPro Advanced Data Engineer Exam Dumps and Practice Test Dumps   Question 301 Which command creates a stream on an existing table? BUILD STREAM CREATE CHANGE STREAM CREATE STREAM MAKE STREAM Correct Answer: 3 Explanation: CREATE STREAM creates a stream object that records changes occurring on a supported source object. Streams are […]<\/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\/21934"}],"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=21934"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21934\/revisions"}],"predecessor-version":[{"id":21935,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/21934\/revisions\/21935"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=21934"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=21934"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=21934"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}