[Aug-2026] Get 100% Real Free SnowPro Core Certification NAS-C01 Sample Questions [Q25-Q48]

[Aug-2026] Get 100% Real Free SnowPro Core Certification NAS-C01 Sample Questions

Accurate NAS-C01 Questions with Free and Fast Updates

NEW QUESTION # 25
You are developing a Snowflake Native Application that relies on external functions (UDFs) hosted outside of Snowflake. You need to ensure that these external functions are securely accessed and that you can track their usage. Which of the following steps are required to correctly configure and manage access to external functions in your application package?

• A. No explicit configuration is required within the application package; external functions are automatically accessible once defined in the developer's Snowflake account.
• B. Grant the 'USAGE privilege on the API integration object to the application role that will be calling the external functions within the application package. This is done through the application setup script.
• C. Create a network rule in the application package that whitelists the IP addresses or hostnames of the external function endpoints. Ensure that the application manifest includes the property set to 'true' and references the network rule.
• D. Define the external functions in the application manifest, specifying the API integration object used for secure communication and authentication.
• E. Implement robust error handling and logging within the application code to capture any issues related to external function calls, including authentication errors, network connectivity problems, and data transformation failures.

Answer: B,C,D,E

Explanation:
Options A, B, C, and D are all correct. External functions require careful configuration within a Snowflake Native Application. Defining the functions in the manifest (A) is essential for Snowflake to recognize and manage them. Network rules (B) ensure secure network access. Granting USAGE on the API integration (C) allows the application role to use the integration for authentication. Robust error handling and logging (D) are crucial for monitoring and troubleshooting. Option E is incorrect; explicit configuration is absolutely necessary for security and control.

NEW QUESTION # 26
You are developing a Snowflake Native Application that processes sensitive customer dat a. The application needs to comply with data residency requirements in both the EU (Frankfurt) and the US (Virginia). You have decided to use Snowflake's multi-region capabilities for failover and regulatory compliance. You plan to install the application in both regions. What considerations are MOST critical when designing your application's installation process to ensure data locality and business continuity?

• A. Use Snowflake's replication features to replicate the application package and its associated data products between the regions.
• B. Ensure the application package contains region-specific configuration files for each region, allowing the application to connect to the correct regional data stores.
• C. Implement a custom error handling mechanism within the application to automatically retry failed operations in the other region in case of a regional outage.
• D. Prioritize replicating application code over replicating application data products, as the code is more critical for application functionality.
• E. Configure Snowflake's cross-cloud auto-failover capabilities to automatically switch to the secondary region in case of a primary region failure. This requires Enterprise Edition or higher.

Answer: A,B

Explanation:
Options A and C are the most critical. Option A ensures the application can connect to the correct data stores in each region, respecting data locality. Option C leverages Snowflake's replication features to ensure both the application code and the data products it relies on are available in both regions for business continuity. B is something good to have but its not the MOST critical, D is also good but it is not the installation process , E is wrong since the code should be first priority for replication

NEW QUESTION # 27
You are the provider of a Snowflake Native Application built with Scal
a. Consumers are reporting that a specific UDF, 'calculate_risk' , occasionally returns incorrect results for certain input datasets. You suspect an issue with the UDF's logic but struggle to reproduce the problem in your development environment. Given that you cannot directly access the consumer's data, what are the most effective strategies for diagnosing this issue?

• A. Modify the UDF to include a 'debug' mode that performs additional checks and assertions. The consumer can enable this mode to collect diagnostic information and report any failures back to the provider. Consumer shares the error logs/code
• B. Request the consumer to execute the UDF with the problematic datasets and provide the resulting incorrect output. Then, use Snowflake's query history and lineage features to trace the data flow and identify potential issues in the UDF's logic.
• C. Implement logging within the 'calculate_risk' UDF to capture input parameters and output values for a sample of executions. Store these logs in a secure table accessible only to the provider, subject to data governance policies. Utilize Snowflake's masking policies to mask the sensitive data and allow the provider to see only masked version, not the actual sensitive data.
• D. Implement comprehensive unit tests for the 'calculate_risk' UDF, covering a wide range of input values and edge cases. Ensure these tests pass before deploying new versions of the application.
• E. Request the consumer to provide anonymized sample data that triggers the issue. Use this data in your development environment to debug the UDF.

