pulumi-snowflake 0.58.0a1726035035__py3-none-any.whl → 0.59.0__py3-none-any.whl

pulumi_snowflake/file_format.py

@@ -614,6 +614,7 @@ class _FileFormatState:
                  field_optionally_enclosed_by: Optional[pulumi.Input[str]] = None,
                  file_extension: Optional[pulumi.Input[str]] = None,
                  format_type: Optional[pulumi.Input[str]] = None,
+                 fully_qualified_name: Optional[pulumi.Input[str]] = None,
                  ignore_utf8_errors: Optional[pulumi.Input[bool]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -652,6 +653,7 @@ class _FileFormatState:
         :param pulumi.Input[str] field_optionally_enclosed_by: Character used to enclose strings.
         :param pulumi.Input[str] file_extension: Specifies the extension for files unloaded to a stage.
         :param pulumi.Input[str] format_type: Specifies the format of the input files (for data loading) or output files (for data unloading).
+        :param pulumi.Input[str] fully_qualified_name: Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
         :param pulumi.Input[bool] ignore_utf8_errors: Boolean that specifies whether UTF-8 encoding errors produce error conditions.
         :param pulumi.Input[str] name: Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] null_ifs: String used to convert to and from SQL NULL.
@@ -708,6 +710,8 @@ class _FileFormatState:
             pulumi.set(__self__, "file_extension", file_extension)
         if format_type is not None:
             pulumi.set(__self__, "format_type", format_type)
+        if fully_qualified_name is not None:
+            pulumi.set(__self__, "fully_qualified_name", fully_qualified_name)
         if ignore_utf8_errors is not None:
             pulumi.set(__self__, "ignore_utf8_errors", ignore_utf8_errors)
         if name is not None:
@@ -971,6 +975,18 @@ class _FileFormatState:
     def format_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "format_type", value)
 