Answer: A,C,D

Explanation:
Options B, C, and D are all valid strategies. Robust unit testing (B) helps prevent future issues. Logging input/output (C) provides valuable insights into UDF behavior. A debug mode (D) allows consumers to assist in diagnostics without exposing their data directly. Option A could violate data privacy, and option E is less effective as query history might not reveal the root cause within the UDF's logic.

NEW QUESTION # 28
You are building a Snowflake Native App that aggregates data across multiple consumer accounts. Your app needs to securely access data in each consumer's Snowflake account without requiring them to share their credentials directly. You are evaluating different options for secure data access. Which of the following strategies are viable and recommended to implement this, maximizing security and minimizing administrative overhead for the consumer?

• A. Have consumers create and share a JWT (JSON Web Token) with your application. The JWT will be used to authenticate against their Snowflake instance via an external function.
  
• B. Require consumers to grant SELECT privileges on their tables directly to the application's account. This necessitates the consumer to manage grants directly.
  
• C. Use Snowflake Data Clean Rooms to allow the app to query data from the consumers accounts.
  
• D. Implement a data sharing agreement where consumers create a share from their account and grant usage to your application's account using secure data sharing. The application account can then create a database from this share.
  
• E. Utilize Snowflake's Native App data sharing capabilities where the provider app shares data products back to the consumer account and the consumer account can use this inside their apps.
  

Answer: D,E

Explanation:
Granting SELECT directly (A) requires the consumer to manage grants directly, which is not ideal for scalability or security. Passing JWT tokens (D) is complex and requires careful management of keys. Snowflake Data Clean Rooms(B) are not the correct solution to get consumer data in Provider App.. Secure data sharing (C) is a viable and secure option, as it allows consumers to share data without exposing credentials. Snowflake's Native App sharing Data Products back to the consumer account (E) is the best option for secure data access.

NEW QUESTION # 29
A provider is developing a Snowflake Native Application that uses a managed task to perform critical data transformations. The provider wants to ensure the managed task is only ever executed when the application is in a 'RUNNING' state. They have defined a secure view which returns a single row and a column named 'status' of type VARCHAR. The provider intends to use the 'EXECUTE MANAGED TASK' privilege in conjunction with a user-defined function (UDF) to control task execution. Which of the following approaches, utilizing a UDF and the 'EXECUTE MANAGED TASK' privilege, will correctly and securely prevent the managed task from running unless the application status is 'RUNNING'? Assume the UDF is created with the 'SECURE keyword.

• A. Create a UDF that executes ' if 'SELECT status FROM app_db.app_schema.app_status_view' returns 'RUNNING'. Grant 'EXECUTE MANAGED TASK' on the managed task to the application role. Grant SELECT on the view.
• B. Create a UDF that executes 'SYSTEM$TASK SUSPEND('app_db.app_schema.my_managed_task'Y if 'SELECT status FROM app_db.app_schema.app_status_view' does not return 'RUNNING', otherwise executes Grant 'EXECUTE MANAGED TASK' on the managed task to the application role. Grant 'SELECT on the view.
• C. Create a UDF that returns TRUE only if 'SELECT status FROM app_db.app_schema.app_status_view' returns 'RUNNING'. Then, in the managed task definition, use the WHEN clause with the UDF. Grant 'EXECUTE MANAGED TASK' on the managed task to the application role. Do not grant SELECT on the view.
• D. create a UDF that executes if 'SELECT status FROM app_db.app_schema.app_status_view' does not return 'RUNNING'. Grant 'EXECUTE MANAGED TASK' on the managed task to the application role. Do not grant SELECT on the view.
• E. Create a UDF that returns TRUE only if 'SELECT status FROM app_db.app_schema.app_status_view' returns 'RUNNING'. Then, in the managed task definition, use the WHEN clause with the UDF. Grant 'EXECUTE MANAGED TASK' on the managed task and 'SELECT on the to the application role.

Answer: C

Explanation:
Option C is the most secure and correct approach. By using a UDF within the 'WHEN' clause of the managed task definition, the execution of the task is conditionally dependent on the output of the UDF, which in turn checks the application status view. Crucially, it avoids granting direct SELECT access to the consumer for the status view, preserving application data security. SYSTEM$TASK_SUSPEND/RESUME should be used as the last resource, if other things are failing. Option A incorrectly grants select access to the consumer. Options B, D and E attempt to directly manipulate the task state, this not secure and reliable. The correct solution is to use a UDF with the 'WHEN' clause to achieve conditional task execution without granting unnecessary privileges.

NEW QUESTION # 30
You are developing a Snowflake Native Application that leverages Snowflake's Snowpark API for data processing. The application performs a series of complex transformations on a DataFrame. You need to optimize the application's performance and minimize resource consumption. Which of the following strategies would be MOST effective in achieving this goal?

• A. Use the method frequently to materialize intermediate DataFrames and inspect the data.
• B. Employ lazy evaluation by chaining together transformations on the DataFrame and only triggering execution when the final result is needed.
• C. Break down the DataFrame processing into smaller steps and store the intermediate results in temporary tables within the application's sandbox database.
• D. Explicitly specify the execution order of the transformations using 'cache()' on each intermediate DataFrame to force immediate materialization.
• E. Rely on Snowpark's query optimizer to automatically optimize the entire data processing pipeline without any manual intervention.

Answer: B

Explanation:
Lazy evaluation (C) is the most effective strategy. By chaining transformations and only executing when the final result is needed, Snowpark's query optimizer can optimize the entire pipeline, reducing resource consumption. 'collect()' (A) materializes DataFrames unnecessarily, hindering optimization. While Snowpark does optimize queries (B), relying solely on it is insufficient. Explicit materialization (D) defeats the purpose of lazy evaluation. Storing intermediate results in temporary tables (E) adds overhead and complexity.

NEW QUESTION # 31
A software company, 'Datalnsights', is developing a Snowflake Native Application that requires restricted access to a source data table in the consumer's account. Datalnsights wants to ensure that only the application can access the data, and the consumer cannot directly query it. What is the MOST secure and recommended approach Datalnsights should use within their application package to grant access?

• A. Granting 'SELECT privilege directly on the source data table to the application role.
• B. Using a secure UDF within the application to access the source data table, ensuring data masking and redaction, with only the UDF being granted SELECT privileges on the table.
• C. Granting the ' USAGE privilege on the database and schema containing the source data table directly to the application role.
• D. Creating a secure view on top of the source data table and granting 'SELECT privilege to the application role on the view.
• E. Exposing the table directly through the application's setup script using 'GRANT SELECT ON TABLE TO APPLICATION ROLE app_role' .

Answer: B

Explanation:
Using a secure UDF is the recommended approach. By encapsulating the data access within a secure UDF, you can control precisely how data is accessed and potentially mask sensitive information. Options A, B and E grants direct access which contradicts the requirement for data restriction. While a secure view (C) adds a layer of indirection, a UDF provides greater flexibility and control over the data access logic and potential redaction.

NEW QUESTION # 32
You are developing a Snowflake Native Application that utilizes the 'APPLICATION ROLE' within a secure data sharing context. The application needs to perform different actions based on the role assigned to the user accessing the shared dat a. Consider the following code snippet in a stored procedure:

Which of the following modifications is necessary for the stored procedure to correctly utilize the 'APPLICATION ROLE and function as intended within the context of a Snowflake Native Application and a share?

• A.
• B.
• C.
• D.
• E. No modification is needed. The function will automatically return the active 'APPLICATION_ROLE' within the share.

Answer: B

Explanation:
Option D is correct. The 'CURRENT ROLE()' function returns the primary role of the user, not necessarily the active 'APPLICATION_ROLE. To accurately determine the active , you must use The other options are not relevant to identifying the active application role. Calling SNOWFLAKE.PLATFORM INFO.GET APPLICATION ROLE() may provide some information, but it is preferable to call CURRENT_APPLICATION_ROLE().