+    @property
+    @pulumi.getter(name="fullyQualifiedName")
+    def fully_qualified_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
+        """
+        return pulumi.get(self, "fully_qualified_name")
+
+    @fully_qualified_name.setter
+    def fully_qualified_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "fully_qualified_name", value)
+
     @property
     @pulumi.getter(name="ignoreUtf8Errors")
     def ignore_utf8_errors(self) -> Optional[pulumi.Input[bool]]:
@@ -1219,19 +1235,6 @@ class FileFormat(pulumi.CustomResource):
                  trim_space: Optional[pulumi.Input[bool]] = None,
                  __props__=None):
         """
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_snowflake as snowflake
-
-        example_file_format = snowflake.FileFormat("example_file_format",
-            name="EXAMPLE_FILE_FORMAT",
-            database="EXAMPLE_DB",
-            schema="EXAMPLE_SCHEMA",
-            format_type="CSV")
-        ```
-
         ## Import
 
         format is database name | schema name | file format name
@@ -1286,19 +1289,6 @@ class FileFormat(pulumi.CustomResource):
                  args: FileFormatArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        ## Example Usage
-
-        ```python
-        import pulumi
-        import pulumi_snowflake as snowflake
-
-        example_file_format = snowflake.FileFormat("example_file_format",
-            name="EXAMPLE_FILE_FORMAT",
-            database="EXAMPLE_DB",
-            schema="EXAMPLE_SCHEMA",
-            format_type="CSV")
-        ```
-
         ## Import
 
         format is database name | schema name | file format name
@@ -1409,6 +1399,7 @@ class FileFormat(pulumi.CustomResource):
             __props__.__dict__["time_format"] = time_format
             __props__.__dict__["timestamp_format"] = timestamp_format
             __props__.__dict__["trim_space"] = trim_space
+            __props__.__dict__["fully_qualified_name"] = None
         super(FileFormat, __self__).__init__(
             'snowflake:index/fileFormat:FileFormat',
             resource_name,
@@ -1438,6 +1429,7 @@ class FileFormat(pulumi.CustomResource):
             field_optionally_enclosed_by: Optional[pulumi.Input[str]] = None,
             file_extension: Optional[pulumi.Input[str]] = None,
             format_type: Optional[pulumi.Input[str]] = None,
+            fully_qualified_name: Optional[pulumi.Input[str]] = None,
             ignore_utf8_errors: Optional[pulumi.Input[bool]] = None,
             name: Optional[pulumi.Input[str]] = None,
             null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
@@ -1481,6 +1473,7 @@ class FileFormat(pulumi.CustomResource):
         :param pulumi.Input[str] field_optionally_enclosed_by: Character used to enclose strings.
         :param pulumi.Input[str] file_extension: Specifies the extension for files unloaded to a stage.
         :param pulumi.Input[str] format_type: Specifies the format of the input files (for data loading) or output files (for data unloading).
+        :param pulumi.Input[str] fully_qualified_name: Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
         :param pulumi.Input[bool] ignore_utf8_errors: Boolean that specifies whether UTF-8 encoding errors produce error conditions.
         :param pulumi.Input[str] name: Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] null_ifs: String used to convert to and from SQL NULL.
@@ -1522,6 +1515,7 @@ class FileFormat(pulumi.CustomResource):
         __props__.__dict__["field_optionally_enclosed_by"] = field_optionally_enclosed_by
         __props__.__dict__["file_extension"] = file_extension
         __props__.__dict__["format_type"] = format_type
+        __props__.__dict__["fully_qualified_name"] = fully_qualified_name
         __props__.__dict__["ignore_utf8_errors"] = ignore_utf8_errors
         __props__.__dict__["name"] = name
         __props__.__dict__["null_ifs"] = null_ifs
@@ -1693,6 +1687,14 @@ class FileFormat(pulumi.CustomResource):
         """
         return pulumi.get(self, "format_type")
 
+    @property
+    @pulumi.getter(name="fullyQualifiedName")
+    def fully_qualified_name(self) -> pulumi.Output[str]:
+        """
+        Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
+        """
+        return pulumi.get(self, "fully_qualified_name")
+
     @property
     @pulumi.getter(name="ignoreUtf8Errors")
     def ignore_utf8_errors(self) -> pulumi.Output[Optional[bool]]:

pulumi_snowflake/function.py

@@ -279,6 +279,7 @@ class _FunctionState:
                  arguments: Optional[pulumi.Input[Sequence[pulumi.Input['FunctionArgumentArgs']]]] = None,
                  comment: Optional[pulumi.Input[str]] = None,
                  database: Optional[pulumi.Input[str]] = None,
+                 fully_qualified_name: Optional[pulumi.Input[str]] = None,
                  handler: Optional[pulumi.Input[str]] = None,
                  imports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  is_secure: Optional[pulumi.Input[bool]] = None,
@@ -297,6 +298,7 @@ class _FunctionState:
         :param pulumi.Input[Sequence[pulumi.Input['FunctionArgumentArgs']]] arguments: List of the arguments for the function
         :param pulumi.Input[str] comment: Specifies a comment for the function.
         :param pulumi.Input[str] database: The database in which to create the function. Don't use the | character.
+        :param pulumi.Input[str] fully_qualified_name: Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
         :param pulumi.Input[str] handler: The handler method for Java / Python function.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] imports: Imports for Java / Python functions. For Java this a list of jar files, for Python this is a list of Python files.
         :param pulumi.Input[bool] is_secure: Specifies that the function is secure.
@@ -317,6 +319,8 @@ class _FunctionState:
             pulumi.set(__self__, "comment", comment)
         if database is not None:
             pulumi.set(__self__, "database", database)
+        if fully_qualified_name is not None:
+            pulumi.set(__self__, "fully_qualified_name", fully_qualified_name)
         if handler is not None:
             pulumi.set(__self__, "handler", handler)
         if imports is not None:
@@ -380,6 +384,18 @@ class _FunctionState:
     def database(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "database", value)
 
+    @property
+    @pulumi.getter(name="fullyQualifiedName")
+    def fully_qualified_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
+        """
+        return pulumi.get(self, "fully_qualified_name")
+
+    @fully_qualified_name.setter
+    def fully_qualified_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "fully_qualified_name", value)
+
     @property
     @pulumi.getter
     def handler(self) -> Optional[pulumi.Input[str]]:
@@ -560,8 +576,6 @@ class Function(pulumi.CustomResource):
                  target_path: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
-        ## Example Usage
-
         ## Import
 
         format is <database_name>.<schema_name>.<function_name>(<arg types, separated with ','>)
@@ -596,8 +610,6 @@ class Function(pulumi.CustomResource):
                  args: FunctionArgs,
                  opts: Optional[pulumi.ResourceOptions] = None):
         """
-        ## Example Usage
-
         ## Import
 
         format is <database_name>.<schema_name>.<function_name>(<arg types, separated with ','>)
@@ -670,6 +682,7 @@ class Function(pulumi.CustomResource):
                 raise TypeError("Missing required property 'statement'")
             __props__.__dict__["statement"] = statement
             __props__.__dict__["target_path"] = target_path
+            __props__.__dict__["fully_qualified_name"] = None
         super(Function, __self__).__init__(
             'snowflake:index/function:Function',
             resource_name,
@@ -683,6 +696,7 @@ class Function(pulumi.CustomResource):
             arguments: Optional[pulumi.Input[Sequence[pulumi.Input[Union['FunctionArgumentArgs', 'FunctionArgumentArgsDict']]]]] = None,
             comment: Optional[pulumi.Input[str]] = None,
             database: Optional[pulumi.Input[str]] = None,
+            fully_qualified_name: Optional[pulumi.Input[str]] = None,
             handler: Optional[pulumi.Input[str]] = None,
             imports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             is_secure: Optional[pulumi.Input[bool]] = None,
@@ -706,6 +720,7 @@ class Function(pulumi.CustomResource):
         :param pulumi.Input[Sequence[pulumi.Input[Union['FunctionArgumentArgs', 'FunctionArgumentArgsDict']]]] arguments: List of the arguments for the function
         :param pulumi.Input[str] comment: Specifies a comment for the function.
         :param pulumi.Input[str] database: The database in which to create the function. Don't use the | character.
+        :param pulumi.Input[str] fully_qualified_name: Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
         :param pulumi.Input[str] handler: The handler method for Java / Python function.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] imports: Imports for Java / Python functions. For Java this a list of jar files, for Python this is a list of Python files.
         :param pulumi.Input[bool] is_secure: Specifies that the function is secure.
@@ -727,6 +742,7 @@ class Function(pulumi.CustomResource):
         __props__.__dict__["arguments"] = arguments
         __props__.__dict__["comment"] = comment
         __props__.__dict__["database"] = database
+        __props__.__dict__["fully_qualified_name"] = fully_qualified_name
         __props__.__dict__["handler"] = handler
         __props__.__dict__["imports"] = imports
         __props__.__dict__["is_secure"] = is_secure
@@ -766,6 +782,14 @@ class Function(pulumi.CustomResource):
         """
         return pulumi.get(self, "database")
 
+    @property
+    @pulumi.getter(name="fullyQualifiedName")
+    def fully_qualified_name(self) -> pulumi.Output[str]:
+        """
+        Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
+        """
+        return pulumi.get(self, "fully_qualified_name")
+
     @property
     @pulumi.getter
     def handler(self) -> pulumi.Output[Optional[str]]:

pulumi_snowflake/get_database_roles.py

@@ -9,6 +9,7 @@ import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
+from ._inputs import *
 
 __all__ = [
     'GetDatabaseRolesResult',
@@ -22,30 +23,28 @@ class GetDatabaseRolesResult:
     """
     A collection of values returned by getDatabaseRoles.
     """
-    def __init__(__self__, database=None, database_roles=None, id=None):
-        if database and not isinstance(database, str):
-            raise TypeError("Expected argument 'database' to be a str")
-        pulumi.set(__self__, "database", database)
+    def __init__(__self__, database_roles=None, id=None, in_database=None, like=None, limit=None):
         if database_roles and not isinstance(database_roles, list):
             raise TypeError("Expected argument 'database_roles' to be a list")
         pulumi.set(__self__, "database_roles", database_roles)
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
-
-    @property
-    @pulumi.getter
-    def database(self) -> str:
-        """
-        The database from which to return the database roles from.
-        """
-        return pulumi.get(self, "database")
+        if in_database and not isinstance(in_database, str):
+            raise TypeError("Expected argument 'in_database' to be a str")
+        pulumi.set(__self__, "in_database", in_database)
+        if like and not isinstance(like, str):
+            raise TypeError("Expected argument 'like' to be a str")
+        pulumi.set(__self__, "like", like)
+        if limit and not isinstance(limit, dict):
+            raise TypeError("Expected argument 'limit' to be a dict")
+        pulumi.set(__self__, "limit", limit)
 
     @property
     @pulumi.getter(name="databaseRoles")
     def database_roles(self) -> Sequence['outputs.GetDatabaseRolesDatabaseRoleResult']:
         """
-        Lists all the database roles in a specified database.
+        Holds the aggregated output of all database role details queries.
         """
         return pulumi.get(self, "database_roles")
 
@@ -57,6 +56,30 @@ class GetDatabaseRolesResult:
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="inDatabase")
+    def in_database(self) -> str:
+        """
+        The database from which to return the database roles from.
+        """
+        return pulumi.get(self, "in_database")
+
+    @property
+    @pulumi.getter
+    def like(self) -> Optional[str]:
+        """
+        Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+        """
+        return pulumi.get(self, "like")
+
+    @property
+    @pulumi.getter
+    def limit(self) -> Optional['outputs.GetDatabaseRolesLimitResult']:
+        """
+        Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+        """
+        return pulumi.get(self, "limit")
+
 
 class AwaitableGetDatabaseRolesResult(GetDatabaseRolesResult):
     # pylint: disable=using-constant-test
@@ -64,51 +87,55 @@ class AwaitableGetDatabaseRolesResult(GetDatabaseRolesResult):
         if False:
             yield self
         return GetDatabaseRolesResult(
-            database=self.database,
             database_roles=self.database_roles,
-            id=self.id)
+            id=self.id,
+            in_database=self.in_database,
+            like=self.like,
+            limit=self.limit)
 
 
-def get_database_roles(database: Optional[str] = None,
+def get_database_roles(in_database: Optional[str] = None,
+                       like: Optional[str] = None,
+                       limit: Optional[Union['GetDatabaseRolesLimitArgs', 'GetDatabaseRolesLimitArgsDict']] = None,
                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetDatabaseRolesResult:
     """
-    ## Example Usage
+    !> **V1 release candidate** This data source was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the data source if needed. Any errors reported will be resolved with a higher priority. We encourage checking this data source out before the V1 release. Please follow the migration guide to use it.
 
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
+    Datasource used to get details of filtered database roles. Filtering is aligned with the current possibilities for [SHOW DATABASE ROLES](https://docs.snowflake.com/en/sql-reference/sql/show-database-roles) query (`like` and `limit` are supported). The results of SHOW is encapsulated in show_output collection.
 
-    db_roles = snowflake.get_database_roles(database="MYDB")
-    ```
 