NEW QUESTION # 33
A data science team within your organization is developing a Snowflake Native App that needs to access and process customer data stored in a Snowflake database. The app must only access data for customers residing in the 'USA' region. The team has created a custom role 'APP ROLE for the app to use. Which of the following is the MOST secure and efficient way to grant the app the necessary permissions to read the filtered data? Assume a secure view approach is preferred over direct table access.

• A. Grant the 'APP_ROLE the 'USAGE privilege on the database and schema containing the customer data table. Data filtering should still be handled by the app.
• B. Grant the 'APP_ROLE the 'SELECT privilege on the base customer data table and rely on row-level security policies defined on that table.
• C. Create a standard view (non-secure) that filters customer data to include only customers in the 'USA' region and grant the 'APP_ROLE the 'SELECT' privilege on this view.
• D. Create a secure view that filters customer data to include only customers in the 'USA' region and grant the SAPP ROLE the 'SELECT privilege on the secure view.
• E. Grant the SAPP ROLE the 'OWNERSHIP' privilege on the base customer data table and implement data filtering logic within the app itself.

Answer: D

Explanation:
Secure views offer a crucial security advantage: they hide the underlying table structure and any associated metadata from the app, only exposing the filtered data. Row-level security (RLS) can work (A), but secure views provide an extra layer of abstraction and security, hiding the existence of other rows. Granting ownership (C) is highly insecure and unnecessary. Non-secure views (D) do not offer the security benefits required for sensitive data. USAGE privilege alone (E) doesn't grant any data access without SELECT.

NEW QUESTION # 34
You are preparing to publish a Snowflake Native Application on the Snowflake Marketplace. Your application requires several external functions (UDFs) that need to be securely called. Which of the following steps are crucial to correctly configure these external functions within your application package to ensure they function as expected after installation by consumers?

• A. Set the application version as 'TRUSTED' using the 'ALTER APPLICATION VERSION' command after installation.
• B. Grant the ' USAGE privilege on the API integration object to the application role used by the consumer. This will be automatically inherited when the consumer installs the application.
• C. Ensure that the external functions are defined using the 'SECURE' keyword and that the API integration object associated with the functions is included in the application package setup script.
• D. Define external functions with 'VOLATILE keyword to bypass security restrictions. As it needs to be executed during installation, define it in application setup scripts and the API integration object's details will be automatically configured at the consumer end.
• E. Provide clear documentation for the consumer to manually configure the API integration object in their Snowflake account after installing the application.

Answer: C

Explanation:
External functions in Snowflake Native Applications require careful configuration to ensure secure operation. Using the 'SECURE keyword when defining the functions ensures that Snowflake enforces access controls. The API integration object needs to be included in the setup script so that the application environment can be automatically configured during installation on the consumer's account. Option B is incorrect because privileges aren't automatically inherited from the provider. Option C is undesirable as it puts burden on the consumer. Options D & E are incorrect and not valid approaches to solving the problem.

NEW QUESTION # 35
You are packaging a Snowflake Native App and need to ensure that consumer accounts can only access specific data views you've created within your application schem a. You want to prevent consumers from directly querying the underlying tables. Which of the following security measures, when implemented together, BEST achieve this objective? (Choose two)

• A. Grant "OWNERSHIP' on the views to the 'application role' within the application package.
• B. Do not grant any privileges on the underlying tables to the 'application role' within the application package.
• C. Grant 'SELECT' privilege on the underlying tables to the 'application role' within the application package.
• D. Grant 'SELECT privilege only on the views to the 'application role' within the application package.
• E. Use secure views to expose data, ensuring data access is controlled through the view's definition.

Answer: D,E

Explanation:
The combination of granting ' SELECT only on the views (Option B) and using secure views (Option E) provides the strongest data security. Granting select on the views allows consumers to see the data you want them to see. Secure views prevent consumers from circumventing the view definition to access underlying tables, even if they had theoretical privileges (which they shouldn't). Not granting any privileges on tables(C) is correct in conjunction with (B&E), but on its own consumers will not see any data as they can't select from any object. Giving application role ownership to View(D) is not necessary to give consumer access to view the data.

NEW QUESTION # 36
A Snowflake Native Application is designed to process customer data using a series of stored procedures. One of the stored procedures, process data', requires access to a stage named 'customer stage' in the consumer's account to load dat a. The application role 'app_role' is intended to manage all access within the application. However, the procedure fails with a permission error during testing in the consumer environment. Which of the following combination of steps is required to fix the problem?

• A. Grant 'READ and ' WRITE privilege on 'customer_stage' directly to the provider account.
• B. Grant 'USAGE privilege on the database and schema containing 'customer_stage' to the 'app_role', and grant 'READ privilege on 'customer_stage' to the app_role' .
• C. Grant 'USAGE privilege on the database and schema containing 'customer_stage' to the provider account, and grant privilege on 'customer_stage' to the 'app_role' .
• D. Grant 'USAGE privilege on the database and schema containing 'customer_stage' to the 'app_role', and create a new role in the consumer account, grant 'READ on the 'customer_stage' to this new role, then grant this new role to 'app_role' .
• E. The stored procedure needs to be defined with 'EXECUTE AS CALLER rights to assume the privileges of the role executing the procedure.

Answer: B,E

Explanation:
Options A and E are correct. Option A: The 'app_role' needs 'USAGE privileges on the database and schema to access objects within them. It also needs 'READ' privilege on the stage to load data from it. Option E: If the stored procedure is accessing objects with the 'OWNER rights instead of 'CALLER rights, then it doesn't matter what the 'app_role' has privileges to. The procedure needs to be defined to execute as the caller to take advantage of the consumers permissions to external stages. Options B and C are incorrect because granting privileges directly to the provider account or the consumer account is the incorrect pattern for Snowflake Native Apps. The privileges should be managed within the consumer account, usually through an 'app_role' . Option D includes an unnecessary intermediary role that is not needed.

NEW QUESTION # 37
You are developing a Snowflake Native App that requires accessing a specific table within the consumer's account. The consumer should not have direct access to this table. Which of the following is the MOST secure and appropriate method to grant the necessary access?

• A. Employing a Stored Procedure owned by the application role that queries the table in the provider account, and allowing access to the procedure via API integration.
• B. Creating a Snowflake Secure UDF that queries the table within the provider account and exposing the UDF to the consumer account through a package.
• C. Granting direct SELECT access to the consumer role on the table in the provider account, ensuring to revoke access after the app is installed.
• D. Granting the CONSUMPTION usage privilege on the provider account database to the consumer account, and then granting SELECT on the specific table to a role that the app assumes.
• E. Creating a Snowflake Secure View on the table in the provider account and sharing this view with the consumer account using Data Sharing.

Answer: B

Explanation:
Secure UDFs allow you to execute queries in the provider account without exposing the underlying table directly to the consumer. This isolates the data and minimizes the risk of unauthorized access. Stored procedures offer similar functionality, but UDFs are generally simpler and more performant for basic data retrieval. Secure Views via data sharing expose the structure to the consumer account, and granting direct access is a major security risk.

NEW QUESTION # 38
You are developing a Snowflake Native Application that relies on external functions (UDFs/UDTFs) for data processing. A new version of your application includes significant changes to these external functions, potentially affecting existing consumer data and queries. How should you manage the upgrade process to minimize disruption and ensure data integrity in consumer accounts? Assume consumers rely on your function names in their queries. Which of the following approach is MOST suitable?

• A. Update the external functions in place with the new logic. Snowflake's versioning will automatically handle any compatibility issues for existing queries.
• B. Create new versions of the external functions with different names while maintaining the old functions in the new version. Consumers can then migrate to the new functions at their own pace. Use release directives to route new users to new functions.
• C. Develop wrapper functions in the new version that call the original external functions with the new logic applied. Consumers can then gradually migrate to the wrapper functions without immediately changing their queries.
• D. Rename all the external functions in the new version and instruct consumers to update their queries accordingly after the upgrade.
• E. Use release directives to direct users to an intermediate version that provides a compatibility layer for the external function changes. This layer translates calls to the old function names into calls to the new functions, allowing for a phased transition.

Answer: E