-
-    :param str database: The database from which to return the database roles from.
+    :param str in_database: The database from which to return the database roles from.
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param Union['GetDatabaseRolesLimitArgs', 'GetDatabaseRolesLimitArgsDict'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
     """
     __args__ = dict()
-    __args__['database'] = database
+    __args__['inDatabase'] = in_database
+    __args__['like'] = like
+    __args__['limit'] = limit
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('snowflake:index/getDatabaseRoles:getDatabaseRoles', __args__, opts=opts, typ=GetDatabaseRolesResult).value
 
     return AwaitableGetDatabaseRolesResult(
-        database=pulumi.get(__ret__, 'database'),
         database_roles=pulumi.get(__ret__, 'database_roles'),
-        id=pulumi.get(__ret__, 'id'))
+        id=pulumi.get(__ret__, 'id'),
+        in_database=pulumi.get(__ret__, 'in_database'),
+        like=pulumi.get(__ret__, 'like'),
+        limit=pulumi.get(__ret__, 'limit'))
 
 
 @_utilities.lift_output_func(get_database_roles)
-def get_database_roles_output(database: Optional[pulumi.Input[str]] = None,
+def get_database_roles_output(in_database: Optional[pulumi.Input[str]] = None,
+                              like: Optional[pulumi.Input[Optional[str]]] = None,
+                              limit: Optional[pulumi.Input[Optional[Union['GetDatabaseRolesLimitArgs', 'GetDatabaseRolesLimitArgsDict']]]] = None,
                               opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetDatabaseRolesResult]:
     """
-    ## Example Usage
-
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
+    !> **V1 release candidate** This data source was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the data source if needed. Any errors reported will be resolved with a higher priority. We encourage checking this data source out before the V1 release. Please follow the migration guide to use it.
 
-    db_roles = snowflake.get_database_roles(database="MYDB")
-    ```
+    Datasource used to get details of filtered database roles. Filtering is aligned with the current possibilities for [SHOW DATABASE ROLES](https://docs.snowflake.com/en/sql-reference/sql/show-database-roles) query (`like` and `limit` are supported). The results of SHOW is encapsulated in show_output collection.
 
 
-    :param str database: The database from which to return the database roles from.
+    :param str in_database: The database from which to return the database roles from.
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param Union['GetDatabaseRolesLimitArgs', 'GetDatabaseRolesLimitArgsDict'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
     """
     ...

pulumi_snowflake/get_masking_policies.py

@@ -9,6 +9,7 @@ import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
 from . import _utilities
 from . import outputs
+from ._inputs import *
 
 __all__ = [
     'GetMaskingPoliciesResult',
@@ -22,51 +23,73 @@ class GetMaskingPoliciesResult:
     """
     A collection of values returned by getMaskingPolicies.
     """
-    def __init__(__self__, database=None, id=None, masking_policies=None, schema=None):
-        if database and not isinstance(database, str):
-            raise TypeError("Expected argument 'database' to be a str")
-        pulumi.set(__self__, "database", database)
+    def __init__(__self__, id=None, in_=None, like=None, limit=None, masking_policies=None, with_describe=None):
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if in_ and not isinstance(in_, dict):
+            raise TypeError("Expected argument 'in_' to be a dict")
+        pulumi.set(__self__, "in_", in_)
+        if like and not isinstance(like, str):
+            raise TypeError("Expected argument 'like' to be a str")
+        pulumi.set(__self__, "like", like)
+        if limit and not isinstance(limit, dict):
+            raise TypeError("Expected argument 'limit' to be a dict")
+        pulumi.set(__self__, "limit", limit)
         if masking_policies and not isinstance(masking_policies, list):
             raise TypeError("Expected argument 'masking_policies' to be a list")
         pulumi.set(__self__, "masking_policies", masking_policies)
-        if schema and not isinstance(schema, str):
-            raise TypeError("Expected argument 'schema' to be a str")
-        pulumi.set(__self__, "schema", schema)
+        if with_describe and not isinstance(with_describe, bool):
+            raise TypeError("Expected argument 'with_describe' to be a bool")
+        pulumi.set(__self__, "with_describe", with_describe)
 
     @property
     @pulumi.getter
-    def database(self) -> str:
+    def id(self) -> str:
         """
-        The database from which to return the schemas from.
+        The provider-assigned unique ID for this managed resource.
         """
-        return pulumi.get(self, "database")
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter(name="in")
+    def in_(self) -> Optional['outputs.GetMaskingPoliciesInResult']:
+        """
+        IN clause to filter the list of masking policies
+        """
+        return pulumi.get(self, "in_")
 
     @property
     @pulumi.getter
-    def id(self) -> str:
+    def like(self) -> Optional[str]:
         """
-        The provider-assigned unique ID for this managed resource.
+        Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
         """
-        return pulumi.get(self, "id")
+        return pulumi.get(self, "like")
+
+    @property
+    @pulumi.getter
+    def limit(self) -> Optional['outputs.GetMaskingPoliciesLimitResult']:
+        """
+        Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+        """
+        return pulumi.get(self, "limit")
 
     @property
     @pulumi.getter(name="maskingPolicies")
     def masking_policies(self) -> Sequence['outputs.GetMaskingPoliciesMaskingPolicyResult']:
         """
-        The maskingPolicies in the schema
+        Holds the aggregated output of all views details queries.
         """
         return pulumi.get(self, "masking_policies")
 
     @property
-    @pulumi.getter
-    def schema(self) -> str:
+    @pulumi.getter(name="withDescribe")
+    def with_describe(self) -> Optional[bool]:
         """
-        The schema from which to return the maskingPolicies from.
+        Runs DESC MASKING POLICY for each masking policy returned by SHOW MASKING POLICIES. The output of describe is saved to the description field. By default this value is set to true.
         """
-        return pulumi.get(self, "schema")
+        return pulumi.get(self, "with_describe")
 
 
 class AwaitableGetMaskingPoliciesResult(GetMaskingPoliciesResult):
@@ -75,60 +98,62 @@ class AwaitableGetMaskingPoliciesResult(GetMaskingPoliciesResult):
         if False:
             yield self
         return GetMaskingPoliciesResult(
-            database=self.database,
             id=self.id,
+            in_=self.in_,
+            like=self.like,
+            limit=self.limit,
             masking_policies=self.masking_policies,
-            schema=self.schema)
+            with_describe=self.with_describe)
 
 
-def get_masking_policies(database: Optional[str] = None,
-                         schema: Optional[str] = None,
+def get_masking_policies(in_: Optional[Union['GetMaskingPoliciesInArgs', 'GetMaskingPoliciesInArgsDict']] = None,
+                         like: Optional[str] = None,
+                         limit: Optional[Union['GetMaskingPoliciesLimitArgs', 'GetMaskingPoliciesLimitArgsDict']] = None,
+                         with_describe: Optional[bool] = None,
                          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetMaskingPoliciesResult:
     """
-    ## Example Usage
+    !> **V1 release candidate** This data source was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the data source if needed. Any errors reported will be resolved with a higher priority. We encourage checking this data source out before the V1 release. Please follow the migration guide to use it.
 
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
+    Datasource used to get details of filtered masking policies. Filtering is aligned with the current possibilities for [SHOW MASKING POLICIES](https://docs.snowflake.com/en/sql-reference/sql/show-masking-policies) query. The results of SHOW and DESCRIBE are encapsulated in one output collection `masking_policies`.
 
-    current = snowflake.get_masking_policies(database="MYDB",
-        schema="MYSCHEMA")
-    ```
 
-
-    :param str database: The database from which to return the schemas from.
-    :param str schema: The schema from which to return the maskingPolicies from.
+    :param Union['GetMaskingPoliciesInArgs', 'GetMaskingPoliciesInArgsDict'] in_: IN clause to filter the list of masking policies
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param Union['GetMaskingPoliciesLimitArgs', 'GetMaskingPoliciesLimitArgsDict'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+    :param bool with_describe: Runs DESC MASKING POLICY for each masking policy returned by SHOW MASKING POLICIES. The output of describe is saved to the description field. By default this value is set to true.
     """
     __args__ = dict()
-    __args__['database'] = database
-    __args__['schema'] = schema
+    __args__['in'] = in_
+    __args__['like'] = like
+    __args__['limit'] = limit
+    __args__['withDescribe'] = with_describe
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('snowflake:index/getMaskingPolicies:getMaskingPolicies', __args__, opts=opts, typ=GetMaskingPoliciesResult).value
 
     return AwaitableGetMaskingPoliciesResult(
-        database=pulumi.get(__ret__, 'database'),
         id=pulumi.get(__ret__, 'id'),
+        in_=pulumi.get(__ret__, 'in_'),
+        like=pulumi.get(__ret__, 'like'),
+        limit=pulumi.get(__ret__, 'limit'),
         masking_policies=pulumi.get(__ret__, 'masking_policies'),
-        schema=pulumi.get(__ret__, 'schema'))
+        with_describe=pulumi.get(__ret__, 'with_describe'))
 
 
 @_utilities.lift_output_func(get_masking_policies)
-def get_masking_policies_output(database: Optional[pulumi.Input[str]] = None,
-                                schema: Optional[pulumi.Input[str]] = None,
+def get_masking_policies_output(in_: Optional[pulumi.Input[Optional[Union['GetMaskingPoliciesInArgs', 'GetMaskingPoliciesInArgsDict']]]] = None,
+                                like: Optional[pulumi.Input[Optional[str]]] = None,
+                                limit: Optional[pulumi.Input[Optional[Union['GetMaskingPoliciesLimitArgs', 'GetMaskingPoliciesLimitArgsDict']]]] = None,
+                                with_describe: Optional[pulumi.Input[Optional[bool]]] = None,
                                 opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetMaskingPoliciesResult]:
     """
-    ## Example Usage
-
-    ```python
-    import pulumi
-    import pulumi_snowflake as snowflake
+    !> **V1 release candidate** This data source was reworked and is a release candidate for the V1. We do not expect significant changes in it before the V1. We will welcome any feedback and adjust the data source if needed. Any errors reported will be resolved with a higher priority. We encourage checking this data source out before the V1 release. Please follow the migration guide to use it.
 
-    current = snowflake.get_masking_policies(database="MYDB",
-        schema="MYSCHEMA")
-    ```
+    Datasource used to get details of filtered masking policies. Filtering is aligned with the current possibilities for [SHOW MASKING POLICIES](https://docs.snowflake.com/en/sql-reference/sql/show-masking-policies) query. The results of SHOW and DESCRIBE are encapsulated in one output collection `masking_policies`.
 
 
-    :param str database: The database from which to return the schemas from.
-    :param str schema: The schema from which to return the maskingPolicies from.
+    :param Union['GetMaskingPoliciesInArgs', 'GetMaskingPoliciesInArgsDict'] in_: IN clause to filter the list of masking policies
+    :param str like: Filters the output with **case-insensitive** pattern, with support for SQL wildcard characters (`%` and `_`).
+    :param Union['GetMaskingPoliciesLimitArgs', 'GetMaskingPoliciesLimitArgsDict'] limit: Limits the number of rows returned. If the `limit.from` is set, then the limit wll start from the first element matched by the expression. The expression is only used to match with the first element, later on the elements are not matched by the prefix, but you can enforce a certain pattern with `starts_with` or `like`.
+    :param bool with_describe: Runs DESC MASKING POLICY for each masking policy returned by SHOW MASKING POLICIES. The output of describe is saved to the description field. By default this value is set to true.
     """
     ...