Explanation:
Option E is the MOST suitable approach. Using release directives to direct users to an intermediate version with a compatibility layer provides a smooth transition. This allows consumers to continue using their existing queries while the compatibility layer translates the calls to the updated external functions. It minimizes disruption and allows consumers to migrate at their own pace. Option A will cause immediate breakage for consumers. Option B is viable and recommended for consumers to migrate to new functions with no compatibility layers. Option C assumes a level of compatibility that may not exist. Option D might work, but it requires all the consumers to gradually migrated and update their functions calls.

NEW QUESTION # 39
You're packaging a Snowflake Native App and need to define the minimum Snowflake version required for installation. You also want to specify an optional PARAMETER that users can configure during installation to customize the app's behavior. Which section of the manifest file allows you to achieve this?

• A. The 'privileges.sql' file, where you define the privileges required by the application.
• B. The 'deployment.sql' file where you define the app's deployment settings.
• C. The 'setup.sqrl' file, where you define SQL commands to be executed during app installation.
• D. The 'application.yaml' file under the 'configuration' section, where you can specify and define PARAMETERS with their types and default values.
• E. The 'metadata.json' file, which only contains descriptive information about the app.

Answer: D

Explanation:
The 'application.yaml' file is the core configuration file for a Snowflake Native App. It's where you define the to ensure compatibility and declare PARAMETERS with their data types, descriptions, and optional default values, enabling customization during app installation.

NEW QUESTION # 40
You are developing a Snowflake Native App that needs to be deployed across multiple regions. Your application relies on data stored in internal stages. Considering the limitations of Snowflake Native App Framework regarding regional availability and data residency, which of the following strategies is the MOST appropriate to ensure data availability and minimize latency for users in different regions?

• A. Replicate the entire Snowflake account across all regions where the app is deployed.
• B. Package all necessary data within the application itself, eliminating the need for external data sources.
• C. Utilize Snowflake's data replication feature to replicate the internal stages and associated data to regional Snowflake accounts.
• D. Design the application to use external stages (e.g., AWS S3, Azure Blob Storage) in each region and implement logic to access the nearest stage based on the user's location.
• E. Configure the application to access data in a central, globally accessible stage, regardless of the user's region.

Answer: C,D

Explanation:
The best approaches are B and E. Replicating internal stages (B) keeps data close to users in each region. Using regional external stages (E) with location-aware logic offers flexibility and potentially lower latency. Replicating the entire account (A) is overkill and cost-prohibitive. Packaging data within the app (C) is impractical for large datasets and makes updates difficult. Using a central stage (D) negates the benefits of regional deployment. External stages are preferred because Native Apps can only read/write to internal stages within the Application package and not in the consumer's account

NEW QUESTION # 41
You're developing a Snowflake Native App. Part of your application logic involves using a UDF (User-Defined Function) to perform complex calculations on data residing in a table within the consumer's Snowflake account. Which of the following statements correctly describes how you would package and deploy this UDF within your Native App using the application package?

• A. You must create the UDF within a schema in your application package. No additional privileges need to be granted, as the application role automatically has all necessary privileges within the application's namespace.
• B. You must create the UDF within a schema in your application package, and grant USAGE privilege on the schema to the application role. The application code can then execute the UDF without any further privilege grants within the consumer account, and the UDF can be called from SQL or other UDFs using unqualified names.
• C. The UDF definition must be created directly within the consumer's account after the application is installed, as UDFs cannot be included in the application package.
• D. You must create the UDF within a schema in your application package, and grant USAGE privilege on the schema to the application role. The consumer will automatically be granted EXECUTE privilege on the UDF.
• E. The UDF definition must be created as an external function, pointing to an external API endpoint that your application controls, enabling the UDF logic to be executed outside of the consumer's Snowflake environment.

Answer: B

Explanation:
The UDF needs to be created within a schema in the application package. The application role needs USAGE privilege on the schema containing the UDF, and the application can then execute the UDF.

NEW QUESTION # 42
A Native Application is being developed that requires access to the consumer's Snowflake account for billing purposes. The application needs to record the query history of the consumer's account to estimate resource usage. Which is the MOST secure and efficient method for the Native App to access this data, minimizing the permissions granted to the app and considering the governance aspects?

• A. Grant the ' MONITOR USAGE' privilege to the Native App's service account, allowing it to query the view.
• B. Use the 'READ SESSION' privilege to allow the application to read the current session context and infer the resource usage from it.
• C. Grant the ' USAGE privilege on the 'SNOWFLAKE' database to the Native App's service account, allowing it to query all tables and views in that database.
• D. Create a stored procedure within the Native App that executes as the 'OWNER and queries the view. The stored procedure is granted to the Native App's service account with 'EXECUTE privileges.
• E. Grant the 'ACCOUNTADMIN' role to the Native App's service account. This provides full access to the account's query history.

Answer: D

Explanation:
Granting 'ACCOUNTADMIN' is highly insecure and violates the principle of least privilege. 'MONITOR USAGE is not sufficient to query 'QUERY_HISTORY. 'READ SESSION' provides limited contextual information and wouldn't allow retrieval of full query history. Granting USAGE on the 'SNOWFLAKE database is too broad and exposes more data than necessary. A stored procedure executing as the 'OWNER allows controlled access to the query history while minimizing the permissions granted directly to the application's service account.

NEW QUESTION # 43
You are packaging a Snowflake Native App that includes Python code and several supporting data files (e.g., configuration files, sample datasets). What are the correct steps to upload these files to a stage for inclusion in your application package, and how do you ensure the Python code is correctly referenced?

• A. Use the 'snowcli' command-line tool to upload the files to a stage. In the setup.py file, ensure that the Python code is referenced correctly, and the data files are listed as package data.
• B. Upload the Python code directly to a Snowflake UDF using the web interface. Upload the data files to an external stage accessible via a URL, and reference them in the application code.
• C. Employ the Snowflake JDBC driver to programmatically upload the files to an internal stage. Update the setup.py file to install the Python dependencies and reference the data files as resources.
• D. Use 'snowcli' to create and manage stages. Structure the application directory appropriately, listing Python code and data files in 'manifest.yml' for correct packaging.
• E. Use the Snowflake web interface to upload all files to an internal stage. Reference the Python code within the setup.py file using relative paths.

Answer: A,D

Explanation:
'snowcli' is the recommended tool for managing Snowflake Native App development, including stage management and file uploads. The 'setup.py' file is crucial for specifying dependencies and including data files as package data. Newer native apps use 'manifest.ymr to declare stage resources and dependencies. Using JDBC for uploading is possible, but less convenient than 'snowcli' . Referencing files via URLs from external stages introduces unnecessary complexity and security risks. Direct uploading to UDFs is not a method for including all app assets.

NEW QUESTION # 44
You are developing a Snowflake Native Application and need to track changes made to the application code across different versions. You want to leverage Snowflake's built-in capabilities for version control and auditing. Which of the following approaches is the MOST suitable and efficient for achieving this?

• A. Use Snowflake's Streams feature to capture changes made to application code objects and store them in a separate change table for auditing.
• B. Utilize Snowflake's Information Schema views (e.g., 'INFORMATION_SCHEMA.PROCEDURES, 'INFORMATION SCHEMA.FUNCTIONS) in conjunction with Time Travel to query historical metadata and code definitions.
• C. Integrate with an external version control system (e.g., Git) and store application code and deployment scripts in the repository. Use CI/CD pipelines to manage deployments to Snowflake.
• D. Use Snowflake's Time Travel feature to query historical versions of application code objects (e.g., stored procedures, UDFs) and compare differences between versions.
• E. Manually maintain a change log in a separate Snowflake table, documenting each code modification with associated version numbers and timestamps.

Answer: B

Explanation:
Option E is the most suitable and efficient solution. Combining Snowflake's Information Schema views with Time Travel provides a comprehensive and native way to track changes to application code objects. The Information Schema provides metadata about database objects, and Time Travel allows you to query historical versions of those objects. This approach leverages Snowflake's built-in capabilities without requiring external tools or manual change logging. Options A and B requires extra configuration of the whole process. Option C while feasible, Time Travel has to be enabled on each component, which makes option E superior. Option D is designed for data and not code auditing.

NEW QUESTION # 45
A Snowflake Native Application developer wants to ensure that a specific stored procedure, 'UPDATE CUSTOMER STATUS, within their application can only be executed by users who have been granted the 'CUSTOMER ADMIN' role in the consumer's account. How can the developer enforce this authorization check within the stored procedure's code?

• A. Implement a custom function that calls 'SYSTEM$GET PRIVILEGES()' and checks if the user executing the stored procedure possesses the 'CUSTOMER ADMIN' role.
• B. Use the 'CURRENT ROLE()' function within the stored procedure to check if the current role is 'CUSTOMER ADMIN'. If not, raise an error.
• C. Use the function within the stored procedure to verify that the 'CUSTOMER_ADMIN' role is currently active in the session. If not, raise an error.
• D. Utilize the 'SESSION CONTEXT()' function to check for a specific context variable set only when a user with the 'CUSTOMER ADMIN' role is connected.
• E. Grant the 'EXECUTE privilege on the stored procedure only to the 'CUSTOMER_ADMIN' role in the consumer's account.

Answer: C

Explanation:
Option E is the correct approach. directly checks if the specified role is active in the current session, providing a reliable way to enforce role-based access control within the stored procedure. Option A will not work as returns the primary role, not all active roles. Option B controls who can be granted the ability to execute the procedure, but not who is executing it at runtime. Option C is overly complex and less efficient. Option D relies on external context variables, making the authorization less self-contained and harder to manage.

NEW QUESTION # 46
You are developing a Snowflake Native Application that leverages Snowflake Event Tables to log application events. You notice that while the application is successfully writing events to the event table, consumers are reporting that they cannot query the event table. Assume that you have successfully implemented the logging mechanism in your code and data is being logged. Consider the following manifest section:

Which of the following steps is MOST critical to resolve this issue and ensure consumers can query the event table?

• A. The correct approach is not listed, as consumers cannot directly query event tables associated with Snowflake Native Applications for security reasons.
• B. Verify that the application role defined in the application manifest has been granted the 'SELECT privilege on the event table within the provider account.
• C. Grant the 'APPLY MASKING POLICY privilege to the application role on the event table to enable consumers to see masked data, and the REFERENCE_USAGE privilege on the database and schema that contains the event table.
• D. Ensure that the consumer account has the 'MONITOR privilege on the application, as this is required to query event tables associated with native applications.
• E. Confirm that the event table is explicitly listed in the 'shared_objects' section of the application manifest with the correct 'object_name', 'source_type' set to event_table', and 'privileges' including 'SELECT'.

Answer: E

Explanation:
The most critical step is to ensure that the event table is correctly configured in the application manifest under the 'shared_objectS section, with the 'source_type' defined as 'event_table' and the 'privileges' including ' SELECT. This explicitly tells Snowflake that the event table is intended to be shared with consumers and that they should have the 'SELECT privilege on it. Without this, consumers will not be able to query the event table, regardless of other privileges. Other options are either not relevant or do not address the root cause of the problem. Option A, option B and option D are all wrong, as they are not related to the root cause of the problem. Option E, is correct as it ensures masking policy is not a problem. The privileges are not relevant in this case.

NEW QUESTION # 47
You are using the Snowflake Visual Studio Code (VS Code) extension to develop a Snowflake Native App. After making several changes, you encounter an error that seems to stem from a syntax issue. You want to quickly pinpoint the exact location of the error in your SQL code. What functionality of the VS Code extension can best assist you in this scenario?

• A. The syntax highlighting and code completion features, which help identify syntax errors and suggest valid code snippets.
• B. Using Version Control tool integration
• C. The extension's integrated debugger, which allows you to step through your SQL code line by line.
• D. The built-in linter that automatically identifies syntax errors, style issues, and potential security vulnerabilities in your SQL code.
• E. The extension's integration with Snowflake's query profile tool, enabling you to analyze the query execution plan for errors.

Answer: A,D

Explanation:
The correct answers are B and D. Syntax highlighting (B) visually cues potential errors while typing. The built-in linter (D) provides real-time automated error detection. Options A and C are not directly designed for quickly finding syntax issues. Version control tool integration is used for code managment but can't help in identifying synatax error.

NEW QUESTION # 48
......

NAS-C01 Study Guide Realistic Verified Dumps: https://pass4sures.freepdfdump.top/NAS-C01-valid-torrent.html