pulumi-snowflake 2.3.0a1753339260__py3-none-any.whl → 2.3.0a1753415140__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of pulumi-snowflake might be problematic. Click here for more details.
- pulumi_snowflake/__init__.py +20 -1
- pulumi_snowflake/_inputs.py +17236 -16797
- pulumi_snowflake/account.py +252 -253
- pulumi_snowflake/account_authentication_policy_attachment.py +18 -19
- pulumi_snowflake/account_parameter.py +35 -36
- pulumi_snowflake/account_password_policy_attachment.py +18 -19
- pulumi_snowflake/account_role.py +42 -43
- pulumi_snowflake/alert.py +149 -150
- pulumi_snowflake/api_authentication_integration_with_authorization_code_grant.py +197 -198
- pulumi_snowflake/api_authentication_integration_with_client_credentials.py +180 -181
- pulumi_snowflake/api_authentication_integration_with_jwt_bearer.py +193 -194
- pulumi_snowflake/api_integration.py +251 -252
- pulumi_snowflake/authentication_policy.py +167 -168
- pulumi_snowflake/compute_pool.py +167 -168
- pulumi_snowflake/config/__init__.py +1 -1
- pulumi_snowflake/config/__init__.pyi +1 -2
- pulumi_snowflake/config/outputs.py +21 -22
- pulumi_snowflake/config/vars.py +43 -44
- pulumi_snowflake/cortex_search_service.py +191 -192
- pulumi_snowflake/current_account.py +2096 -2097
- pulumi_snowflake/current_organization_account.py +5863 -0
- pulumi_snowflake/database.py +353 -354
- pulumi_snowflake/database_role.py +63 -64
- pulumi_snowflake/dynamic_table.py +274 -275
- pulumi_snowflake/email_notification_integration.py +70 -71
- pulumi_snowflake/execute.py +61 -62
- pulumi_snowflake/external_function.py +280 -281
- pulumi_snowflake/external_oauth_integration.py +288 -289
- pulumi_snowflake/external_table.py +246 -247
- pulumi_snowflake/external_volume.py +68 -69
- pulumi_snowflake/failover_group.py +135 -136
- pulumi_snowflake/file_format.py +622 -623
- pulumi_snowflake/function_java.py +320 -321
- pulumi_snowflake/function_javascript.py +243 -244
- pulumi_snowflake/function_python.py +334 -335
- pulumi_snowflake/function_scala.py +320 -321
- pulumi_snowflake/function_sql.py +226 -227
- pulumi_snowflake/get_account_roles.py +16 -17
- pulumi_snowflake/get_accounts.py +16 -17
- pulumi_snowflake/get_alerts.py +22 -23
- pulumi_snowflake/get_compute_pools.py +23 -24
- pulumi_snowflake/get_connections.py +10 -11
- pulumi_snowflake/get_cortex_search_services.py +18 -19
- pulumi_snowflake/get_current_account.py +9 -10
- pulumi_snowflake/get_current_role.py +5 -6
- pulumi_snowflake/get_database.py +25 -26
- pulumi_snowflake/get_database_role.py +19 -20
- pulumi_snowflake/get_database_roles.py +17 -18
- pulumi_snowflake/get_databases.py +29 -30
- pulumi_snowflake/get_dynamic_tables.py +13 -14
- pulumi_snowflake/get_external_functions.py +16 -17
- pulumi_snowflake/get_external_tables.py +16 -17
- pulumi_snowflake/get_failover_groups.py +10 -11
- pulumi_snowflake/get_file_formats.py +16 -17
- pulumi_snowflake/get_functions.py +16 -17
- pulumi_snowflake/get_git_repositories.py +18 -19
- pulumi_snowflake/get_grants.py +9 -10
- pulumi_snowflake/get_image_repositories.py +11 -12
- pulumi_snowflake/get_masking_policies.py +18 -19
- pulumi_snowflake/get_materialized_views.py +16 -17
- pulumi_snowflake/get_network_policies.py +16 -17
- pulumi_snowflake/get_parameters.py +34 -35
- pulumi_snowflake/get_pipes.py +16 -17
- pulumi_snowflake/get_procedures.py +16 -17
- pulumi_snowflake/get_resource_monitors.py +10 -11
- pulumi_snowflake/get_row_access_policies.py +18 -19
- pulumi_snowflake/get_schemas.py +30 -31
- pulumi_snowflake/get_secrets.py +17 -18
- pulumi_snowflake/get_security_integrations.py +16 -17
- pulumi_snowflake/get_sequences.py +16 -17
- pulumi_snowflake/get_services.py +30 -31
- pulumi_snowflake/get_shares.py +10 -11
- pulumi_snowflake/get_stages.py +16 -17
- pulumi_snowflake/get_storage_integrations.py +4 -5
- pulumi_snowflake/get_streamlits.py +18 -19
- pulumi_snowflake/get_streams.py +24 -25
- pulumi_snowflake/get_system_generate_scim_access_token.py +11 -12
- pulumi_snowflake/get_system_get_aws_sns_iam_policy.py +11 -12
- pulumi_snowflake/get_system_get_private_link_config.py +21 -22
- pulumi_snowflake/get_system_get_snowflake_platform_info.py +7 -8
- pulumi_snowflake/get_tables.py +24 -25
- pulumi_snowflake/get_tags.py +11 -12
- pulumi_snowflake/get_tasks.py +30 -31
- pulumi_snowflake/get_user_programmatic_access_tokens.py +113 -0
- pulumi_snowflake/get_users.py +29 -30
- pulumi_snowflake/get_views.py +24 -25
- pulumi_snowflake/get_warehouses.py +22 -23
- pulumi_snowflake/git_repository.py +133 -134
- pulumi_snowflake/grant_account_role.py +52 -53
- pulumi_snowflake/grant_application_role.py +52 -53
- pulumi_snowflake/grant_database_role.py +69 -70
- pulumi_snowflake/grant_ownership.py +55 -56
- pulumi_snowflake/grant_privileges_to_account_role.py +125 -126
- pulumi_snowflake/grant_privileges_to_database_role.py +122 -123
- pulumi_snowflake/grant_privileges_to_share.py +154 -155
- pulumi_snowflake/image_repository.py +80 -81
- pulumi_snowflake/job_service.py +148 -149
- pulumi_snowflake/legacy_service_user.py +1269 -1270
- pulumi_snowflake/managed_account.py +140 -141
- pulumi_snowflake/masking_policy.py +136 -137
- pulumi_snowflake/materialized_view.py +149 -150
- pulumi_snowflake/network_policy.py +116 -117
- pulumi_snowflake/network_policy_attachment.py +52 -53
- pulumi_snowflake/network_rule.py +129 -130
- pulumi_snowflake/notification_integration.py +298 -299
- pulumi_snowflake/oauth_integration_for_custom_clients.py +263 -264
- pulumi_snowflake/oauth_integration_for_partner_applications.py +169 -170
- pulumi_snowflake/object_parameter.py +72 -73
- pulumi_snowflake/outputs.py +15957 -15511
- pulumi_snowflake/password_policy.py +299 -300
- pulumi_snowflake/pipe.py +181 -182
- pulumi_snowflake/primary_connection.py +70 -71
- pulumi_snowflake/procedure_java.py +341 -342
- pulumi_snowflake/procedure_javascript.py +247 -248
- pulumi_snowflake/procedure_python.py +338 -339
- pulumi_snowflake/procedure_scala.py +341 -342
- pulumi_snowflake/procedure_sql.py +247 -248
- pulumi_snowflake/provider.py +377 -378
- pulumi_snowflake/pulumi-plugin.json +1 -1
- pulumi_snowflake/resource_monitor.py +165 -166
- pulumi_snowflake/row_access_policy.py +102 -103
- pulumi_snowflake/saml2_integration.py +303 -304
- pulumi_snowflake/schema.py +390 -391
- pulumi_snowflake/scim_integration.py +133 -134
- pulumi_snowflake/secondary_connection.py +72 -73
- pulumi_snowflake/secondary_database.py +350 -351
- pulumi_snowflake/secret_with_authorization_code_grant.py +138 -139
- pulumi_snowflake/secret_with_basic_authentication.py +121 -122
- pulumi_snowflake/secret_with_client_credentials.py +125 -126
- pulumi_snowflake/secret_with_generic_string.py +104 -105
- pulumi_snowflake/sequence.py +121 -122
- pulumi_snowflake/service.py +233 -234
- pulumi_snowflake/service_user.py +1239 -1240
- pulumi_snowflake/share.py +61 -62
- pulumi_snowflake/shared_database.py +299 -300
- pulumi_snowflake/stage.py +234 -235
- pulumi_snowflake/storage_integration.py +230 -231
- pulumi_snowflake/stream_on_directory_table.py +128 -129
- pulumi_snowflake/stream_on_external_table.py +151 -152
- pulumi_snowflake/stream_on_table.py +164 -165
- pulumi_snowflake/stream_on_view.py +164 -165
- pulumi_snowflake/streamlit.py +184 -185
- pulumi_snowflake/table.py +147 -148
- pulumi_snowflake/table_column_masking_policy_application.py +52 -53
- pulumi_snowflake/table_constraint.py +191 -192
- pulumi_snowflake/tag.py +114 -115
- pulumi_snowflake/tag_association.py +86 -87
- pulumi_snowflake/task.py +1224 -1225
- pulumi_snowflake/user.py +1346 -1347
- pulumi_snowflake/user_authentication_policy_attachment.py +35 -36
- pulumi_snowflake/user_password_policy_attachment.py +35 -36
- pulumi_snowflake/user_programmatic_access_token.py +598 -0
- pulumi_snowflake/user_public_keys.py +52 -53
- pulumi_snowflake/view.py +187 -188
- pulumi_snowflake/warehouse.py +286 -287
- {pulumi_snowflake-2.3.0a1753339260.dist-info → pulumi_snowflake-2.3.0a1753415140.dist-info}/METADATA +1 -1
- pulumi_snowflake-2.3.0a1753415140.dist-info/RECORD +161 -0
- pulumi_snowflake-2.3.0a1753339260.dist-info/RECORD +0 -158
- {pulumi_snowflake-2.3.0a1753339260.dist-info → pulumi_snowflake-2.3.0a1753415140.dist-info}/WHEEL +0 -0
- {pulumi_snowflake-2.3.0a1753339260.dist-info → pulumi_snowflake-2.3.0a1753415140.dist-info}/top_level.txt +0 -0
pulumi_snowflake/file_format.py
CHANGED
|
@@ -2,8 +2,7 @@
|
|
|
2
2
|
# *** WARNING: this file was generated by pulumi-language-python. ***
|
|
3
3
|
# *** Do not edit by hand unless you're certain you know what you are doing! ***
|
|
4
4
|
|
|
5
|
-
import builtins
|
|
6
|
-
import copy
|
|
5
|
+
import builtins as _builtins
|
|
7
6
|
import warnings
|
|
8
7
|
import sys
|
|
9
8
|
import pulumi
|
|
@@ -20,80 +19,80 @@ __all__ = ['FileFormatArgs', 'FileFormat']
|
|
|
20
19
|
@pulumi.input_type
|
|
21
20
|
class FileFormatArgs:
|
|
22
21
|
def __init__(__self__, *,
|
|
23
|
-
database: pulumi.Input[
|
|
24
|
-
format_type: pulumi.Input[
|
|
25
|
-
schema: pulumi.Input[
|
|
26
|
-
allow_duplicate: Optional[pulumi.Input[
|
|
27
|
-
binary_as_text: Optional[pulumi.Input[
|
|
28
|
-
binary_format: Optional[pulumi.Input[
|
|
29
|
-
comment: Optional[pulumi.Input[
|
|
30
|
-
compression: Optional[pulumi.Input[
|
|
31
|
-
date_format: Optional[pulumi.Input[
|
|
32
|
-
disable_auto_convert: Optional[pulumi.Input[
|
|
33
|
-
disable_snowflake_data: Optional[pulumi.Input[
|
|
34
|
-
empty_field_as_null: Optional[pulumi.Input[
|
|
35
|
-
enable_octal: Optional[pulumi.Input[
|
|
36
|
-
encoding: Optional[pulumi.Input[
|
|
37
|
-
error_on_column_count_mismatch: Optional[pulumi.Input[
|
|
38
|
-
escape: Optional[pulumi.Input[
|
|
39
|
-
escape_unenclosed_field: Optional[pulumi.Input[
|
|
40
|
-
field_delimiter: Optional[pulumi.Input[
|
|
41
|
-
field_optionally_enclosed_by: Optional[pulumi.Input[
|
|
42
|
-
file_extension: Optional[pulumi.Input[
|
|
43
|
-
ignore_utf8_errors: Optional[pulumi.Input[
|
|
44
|
-
name: Optional[pulumi.Input[
|
|
45
|
-
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
46
|
-
parse_header: Optional[pulumi.Input[
|
|
47
|
-
preserve_space: Optional[pulumi.Input[
|
|
48
|
-
record_delimiter: Optional[pulumi.Input[
|
|
49
|
-
replace_invalid_characters: Optional[pulumi.Input[
|
|
50
|
-
skip_blank_lines: Optional[pulumi.Input[
|
|
51
|
-
skip_byte_order_mark: Optional[pulumi.Input[
|
|
52
|
-
skip_header: Optional[pulumi.Input[
|
|
53
|
-
strip_null_values: Optional[pulumi.Input[
|
|
54
|
-
strip_outer_array: Optional[pulumi.Input[
|
|
55
|
-
strip_outer_element: Optional[pulumi.Input[
|
|
56
|
-
time_format: Optional[pulumi.Input[
|
|
57
|
-
timestamp_format: Optional[pulumi.Input[
|
|
58
|
-
trim_space: Optional[pulumi.Input[
|
|
22
|
+
database: pulumi.Input[_builtins.str],
|
|
23
|
+
format_type: pulumi.Input[_builtins.str],
|
|
24
|
+
schema: pulumi.Input[_builtins.str],
|
|
25
|
+
allow_duplicate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
26
|
+
binary_as_text: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
27
|
+
binary_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
28
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
29
|
+
compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
30
|
+
date_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
31
|
+
disable_auto_convert: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
32
|
+
disable_snowflake_data: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
33
|
+
empty_field_as_null: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
34
|
+
enable_octal: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
35
|
+
encoding: Optional[pulumi.Input[_builtins.str]] = None,
|
|
36
|
+
error_on_column_count_mismatch: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
37
|
+
escape: Optional[pulumi.Input[_builtins.str]] = None,
|
|
38
|
+
escape_unenclosed_field: Optional[pulumi.Input[_builtins.str]] = None,
|
|
39
|
+
field_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
40
|
+
field_optionally_enclosed_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
41
|
+
file_extension: Optional[pulumi.Input[_builtins.str]] = None,
|
|
42
|
+
ignore_utf8_errors: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
43
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
44
|
+
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
45
|
+
parse_header: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
46
|
+
preserve_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
47
|
+
record_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
48
|
+
replace_invalid_characters: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
49
|
+
skip_blank_lines: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
50
|
+
skip_byte_order_mark: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
51
|
+
skip_header: Optional[pulumi.Input[_builtins.int]] = None,
|
|
52
|
+
strip_null_values: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
53
|
+
strip_outer_array: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
54
|
+
strip_outer_element: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
55
|
+
time_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
56
|
+
timestamp_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
57
|
+
trim_space: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
59
58
|
"""
|
|
60
59
|
The set of arguments for constructing a FileFormat resource.
|
|
61
|
-
:param pulumi.Input[
|
|
62
|
-
:param pulumi.Input[
|
|
63
|
-
:param pulumi.Input[
|
|
64
|
-
:param pulumi.Input[
|
|
65
|
-
:param pulumi.Input[
|
|
66
|
-
:param pulumi.Input[
|
|
67
|
-
:param pulumi.Input[
|
|
68
|
-
:param pulumi.Input[
|
|
69
|
-
:param pulumi.Input[
|
|
70
|
-
:param pulumi.Input[
|
|
71
|
-
:param pulumi.Input[
|
|
72
|
-
:param pulumi.Input[
|
|
73
|
-
:param pulumi.Input[
|
|
74
|
-
:param pulumi.Input[
|
|
75
|
-
:param pulumi.Input[
|
|
76
|
-
:param pulumi.Input[
|
|
77
|
-
:param pulumi.Input[
|
|
78
|
-
:param pulumi.Input[
|
|
79
|
-
:param pulumi.Input[
|
|
80
|
-
:param pulumi.Input[
|
|
81
|
-
:param pulumi.Input[
|
|
82
|
-
:param pulumi.Input[
|
|
83
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
84
|
-
:param pulumi.Input[
|
|
85
|
-
:param pulumi.Input[
|
|
86
|
-
:param pulumi.Input[
|
|
87
|
-
:param pulumi.Input[
|
|
88
|
-
:param pulumi.Input[
|
|
89
|
-
:param pulumi.Input[
|
|
90
|
-
:param pulumi.Input[
|
|
91
|
-
:param pulumi.Input[
|
|
92
|
-
:param pulumi.Input[
|
|
93
|
-
:param pulumi.Input[
|
|
94
|
-
:param pulumi.Input[
|
|
95
|
-
:param pulumi.Input[
|
|
96
|
-
:param pulumi.Input[
|
|
60
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the file format.
|
|
61
|
+
:param pulumi.Input[_builtins.str] format_type: Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
62
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the file format.
|
|
63
|
+
:param pulumi.Input[_builtins.bool] allow_duplicate: Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
64
|
+
:param pulumi.Input[_builtins.bool] binary_as_text: Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
65
|
+
:param pulumi.Input[_builtins.str] binary_format: Defines the encoding format for binary input or output.
|
|
66
|
+
:param pulumi.Input[_builtins.str] comment: Specifies a comment for the file format.
|
|
67
|
+
:param pulumi.Input[_builtins.str] compression: Specifies the current compression algorithm for the data file.
|
|
68
|
+
:param pulumi.Input[_builtins.str] date_format: Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
69
|
+
:param pulumi.Input[_builtins.bool] disable_auto_convert: Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
70
|
+
:param pulumi.Input[_builtins.bool] disable_snowflake_data: Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
71
|
+
:param pulumi.Input[_builtins.bool] empty_field_as_null: Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
72
|
+
:param pulumi.Input[_builtins.bool] enable_octal: Boolean that enables parsing of octal numbers.
|
|
73
|
+
:param pulumi.Input[_builtins.str] encoding: String (constant) that specifies the character set of the source data when loading data into a table.
|
|
74
|
+
:param pulumi.Input[_builtins.bool] error_on_column_count_mismatch: Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
75
|
+
:param pulumi.Input[_builtins.str] escape: Single character string used as the escape character for field values.
|
|
76
|
+
:param pulumi.Input[_builtins.str] escape_unenclosed_field: Single character string used as the escape character for unenclosed field values only.
|
|
77
|
+
:param pulumi.Input[_builtins.str] field_delimiter: Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
78
|
+
:param pulumi.Input[_builtins.str] field_optionally_enclosed_by: Character used to enclose strings.
|
|
79
|
+
:param pulumi.Input[_builtins.str] file_extension: Specifies the extension for files unloaded to a stage.
|
|
80
|
+
:param pulumi.Input[_builtins.bool] ignore_utf8_errors: Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
81
|
+
:param pulumi.Input[_builtins.str] name: Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
82
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] null_ifs: String used to convert to and from SQL NULL.
|
|
83
|
+
:param pulumi.Input[_builtins.bool] parse_header: Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
84
|
+
:param pulumi.Input[_builtins.bool] preserve_space: Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
85
|
+
:param pulumi.Input[_builtins.str] record_delimiter: Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
86
|
+
:param pulumi.Input[_builtins.bool] replace_invalid_characters: Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
87
|
+
:param pulumi.Input[_builtins.bool] skip_blank_lines: Boolean that specifies to skip any blank lines encountered in the data files.
|
|
88
|
+
:param pulumi.Input[_builtins.bool] skip_byte_order_mark: Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
89
|
+
:param pulumi.Input[_builtins.int] skip_header: Number of lines at the start of the file to skip.
|
|
90
|
+
:param pulumi.Input[_builtins.bool] strip_null_values: Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
91
|
+
:param pulumi.Input[_builtins.bool] strip_outer_array: Boolean that instructs the JSON parser to remove outer brackets.
|
|
92
|
+
:param pulumi.Input[_builtins.bool] strip_outer_element: Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
93
|
+
:param pulumi.Input[_builtins.str] time_format: Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
94
|
+
:param pulumi.Input[_builtins.str] timestamp_format: Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
95
|
+
:param pulumi.Input[_builtins.bool] trim_space: Boolean that specifies whether to remove white space from fields.
|
|
97
96
|
"""
|
|
98
97
|
pulumi.set(__self__, "database", database)
|
|
99
98
|
pulumi.set(__self__, "format_type", format_type)
|
|
@@ -165,518 +164,518 @@ class FileFormatArgs:
|
|
|
165
164
|
if trim_space is not None:
|
|
166
165
|
pulumi.set(__self__, "trim_space", trim_space)
|
|
167
166
|
|
|
168
|
-
@property
|
|
167
|
+
@_builtins.property
|
|
169
168
|
@pulumi.getter
|
|
170
|
-
def database(self) -> pulumi.Input[
|
|
169
|
+
def database(self) -> pulumi.Input[_builtins.str]:
|
|
171
170
|
"""
|
|
172
171
|
The database in which to create the file format.
|
|
173
172
|
"""
|
|
174
173
|
return pulumi.get(self, "database")
|
|
175
174
|
|
|
176
175
|
@database.setter
|
|
177
|
-
def database(self, value: pulumi.Input[
|
|
176
|
+
def database(self, value: pulumi.Input[_builtins.str]):
|
|
178
177
|
pulumi.set(self, "database", value)
|
|
179
178
|
|
|
180
|
-
@property
|
|
179
|
+
@_builtins.property
|
|
181
180
|
@pulumi.getter(name="formatType")
|
|
182
|
-
def format_type(self) -> pulumi.Input[
|
|
181
|
+
def format_type(self) -> pulumi.Input[_builtins.str]:
|
|
183
182
|
"""
|
|
184
183
|
Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
185
184
|
"""
|
|
186
185
|
return pulumi.get(self, "format_type")
|
|
187
186
|
|
|
188
187
|
@format_type.setter
|
|
189
|
-
def format_type(self, value: pulumi.Input[
|
|
188
|
+
def format_type(self, value: pulumi.Input[_builtins.str]):
|
|
190
189
|
pulumi.set(self, "format_type", value)
|
|
191
190
|
|
|
192
|
-
@property
|
|
191
|
+
@_builtins.property
|
|
193
192
|
@pulumi.getter
|
|
194
|
-
def schema(self) -> pulumi.Input[
|
|
193
|
+
def schema(self) -> pulumi.Input[_builtins.str]:
|
|
195
194
|
"""
|
|
196
195
|
The schema in which to create the file format.
|
|
197
196
|
"""
|
|
198
197
|
return pulumi.get(self, "schema")
|
|
199
198
|
|
|
200
199
|
@schema.setter
|
|
201
|
-
def schema(self, value: pulumi.Input[
|
|
200
|
+
def schema(self, value: pulumi.Input[_builtins.str]):
|
|
202
201
|
pulumi.set(self, "schema", value)
|
|
203
202
|
|
|
204
|
-
@property
|
|
203
|
+
@_builtins.property
|
|
205
204
|
@pulumi.getter(name="allowDuplicate")
|
|
206
|
-
def allow_duplicate(self) -> Optional[pulumi.Input[
|
|
205
|
+
def allow_duplicate(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
207
206
|
"""
|
|
208
207
|
Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
209
208
|
"""
|
|
210
209
|
return pulumi.get(self, "allow_duplicate")
|
|
211
210
|
|
|
212
211
|
@allow_duplicate.setter
|
|
213
|
-
def allow_duplicate(self, value: Optional[pulumi.Input[
|
|
212
|
+
def allow_duplicate(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
214
213
|
pulumi.set(self, "allow_duplicate", value)
|
|
215
214
|
|
|
216
|
-
@property
|
|
215
|
+
@_builtins.property
|
|
217
216
|
@pulumi.getter(name="binaryAsText")
|
|
218
|
-
def binary_as_text(self) -> Optional[pulumi.Input[
|
|
217
|
+
def binary_as_text(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
219
218
|
"""
|
|
220
219
|
Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
221
220
|
"""
|
|
222
221
|
return pulumi.get(self, "binary_as_text")
|
|
223
222
|
|
|
224
223
|
@binary_as_text.setter
|
|
225
|
-
def binary_as_text(self, value: Optional[pulumi.Input[
|
|
224
|
+
def binary_as_text(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
226
225
|
pulumi.set(self, "binary_as_text", value)
|
|
227
226
|
|
|
228
|
-
@property
|
|
227
|
+
@_builtins.property
|
|
229
228
|
@pulumi.getter(name="binaryFormat")
|
|
230
|
-
def binary_format(self) -> Optional[pulumi.Input[
|
|
229
|
+
def binary_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
231
230
|
"""
|
|
232
231
|
Defines the encoding format for binary input or output.
|
|
233
232
|
"""
|
|
234
233
|
return pulumi.get(self, "binary_format")
|
|
235
234
|
|
|
236
235
|
@binary_format.setter
|
|
237
|
-
def binary_format(self, value: Optional[pulumi.Input[
|
|
236
|
+
def binary_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
238
237
|
pulumi.set(self, "binary_format", value)
|
|
239
238
|
|
|
240
|
-
@property
|
|
239
|
+
@_builtins.property
|
|
241
240
|
@pulumi.getter
|
|
242
|
-
def comment(self) -> Optional[pulumi.Input[
|
|
241
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
243
242
|
"""
|
|
244
243
|
Specifies a comment for the file format.
|
|
245
244
|
"""
|
|
246
245
|
return pulumi.get(self, "comment")
|
|
247
246
|
|
|
248
247
|
@comment.setter
|
|
249
|
-
def comment(self, value: Optional[pulumi.Input[
|
|
248
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
250
249
|
pulumi.set(self, "comment", value)
|
|
251
250
|
|
|
252
|
-
@property
|
|
251
|
+
@_builtins.property
|
|
253
252
|
@pulumi.getter
|
|
254
|
-
def compression(self) -> Optional[pulumi.Input[
|
|
253
|
+
def compression(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
255
254
|
"""
|
|
256
255
|
Specifies the current compression algorithm for the data file.
|
|
257
256
|
"""
|
|
258
257
|
return pulumi.get(self, "compression")
|
|
259
258
|
|
|
260
259
|
@compression.setter
|
|
261
|
-
def compression(self, value: Optional[pulumi.Input[
|
|
260
|
+
def compression(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
262
261
|
pulumi.set(self, "compression", value)
|
|
263
262
|
|
|
264
|
-
@property
|
|
263
|
+
@_builtins.property
|
|
265
264
|
@pulumi.getter(name="dateFormat")
|
|
266
|
-
def date_format(self) -> Optional[pulumi.Input[
|
|
265
|
+
def date_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
267
266
|
"""
|
|
268
267
|
Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
269
268
|
"""
|
|
270
269
|
return pulumi.get(self, "date_format")
|
|
271
270
|
|
|
272
271
|
@date_format.setter
|
|
273
|
-
def date_format(self, value: Optional[pulumi.Input[
|
|
272
|
+
def date_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
274
273
|
pulumi.set(self, "date_format", value)
|
|
275
274
|
|
|
276
|
-
@property
|
|
275
|
+
@_builtins.property
|
|
277
276
|
@pulumi.getter(name="disableAutoConvert")
|
|
278
|
-
def disable_auto_convert(self) -> Optional[pulumi.Input[
|
|
277
|
+
def disable_auto_convert(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
279
278
|
"""
|
|
280
279
|
Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
281
280
|
"""
|
|
282
281
|
return pulumi.get(self, "disable_auto_convert")
|
|
283
282
|
|
|
284
283
|
@disable_auto_convert.setter
|
|
285
|
-
def disable_auto_convert(self, value: Optional[pulumi.Input[
|
|
284
|
+
def disable_auto_convert(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
286
285
|
pulumi.set(self, "disable_auto_convert", value)
|
|
287
286
|
|
|
288
|
-
@property
|
|
287
|
+
@_builtins.property
|
|
289
288
|
@pulumi.getter(name="disableSnowflakeData")
|
|
290
|
-
def disable_snowflake_data(self) -> Optional[pulumi.Input[
|
|
289
|
+
def disable_snowflake_data(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
291
290
|
"""
|
|
292
291
|
Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
293
292
|
"""
|
|
294
293
|
return pulumi.get(self, "disable_snowflake_data")
|
|
295
294
|
|
|
296
295
|
@disable_snowflake_data.setter
|
|
297
|
-
def disable_snowflake_data(self, value: Optional[pulumi.Input[
|
|
296
|
+
def disable_snowflake_data(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
298
297
|
pulumi.set(self, "disable_snowflake_data", value)
|
|
299
298
|
|
|
300
|
-
@property
|
|
299
|
+
@_builtins.property
|
|
301
300
|
@pulumi.getter(name="emptyFieldAsNull")
|
|
302
|
-
def empty_field_as_null(self) -> Optional[pulumi.Input[
|
|
301
|
+
def empty_field_as_null(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
303
302
|
"""
|
|
304
303
|
Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
305
304
|
"""
|
|
306
305
|
return pulumi.get(self, "empty_field_as_null")
|
|
307
306
|
|
|
308
307
|
@empty_field_as_null.setter
|
|
309
|
-
def empty_field_as_null(self, value: Optional[pulumi.Input[
|
|
308
|
+
def empty_field_as_null(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
310
309
|
pulumi.set(self, "empty_field_as_null", value)
|
|
311
310
|
|
|
312
|
-
@property
|
|
311
|
+
@_builtins.property
|
|
313
312
|
@pulumi.getter(name="enableOctal")
|
|
314
|
-
def enable_octal(self) -> Optional[pulumi.Input[
|
|
313
|
+
def enable_octal(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
315
314
|
"""
|
|
316
315
|
Boolean that enables parsing of octal numbers.
|
|
317
316
|
"""
|
|
318
317
|
return pulumi.get(self, "enable_octal")
|
|
319
318
|
|
|
320
319
|
@enable_octal.setter
|
|
321
|
-
def enable_octal(self, value: Optional[pulumi.Input[
|
|
320
|
+
def enable_octal(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
322
321
|
pulumi.set(self, "enable_octal", value)
|
|
323
322
|
|
|
324
|
-
@property
|
|
323
|
+
@_builtins.property
|
|
325
324
|
@pulumi.getter
|
|
326
|
-
def encoding(self) -> Optional[pulumi.Input[
|
|
325
|
+
def encoding(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
327
326
|
"""
|
|
328
327
|
String (constant) that specifies the character set of the source data when loading data into a table.
|
|
329
328
|
"""
|
|
330
329
|
return pulumi.get(self, "encoding")
|
|
331
330
|
|
|
332
331
|
@encoding.setter
|
|
333
|
-
def encoding(self, value: Optional[pulumi.Input[
|
|
332
|
+
def encoding(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
334
333
|
pulumi.set(self, "encoding", value)
|
|
335
334
|
|
|
336
|
-
@property
|
|
335
|
+
@_builtins.property
|
|
337
336
|
@pulumi.getter(name="errorOnColumnCountMismatch")
|
|
338
|
-
def error_on_column_count_mismatch(self) -> Optional[pulumi.Input[
|
|
337
|
+
def error_on_column_count_mismatch(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
339
338
|
"""
|
|
340
339
|
Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
341
340
|
"""
|
|
342
341
|
return pulumi.get(self, "error_on_column_count_mismatch")
|
|
343
342
|
|
|
344
343
|
@error_on_column_count_mismatch.setter
|
|
345
|
-
def error_on_column_count_mismatch(self, value: Optional[pulumi.Input[
|
|
344
|
+
def error_on_column_count_mismatch(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
346
345
|
pulumi.set(self, "error_on_column_count_mismatch", value)
|
|
347
346
|
|
|
348
|
-
@property
|
|
347
|
+
@_builtins.property
|
|
349
348
|
@pulumi.getter
|
|
350
|
-
def escape(self) -> Optional[pulumi.Input[
|
|
349
|
+
def escape(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
351
350
|
"""
|
|
352
351
|
Single character string used as the escape character for field values.
|
|
353
352
|
"""
|
|
354
353
|
return pulumi.get(self, "escape")
|
|
355
354
|
|
|
356
355
|
@escape.setter
|
|
357
|
-
def escape(self, value: Optional[pulumi.Input[
|
|
356
|
+
def escape(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
358
357
|
pulumi.set(self, "escape", value)
|
|
359
358
|
|
|
360
|
-
@property
|
|
359
|
+
@_builtins.property
|
|
361
360
|
@pulumi.getter(name="escapeUnenclosedField")
|
|
362
|
-
def escape_unenclosed_field(self) -> Optional[pulumi.Input[
|
|
361
|
+
def escape_unenclosed_field(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
363
362
|
"""
|
|
364
363
|
Single character string used as the escape character for unenclosed field values only.
|
|
365
364
|
"""
|
|
366
365
|
return pulumi.get(self, "escape_unenclosed_field")
|
|
367
366
|
|
|
368
367
|
@escape_unenclosed_field.setter
|
|
369
|
-
def escape_unenclosed_field(self, value: Optional[pulumi.Input[
|
|
368
|
+
def escape_unenclosed_field(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
370
369
|
pulumi.set(self, "escape_unenclosed_field", value)
|
|
371
370
|
|
|
372
|
-
@property
|
|
371
|
+
@_builtins.property
|
|
373
372
|
@pulumi.getter(name="fieldDelimiter")
|
|
374
|
-
def field_delimiter(self) -> Optional[pulumi.Input[
|
|
373
|
+
def field_delimiter(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
375
374
|
"""
|
|
376
375
|
Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
377
376
|
"""
|
|
378
377
|
return pulumi.get(self, "field_delimiter")
|
|
379
378
|
|
|
380
379
|
@field_delimiter.setter
|
|
381
|
-
def field_delimiter(self, value: Optional[pulumi.Input[
|
|
380
|
+
def field_delimiter(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
382
381
|
pulumi.set(self, "field_delimiter", value)
|
|
383
382
|
|
|
384
|
-
@property
|
|
383
|
+
@_builtins.property
|
|
385
384
|
@pulumi.getter(name="fieldOptionallyEnclosedBy")
|
|
386
|
-
def field_optionally_enclosed_by(self) -> Optional[pulumi.Input[
|
|
385
|
+
def field_optionally_enclosed_by(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
387
386
|
"""
|
|
388
387
|
Character used to enclose strings.
|
|
389
388
|
"""
|
|
390
389
|
return pulumi.get(self, "field_optionally_enclosed_by")
|
|
391
390
|
|
|
392
391
|
@field_optionally_enclosed_by.setter
|
|
393
|
-
def field_optionally_enclosed_by(self, value: Optional[pulumi.Input[
|
|
392
|
+
def field_optionally_enclosed_by(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
394
393
|
pulumi.set(self, "field_optionally_enclosed_by", value)
|
|
395
394
|
|
|
396
|
-
@property
|
|
395
|
+
@_builtins.property
|
|
397
396
|
@pulumi.getter(name="fileExtension")
|
|
398
|
-
def file_extension(self) -> Optional[pulumi.Input[
|
|
397
|
+
def file_extension(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
399
398
|
"""
|
|
400
399
|
Specifies the extension for files unloaded to a stage.
|
|
401
400
|
"""
|
|
402
401
|
return pulumi.get(self, "file_extension")
|
|
403
402
|
|
|
404
403
|
@file_extension.setter
|
|
405
|
-
def file_extension(self, value: Optional[pulumi.Input[
|
|
404
|
+
def file_extension(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
406
405
|
pulumi.set(self, "file_extension", value)
|
|
407
406
|
|
|
408
|
-
@property
|
|
407
|
+
@_builtins.property
|
|
409
408
|
@pulumi.getter(name="ignoreUtf8Errors")
|
|
410
|
-
def ignore_utf8_errors(self) -> Optional[pulumi.Input[
|
|
409
|
+
def ignore_utf8_errors(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
411
410
|
"""
|
|
412
411
|
Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
413
412
|
"""
|
|
414
413
|
return pulumi.get(self, "ignore_utf8_errors")
|
|
415
414
|
|
|
416
415
|
@ignore_utf8_errors.setter
|
|
417
|
-
def ignore_utf8_errors(self, value: Optional[pulumi.Input[
|
|
416
|
+
def ignore_utf8_errors(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
418
417
|
pulumi.set(self, "ignore_utf8_errors", value)
|
|
419
418
|
|
|
420
|
-
@property
|
|
419
|
+
@_builtins.property
|
|
421
420
|
@pulumi.getter
|
|
422
|
-
def name(self) -> Optional[pulumi.Input[
|
|
421
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
423
422
|
"""
|
|
424
423
|
Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
425
424
|
"""
|
|
426
425
|
return pulumi.get(self, "name")
|
|
427
426
|
|
|
428
427
|
@name.setter
|
|
429
|
-
def name(self, value: Optional[pulumi.Input[
|
|
428
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
430
429
|
pulumi.set(self, "name", value)
|
|
431
430
|
|
|
432
|
-
@property
|
|
431
|
+
@_builtins.property
|
|
433
432
|
@pulumi.getter(name="nullIfs")
|
|
434
|
-
def null_ifs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
433
|
+
def null_ifs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
435
434
|
"""
|
|
436
435
|
String used to convert to and from SQL NULL.
|
|
437
436
|
"""
|
|
438
437
|
return pulumi.get(self, "null_ifs")
|
|
439
438
|
|
|
440
439
|
@null_ifs.setter
|
|
441
|
-
def null_ifs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
440
|
+
def null_ifs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
442
441
|
pulumi.set(self, "null_ifs", value)
|
|
443
442
|
|
|
444
|
-
@property
|
|
443
|
+
@_builtins.property
|
|
445
444
|
@pulumi.getter(name="parseHeader")
|
|
446
|
-
def parse_header(self) -> Optional[pulumi.Input[
|
|
445
|
+
def parse_header(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
447
446
|
"""
|
|
448
447
|
Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
449
448
|
"""
|
|
450
449
|
return pulumi.get(self, "parse_header")
|
|
451
450
|
|
|
452
451
|
@parse_header.setter
|
|
453
|
-
def parse_header(self, value: Optional[pulumi.Input[
|
|
452
|
+
def parse_header(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
454
453
|
pulumi.set(self, "parse_header", value)
|
|
455
454
|
|
|
456
|
-
@property
|
|
455
|
+
@_builtins.property
|
|
457
456
|
@pulumi.getter(name="preserveSpace")
|
|
458
|
-
def preserve_space(self) -> Optional[pulumi.Input[
|
|
457
|
+
def preserve_space(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
459
458
|
"""
|
|
460
459
|
Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
461
460
|
"""
|
|
462
461
|
return pulumi.get(self, "preserve_space")
|
|
463
462
|
|
|
464
463
|
@preserve_space.setter
|
|
465
|
-
def preserve_space(self, value: Optional[pulumi.Input[
|
|
464
|
+
def preserve_space(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
466
465
|
pulumi.set(self, "preserve_space", value)
|
|
467
466
|
|
|
468
|
-
@property
|
|
467
|
+
@_builtins.property
|
|
469
468
|
@pulumi.getter(name="recordDelimiter")
|
|
470
|
-
def record_delimiter(self) -> Optional[pulumi.Input[
|
|
469
|
+
def record_delimiter(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
471
470
|
"""
|
|
472
471
|
Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
473
472
|
"""
|
|
474
473
|
return pulumi.get(self, "record_delimiter")
|
|
475
474
|
|
|
476
475
|
@record_delimiter.setter
|
|
477
|
-
def record_delimiter(self, value: Optional[pulumi.Input[
|
|
476
|
+
def record_delimiter(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
478
477
|
pulumi.set(self, "record_delimiter", value)
|
|
479
478
|
|
|
480
|
-
@property
|
|
479
|
+
@_builtins.property
|
|
481
480
|
@pulumi.getter(name="replaceInvalidCharacters")
|
|
482
|
-
def replace_invalid_characters(self) -> Optional[pulumi.Input[
|
|
481
|
+
def replace_invalid_characters(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
483
482
|
"""
|
|
484
483
|
Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
485
484
|
"""
|
|
486
485
|
return pulumi.get(self, "replace_invalid_characters")
|
|
487
486
|
|
|
488
487
|
@replace_invalid_characters.setter
|
|
489
|
-
def replace_invalid_characters(self, value: Optional[pulumi.Input[
|
|
488
|
+
def replace_invalid_characters(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
490
489
|
pulumi.set(self, "replace_invalid_characters", value)
|
|
491
490
|
|
|
492
|
-
@property
|
|
491
|
+
@_builtins.property
|
|
493
492
|
@pulumi.getter(name="skipBlankLines")
|
|
494
|
-
def skip_blank_lines(self) -> Optional[pulumi.Input[
|
|
493
|
+
def skip_blank_lines(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
495
494
|
"""
|
|
496
495
|
Boolean that specifies to skip any blank lines encountered in the data files.
|
|
497
496
|
"""
|
|
498
497
|
return pulumi.get(self, "skip_blank_lines")
|
|
499
498
|
|
|
500
499
|
@skip_blank_lines.setter
|
|
501
|
-
def skip_blank_lines(self, value: Optional[pulumi.Input[
|
|
500
|
+
def skip_blank_lines(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
502
501
|
pulumi.set(self, "skip_blank_lines", value)
|
|
503
502
|
|
|
504
|
-
@property
|
|
503
|
+
@_builtins.property
|
|
505
504
|
@pulumi.getter(name="skipByteOrderMark")
|
|
506
|
-
def skip_byte_order_mark(self) -> Optional[pulumi.Input[
|
|
505
|
+
def skip_byte_order_mark(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
507
506
|
"""
|
|
508
507
|
Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
509
508
|
"""
|
|
510
509
|
return pulumi.get(self, "skip_byte_order_mark")
|
|
511
510
|
|
|
512
511
|
@skip_byte_order_mark.setter
|
|
513
|
-
def skip_byte_order_mark(self, value: Optional[pulumi.Input[
|
|
512
|
+
def skip_byte_order_mark(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
514
513
|
pulumi.set(self, "skip_byte_order_mark", value)
|
|
515
514
|
|
|
516
|
-
@property
|
|
515
|
+
@_builtins.property
|
|
517
516
|
@pulumi.getter(name="skipHeader")
|
|
518
|
-
def skip_header(self) -> Optional[pulumi.Input[
|
|
517
|
+
def skip_header(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
519
518
|
"""
|
|
520
519
|
Number of lines at the start of the file to skip.
|
|
521
520
|
"""
|
|
522
521
|
return pulumi.get(self, "skip_header")
|
|
523
522
|
|
|
524
523
|
@skip_header.setter
|
|
525
|
-
def skip_header(self, value: Optional[pulumi.Input[
|
|
524
|
+
def skip_header(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
526
525
|
pulumi.set(self, "skip_header", value)
|
|
527
526
|
|
|
528
|
-
@property
|
|
527
|
+
@_builtins.property
|
|
529
528
|
@pulumi.getter(name="stripNullValues")
|
|
530
|
-
def strip_null_values(self) -> Optional[pulumi.Input[
|
|
529
|
+
def strip_null_values(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
531
530
|
"""
|
|
532
531
|
Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
533
532
|
"""
|
|
534
533
|
return pulumi.get(self, "strip_null_values")
|
|
535
534
|
|
|
536
535
|
@strip_null_values.setter
|
|
537
|
-
def strip_null_values(self, value: Optional[pulumi.Input[
|
|
536
|
+
def strip_null_values(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
538
537
|
pulumi.set(self, "strip_null_values", value)
|
|
539
538
|
|
|
540
|
-
@property
|
|
539
|
+
@_builtins.property
|
|
541
540
|
@pulumi.getter(name="stripOuterArray")
|
|
542
|
-
def strip_outer_array(self) -> Optional[pulumi.Input[
|
|
541
|
+
def strip_outer_array(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
543
542
|
"""
|
|
544
543
|
Boolean that instructs the JSON parser to remove outer brackets.
|
|
545
544
|
"""
|
|
546
545
|
return pulumi.get(self, "strip_outer_array")
|
|
547
546
|
|
|
548
547
|
@strip_outer_array.setter
|
|
549
|
-
def strip_outer_array(self, value: Optional[pulumi.Input[
|
|
548
|
+
def strip_outer_array(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
550
549
|
pulumi.set(self, "strip_outer_array", value)
|
|
551
550
|
|
|
552
|
-
@property
|
|
551
|
+
@_builtins.property
|
|
553
552
|
@pulumi.getter(name="stripOuterElement")
|
|
554
|
-
def strip_outer_element(self) -> Optional[pulumi.Input[
|
|
553
|
+
def strip_outer_element(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
555
554
|
"""
|
|
556
555
|
Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
557
556
|
"""
|
|
558
557
|
return pulumi.get(self, "strip_outer_element")
|
|
559
558
|
|
|
560
559
|
@strip_outer_element.setter
|
|
561
|
-
def strip_outer_element(self, value: Optional[pulumi.Input[
|
|
560
|
+
def strip_outer_element(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
562
561
|
pulumi.set(self, "strip_outer_element", value)
|
|
563
562
|
|
|
564
|
-
@property
|
|
563
|
+
@_builtins.property
|
|
565
564
|
@pulumi.getter(name="timeFormat")
|
|
566
|
-
def time_format(self) -> Optional[pulumi.Input[
|
|
565
|
+
def time_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
567
566
|
"""
|
|
568
567
|
Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
569
568
|
"""
|
|
570
569
|
return pulumi.get(self, "time_format")
|
|
571
570
|
|
|
572
571
|
@time_format.setter
|
|
573
|
-
def time_format(self, value: Optional[pulumi.Input[
|
|
572
|
+
def time_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
574
573
|
pulumi.set(self, "time_format", value)
|
|
575
574
|
|
|
576
|
-
@property
|
|
575
|
+
@_builtins.property
|
|
577
576
|
@pulumi.getter(name="timestampFormat")
|
|
578
|
-
def timestamp_format(self) -> Optional[pulumi.Input[
|
|
577
|
+
def timestamp_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
579
578
|
"""
|
|
580
579
|
Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
581
580
|
"""
|
|
582
581
|
return pulumi.get(self, "timestamp_format")
|
|
583
582
|
|
|
584
583
|
@timestamp_format.setter
|
|
585
|
-
def timestamp_format(self, value: Optional[pulumi.Input[
|
|
584
|
+
def timestamp_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
586
585
|
pulumi.set(self, "timestamp_format", value)
|
|
587
586
|
|
|
588
|
-
@property
|
|
587
|
+
@_builtins.property
|
|
589
588
|
@pulumi.getter(name="trimSpace")
|
|
590
|
-
def trim_space(self) -> Optional[pulumi.Input[
|
|
589
|
+
def trim_space(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
591
590
|
"""
|
|
592
591
|
Boolean that specifies whether to remove white space from fields.
|
|
593
592
|
"""
|
|
594
593
|
return pulumi.get(self, "trim_space")
|
|
595
594
|
|
|
596
595
|
@trim_space.setter
|
|
597
|
-
def trim_space(self, value: Optional[pulumi.Input[
|
|
596
|
+
def trim_space(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
598
597
|
pulumi.set(self, "trim_space", value)
|
|
599
598
|
|
|
600
599
|
|
|
601
600
|
@pulumi.input_type
|
|
602
601
|
class _FileFormatState:
|
|
603
602
|
def __init__(__self__, *,
|
|
604
|
-
allow_duplicate: Optional[pulumi.Input[
|
|
605
|
-
binary_as_text: Optional[pulumi.Input[
|
|
606
|
-
binary_format: Optional[pulumi.Input[
|
|
607
|
-
comment: Optional[pulumi.Input[
|
|
608
|
-
compression: Optional[pulumi.Input[
|
|
609
|
-
database: Optional[pulumi.Input[
|
|
610
|
-
date_format: Optional[pulumi.Input[
|
|
611
|
-
disable_auto_convert: Optional[pulumi.Input[
|
|
612
|
-
disable_snowflake_data: Optional[pulumi.Input[
|
|
613
|
-
empty_field_as_null: Optional[pulumi.Input[
|
|
614
|
-
enable_octal: Optional[pulumi.Input[
|
|
615
|
-
encoding: Optional[pulumi.Input[
|
|
616
|
-
error_on_column_count_mismatch: Optional[pulumi.Input[
|
|
617
|
-
escape: Optional[pulumi.Input[
|
|
618
|
-
escape_unenclosed_field: Optional[pulumi.Input[
|
|
619
|
-
field_delimiter: Optional[pulumi.Input[
|
|
620
|
-
field_optionally_enclosed_by: Optional[pulumi.Input[
|
|
621
|
-
file_extension: Optional[pulumi.Input[
|
|
622
|
-
format_type: Optional[pulumi.Input[
|
|
623
|
-
fully_qualified_name: Optional[pulumi.Input[
|
|
624
|
-
ignore_utf8_errors: Optional[pulumi.Input[
|
|
625
|
-
name: Optional[pulumi.Input[
|
|
626
|
-
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
627
|
-
parse_header: Optional[pulumi.Input[
|
|
628
|
-
preserve_space: Optional[pulumi.Input[
|
|
629
|
-
record_delimiter: Optional[pulumi.Input[
|
|
630
|
-
replace_invalid_characters: Optional[pulumi.Input[
|
|
631
|
-
schema: Optional[pulumi.Input[
|
|
632
|
-
skip_blank_lines: Optional[pulumi.Input[
|
|
633
|
-
skip_byte_order_mark: Optional[pulumi.Input[
|
|
634
|
-
skip_header: Optional[pulumi.Input[
|
|
635
|
-
strip_null_values: Optional[pulumi.Input[
|
|
636
|
-
strip_outer_array: Optional[pulumi.Input[
|
|
637
|
-
strip_outer_element: Optional[pulumi.Input[
|
|
638
|
-
time_format: Optional[pulumi.Input[
|
|
639
|
-
timestamp_format: Optional[pulumi.Input[
|
|
640
|
-
trim_space: Optional[pulumi.Input[
|
|
603
|
+
allow_duplicate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
604
|
+
binary_as_text: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
605
|
+
binary_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
606
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
607
|
+
compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
608
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
609
|
+
date_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
610
|
+
disable_auto_convert: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
611
|
+
disable_snowflake_data: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
612
|
+
empty_field_as_null: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
613
|
+
enable_octal: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
614
|
+
encoding: Optional[pulumi.Input[_builtins.str]] = None,
|
|
615
|
+
error_on_column_count_mismatch: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
616
|
+
escape: Optional[pulumi.Input[_builtins.str]] = None,
|
|
617
|
+
escape_unenclosed_field: Optional[pulumi.Input[_builtins.str]] = None,
|
|
618
|
+
field_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
619
|
+
field_optionally_enclosed_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
620
|
+
file_extension: Optional[pulumi.Input[_builtins.str]] = None,
|
|
621
|
+
format_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
622
|
+
fully_qualified_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
623
|
+
ignore_utf8_errors: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
624
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
625
|
+
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
626
|
+
parse_header: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
627
|
+
preserve_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
628
|
+
record_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
629
|
+
replace_invalid_characters: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
630
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
631
|
+
skip_blank_lines: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
632
|
+
skip_byte_order_mark: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
633
|
+
skip_header: Optional[pulumi.Input[_builtins.int]] = None,
|
|
634
|
+
strip_null_values: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
635
|
+
strip_outer_array: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
636
|
+
strip_outer_element: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
637
|
+
time_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
638
|
+
timestamp_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
639
|
+
trim_space: Optional[pulumi.Input[_builtins.bool]] = None):
|
|
641
640
|
"""
|
|
642
641
|
Input properties used for looking up and filtering FileFormat resources.
|
|
643
|
-
:param pulumi.Input[
|
|
644
|
-
:param pulumi.Input[
|
|
645
|
-
:param pulumi.Input[
|
|
646
|
-
:param pulumi.Input[
|
|
647
|
-
:param pulumi.Input[
|
|
648
|
-
:param pulumi.Input[
|
|
649
|
-
:param pulumi.Input[
|
|
650
|
-
:param pulumi.Input[
|
|
651
|
-
:param pulumi.Input[
|
|
652
|
-
:param pulumi.Input[
|
|
653
|
-
:param pulumi.Input[
|
|
654
|
-
:param pulumi.Input[
|
|
655
|
-
:param pulumi.Input[
|
|
656
|
-
:param pulumi.Input[
|
|
657
|
-
:param pulumi.Input[
|
|
658
|
-
:param pulumi.Input[
|
|
659
|
-
:param pulumi.Input[
|
|
660
|
-
:param pulumi.Input[
|
|
661
|
-
:param pulumi.Input[
|
|
662
|
-
:param pulumi.Input[
|
|
663
|
-
:param pulumi.Input[
|
|
664
|
-
:param pulumi.Input[
|
|
665
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
666
|
-
:param pulumi.Input[
|
|
667
|
-
:param pulumi.Input[
|
|
668
|
-
:param pulumi.Input[
|
|
669
|
-
:param pulumi.Input[
|
|
670
|
-
:param pulumi.Input[
|
|
671
|
-
:param pulumi.Input[
|
|
672
|
-
:param pulumi.Input[
|
|
673
|
-
:param pulumi.Input[
|
|
674
|
-
:param pulumi.Input[
|
|
675
|
-
:param pulumi.Input[
|
|
676
|
-
:param pulumi.Input[
|
|
677
|
-
:param pulumi.Input[
|
|
678
|
-
:param pulumi.Input[
|
|
679
|
-
:param pulumi.Input[
|
|
642
|
+
:param pulumi.Input[_builtins.bool] allow_duplicate: Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
643
|
+
:param pulumi.Input[_builtins.bool] binary_as_text: Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
644
|
+
:param pulumi.Input[_builtins.str] binary_format: Defines the encoding format for binary input or output.
|
|
645
|
+
:param pulumi.Input[_builtins.str] comment: Specifies a comment for the file format.
|
|
646
|
+
:param pulumi.Input[_builtins.str] compression: Specifies the current compression algorithm for the data file.
|
|
647
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the file format.
|
|
648
|
+
:param pulumi.Input[_builtins.str] date_format: Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
649
|
+
:param pulumi.Input[_builtins.bool] disable_auto_convert: Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
650
|
+
:param pulumi.Input[_builtins.bool] disable_snowflake_data: Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
651
|
+
:param pulumi.Input[_builtins.bool] empty_field_as_null: Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
652
|
+
:param pulumi.Input[_builtins.bool] enable_octal: Boolean that enables parsing of octal numbers.
|
|
653
|
+
:param pulumi.Input[_builtins.str] encoding: String (constant) that specifies the character set of the source data when loading data into a table.
|
|
654
|
+
:param pulumi.Input[_builtins.bool] error_on_column_count_mismatch: Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
655
|
+
:param pulumi.Input[_builtins.str] escape: Single character string used as the escape character for field values.
|
|
656
|
+
:param pulumi.Input[_builtins.str] escape_unenclosed_field: Single character string used as the escape character for unenclosed field values only.
|
|
657
|
+
:param pulumi.Input[_builtins.str] field_delimiter: Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
658
|
+
:param pulumi.Input[_builtins.str] field_optionally_enclosed_by: Character used to enclose strings.
|
|
659
|
+
:param pulumi.Input[_builtins.str] file_extension: Specifies the extension for files unloaded to a stage.
|
|
660
|
+
:param pulumi.Input[_builtins.str] format_type: Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
661
|
+
:param pulumi.Input[_builtins.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).
|
|
662
|
+
:param pulumi.Input[_builtins.bool] ignore_utf8_errors: Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
663
|
+
:param pulumi.Input[_builtins.str] name: Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
664
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] null_ifs: String used to convert to and from SQL NULL.
|
|
665
|
+
:param pulumi.Input[_builtins.bool] parse_header: Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
666
|
+
:param pulumi.Input[_builtins.bool] preserve_space: Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
667
|
+
:param pulumi.Input[_builtins.str] record_delimiter: Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
668
|
+
:param pulumi.Input[_builtins.bool] replace_invalid_characters: Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
669
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the file format.
|
|
670
|
+
:param pulumi.Input[_builtins.bool] skip_blank_lines: Boolean that specifies to skip any blank lines encountered in the data files.
|
|
671
|
+
:param pulumi.Input[_builtins.bool] skip_byte_order_mark: Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
672
|
+
:param pulumi.Input[_builtins.int] skip_header: Number of lines at the start of the file to skip.
|
|
673
|
+
:param pulumi.Input[_builtins.bool] strip_null_values: Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
674
|
+
:param pulumi.Input[_builtins.bool] strip_outer_array: Boolean that instructs the JSON parser to remove outer brackets.
|
|
675
|
+
:param pulumi.Input[_builtins.bool] strip_outer_element: Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
676
|
+
:param pulumi.Input[_builtins.str] time_format: Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
677
|
+
:param pulumi.Input[_builtins.str] timestamp_format: Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
678
|
+
:param pulumi.Input[_builtins.bool] trim_space: Boolean that specifies whether to remove white space from fields.
|
|
680
679
|
"""
|
|
681
680
|
if allow_duplicate is not None:
|
|
682
681
|
pulumi.set(__self__, "allow_duplicate", allow_duplicate)
|
|
@@ -753,448 +752,448 @@ class _FileFormatState:
|
|
|
753
752
|
if trim_space is not None:
|
|
754
753
|
pulumi.set(__self__, "trim_space", trim_space)
|
|
755
754
|
|
|
756
|
-
@property
|
|
755
|
+
@_builtins.property
|
|
757
756
|
@pulumi.getter(name="allowDuplicate")
|
|
758
|
-
def allow_duplicate(self) -> Optional[pulumi.Input[
|
|
757
|
+
def allow_duplicate(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
759
758
|
"""
|
|
760
759
|
Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
761
760
|
"""
|
|
762
761
|
return pulumi.get(self, "allow_duplicate")
|
|
763
762
|
|
|
764
763
|
@allow_duplicate.setter
|
|
765
|
-
def allow_duplicate(self, value: Optional[pulumi.Input[
|
|
764
|
+
def allow_duplicate(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
766
765
|
pulumi.set(self, "allow_duplicate", value)
|
|
767
766
|
|
|
768
|
-
@property
|
|
767
|
+
@_builtins.property
|
|
769
768
|
@pulumi.getter(name="binaryAsText")
|
|
770
|
-
def binary_as_text(self) -> Optional[pulumi.Input[
|
|
769
|
+
def binary_as_text(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
771
770
|
"""
|
|
772
771
|
Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
773
772
|
"""
|
|
774
773
|
return pulumi.get(self, "binary_as_text")
|
|
775
774
|
|
|
776
775
|
@binary_as_text.setter
|
|
777
|
-
def binary_as_text(self, value: Optional[pulumi.Input[
|
|
776
|
+
def binary_as_text(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
778
777
|
pulumi.set(self, "binary_as_text", value)
|
|
779
778
|
|
|
780
|
-
@property
|
|
779
|
+
@_builtins.property
|
|
781
780
|
@pulumi.getter(name="binaryFormat")
|
|
782
|
-
def binary_format(self) -> Optional[pulumi.Input[
|
|
781
|
+
def binary_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
783
782
|
"""
|
|
784
783
|
Defines the encoding format for binary input or output.
|
|
785
784
|
"""
|
|
786
785
|
return pulumi.get(self, "binary_format")
|
|
787
786
|
|
|
788
787
|
@binary_format.setter
|
|
789
|
-
def binary_format(self, value: Optional[pulumi.Input[
|
|
788
|
+
def binary_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
790
789
|
pulumi.set(self, "binary_format", value)
|
|
791
790
|
|
|
792
|
-
@property
|
|
791
|
+
@_builtins.property
|
|
793
792
|
@pulumi.getter
|
|
794
|
-
def comment(self) -> Optional[pulumi.Input[
|
|
793
|
+
def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
795
794
|
"""
|
|
796
795
|
Specifies a comment for the file format.
|
|
797
796
|
"""
|
|
798
797
|
return pulumi.get(self, "comment")
|
|
799
798
|
|
|
800
799
|
@comment.setter
|
|
801
|
-
def comment(self, value: Optional[pulumi.Input[
|
|
800
|
+
def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
802
801
|
pulumi.set(self, "comment", value)
|
|
803
802
|
|
|
804
|
-
@property
|
|
803
|
+
@_builtins.property
|
|
805
804
|
@pulumi.getter
|
|
806
|
-
def compression(self) -> Optional[pulumi.Input[
|
|
805
|
+
def compression(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
807
806
|
"""
|
|
808
807
|
Specifies the current compression algorithm for the data file.
|
|
809
808
|
"""
|
|
810
809
|
return pulumi.get(self, "compression")
|
|
811
810
|
|
|
812
811
|
@compression.setter
|
|
813
|
-
def compression(self, value: Optional[pulumi.Input[
|
|
812
|
+
def compression(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
814
813
|
pulumi.set(self, "compression", value)
|
|
815
814
|
|
|
816
|
-
@property
|
|
815
|
+
@_builtins.property
|
|
817
816
|
@pulumi.getter
|
|
818
|
-
def database(self) -> Optional[pulumi.Input[
|
|
817
|
+
def database(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
819
818
|
"""
|
|
820
819
|
The database in which to create the file format.
|
|
821
820
|
"""
|
|
822
821
|
return pulumi.get(self, "database")
|
|
823
822
|
|
|
824
823
|
@database.setter
|
|
825
|
-
def database(self, value: Optional[pulumi.Input[
|
|
824
|
+
def database(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
826
825
|
pulumi.set(self, "database", value)
|
|
827
826
|
|
|
828
|
-
@property
|
|
827
|
+
@_builtins.property
|
|
829
828
|
@pulumi.getter(name="dateFormat")
|
|
830
|
-
def date_format(self) -> Optional[pulumi.Input[
|
|
829
|
+
def date_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
831
830
|
"""
|
|
832
831
|
Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
833
832
|
"""
|
|
834
833
|
return pulumi.get(self, "date_format")
|
|
835
834
|
|
|
836
835
|
@date_format.setter
|
|
837
|
-
def date_format(self, value: Optional[pulumi.Input[
|
|
836
|
+
def date_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
838
837
|
pulumi.set(self, "date_format", value)
|
|
839
838
|
|
|
840
|
-
@property
|
|
839
|
+
@_builtins.property
|
|
841
840
|
@pulumi.getter(name="disableAutoConvert")
|
|
842
|
-
def disable_auto_convert(self) -> Optional[pulumi.Input[
|
|
841
|
+
def disable_auto_convert(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
843
842
|
"""
|
|
844
843
|
Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
845
844
|
"""
|
|
846
845
|
return pulumi.get(self, "disable_auto_convert")
|
|
847
846
|
|
|
848
847
|
@disable_auto_convert.setter
|
|
849
|
-
def disable_auto_convert(self, value: Optional[pulumi.Input[
|
|
848
|
+
def disable_auto_convert(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
850
849
|
pulumi.set(self, "disable_auto_convert", value)
|
|
851
850
|
|
|
852
|
-
@property
|
|
851
|
+
@_builtins.property
|
|
853
852
|
@pulumi.getter(name="disableSnowflakeData")
|
|
854
|
-
def disable_snowflake_data(self) -> Optional[pulumi.Input[
|
|
853
|
+
def disable_snowflake_data(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
855
854
|
"""
|
|
856
855
|
Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
857
856
|
"""
|
|
858
857
|
return pulumi.get(self, "disable_snowflake_data")
|
|
859
858
|
|
|
860
859
|
@disable_snowflake_data.setter
|
|
861
|
-
def disable_snowflake_data(self, value: Optional[pulumi.Input[
|
|
860
|
+
def disable_snowflake_data(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
862
861
|
pulumi.set(self, "disable_snowflake_data", value)
|
|
863
862
|
|
|
864
|
-
@property
|
|
863
|
+
@_builtins.property
|
|
865
864
|
@pulumi.getter(name="emptyFieldAsNull")
|
|
866
|
-
def empty_field_as_null(self) -> Optional[pulumi.Input[
|
|
865
|
+
def empty_field_as_null(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
867
866
|
"""
|
|
868
867
|
Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
869
868
|
"""
|
|
870
869
|
return pulumi.get(self, "empty_field_as_null")
|
|
871
870
|
|
|
872
871
|
@empty_field_as_null.setter
|
|
873
|
-
def empty_field_as_null(self, value: Optional[pulumi.Input[
|
|
872
|
+
def empty_field_as_null(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
874
873
|
pulumi.set(self, "empty_field_as_null", value)
|
|
875
874
|
|
|
876
|
-
@property
|
|
875
|
+
@_builtins.property
|
|
877
876
|
@pulumi.getter(name="enableOctal")
|
|
878
|
-
def enable_octal(self) -> Optional[pulumi.Input[
|
|
877
|
+
def enable_octal(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
879
878
|
"""
|
|
880
879
|
Boolean that enables parsing of octal numbers.
|
|
881
880
|
"""
|
|
882
881
|
return pulumi.get(self, "enable_octal")
|
|
883
882
|
|
|
884
883
|
@enable_octal.setter
|
|
885
|
-
def enable_octal(self, value: Optional[pulumi.Input[
|
|
884
|
+
def enable_octal(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
886
885
|
pulumi.set(self, "enable_octal", value)
|
|
887
886
|
|
|
888
|
-
@property
|
|
887
|
+
@_builtins.property
|
|
889
888
|
@pulumi.getter
|
|
890
|
-
def encoding(self) -> Optional[pulumi.Input[
|
|
889
|
+
def encoding(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
891
890
|
"""
|
|
892
891
|
String (constant) that specifies the character set of the source data when loading data into a table.
|
|
893
892
|
"""
|
|
894
893
|
return pulumi.get(self, "encoding")
|
|
895
894
|
|
|
896
895
|
@encoding.setter
|
|
897
|
-
def encoding(self, value: Optional[pulumi.Input[
|
|
896
|
+
def encoding(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
898
897
|
pulumi.set(self, "encoding", value)
|
|
899
898
|
|
|
900
|
-
@property
|
|
899
|
+
@_builtins.property
|
|
901
900
|
@pulumi.getter(name="errorOnColumnCountMismatch")
|
|
902
|
-
def error_on_column_count_mismatch(self) -> Optional[pulumi.Input[
|
|
901
|
+
def error_on_column_count_mismatch(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
903
902
|
"""
|
|
904
903
|
Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
905
904
|
"""
|
|
906
905
|
return pulumi.get(self, "error_on_column_count_mismatch")
|
|
907
906
|
|
|
908
907
|
@error_on_column_count_mismatch.setter
|
|
909
|
-
def error_on_column_count_mismatch(self, value: Optional[pulumi.Input[
|
|
908
|
+
def error_on_column_count_mismatch(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
910
909
|
pulumi.set(self, "error_on_column_count_mismatch", value)
|
|
911
910
|
|
|
912
|
-
@property
|
|
911
|
+
@_builtins.property
|
|
913
912
|
@pulumi.getter
|
|
914
|
-
def escape(self) -> Optional[pulumi.Input[
|
|
913
|
+
def escape(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
915
914
|
"""
|
|
916
915
|
Single character string used as the escape character for field values.
|
|
917
916
|
"""
|
|
918
917
|
return pulumi.get(self, "escape")
|
|
919
918
|
|
|
920
919
|
@escape.setter
|
|
921
|
-
def escape(self, value: Optional[pulumi.Input[
|
|
920
|
+
def escape(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
922
921
|
pulumi.set(self, "escape", value)
|
|
923
922
|
|
|
924
|
-
@property
|
|
923
|
+
@_builtins.property
|
|
925
924
|
@pulumi.getter(name="escapeUnenclosedField")
|
|
926
|
-
def escape_unenclosed_field(self) -> Optional[pulumi.Input[
|
|
925
|
+
def escape_unenclosed_field(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
927
926
|
"""
|
|
928
927
|
Single character string used as the escape character for unenclosed field values only.
|
|
929
928
|
"""
|
|
930
929
|
return pulumi.get(self, "escape_unenclosed_field")
|
|
931
930
|
|
|
932
931
|
@escape_unenclosed_field.setter
|
|
933
|
-
def escape_unenclosed_field(self, value: Optional[pulumi.Input[
|
|
932
|
+
def escape_unenclosed_field(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
934
933
|
pulumi.set(self, "escape_unenclosed_field", value)
|
|
935
934
|
|
|
936
|
-
@property
|
|
935
|
+
@_builtins.property
|
|
937
936
|
@pulumi.getter(name="fieldDelimiter")
|
|
938
|
-
def field_delimiter(self) -> Optional[pulumi.Input[
|
|
937
|
+
def field_delimiter(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
939
938
|
"""
|
|
940
939
|
Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
941
940
|
"""
|
|
942
941
|
return pulumi.get(self, "field_delimiter")
|
|
943
942
|
|
|
944
943
|
@field_delimiter.setter
|
|
945
|
-
def field_delimiter(self, value: Optional[pulumi.Input[
|
|
944
|
+
def field_delimiter(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
946
945
|
pulumi.set(self, "field_delimiter", value)
|
|
947
946
|
|
|
948
|
-
@property
|
|
947
|
+
@_builtins.property
|
|
949
948
|
@pulumi.getter(name="fieldOptionallyEnclosedBy")
|
|
950
|
-
def field_optionally_enclosed_by(self) -> Optional[pulumi.Input[
|
|
949
|
+
def field_optionally_enclosed_by(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
951
950
|
"""
|
|
952
951
|
Character used to enclose strings.
|
|
953
952
|
"""
|
|
954
953
|
return pulumi.get(self, "field_optionally_enclosed_by")
|
|
955
954
|
|
|
956
955
|
@field_optionally_enclosed_by.setter
|
|
957
|
-
def field_optionally_enclosed_by(self, value: Optional[pulumi.Input[
|
|
956
|
+
def field_optionally_enclosed_by(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
958
957
|
pulumi.set(self, "field_optionally_enclosed_by", value)
|
|
959
958
|
|
|
960
|
-
@property
|
|
959
|
+
@_builtins.property
|
|
961
960
|
@pulumi.getter(name="fileExtension")
|
|
962
|
-
def file_extension(self) -> Optional[pulumi.Input[
|
|
961
|
+
def file_extension(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
963
962
|
"""
|
|
964
963
|
Specifies the extension for files unloaded to a stage.
|
|
965
964
|
"""
|
|
966
965
|
return pulumi.get(self, "file_extension")
|
|
967
966
|
|
|
968
967
|
@file_extension.setter
|
|
969
|
-
def file_extension(self, value: Optional[pulumi.Input[
|
|
968
|
+
def file_extension(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
970
969
|
pulumi.set(self, "file_extension", value)
|
|
971
970
|
|
|
972
|
-
@property
|
|
971
|
+
@_builtins.property
|
|
973
972
|
@pulumi.getter(name="formatType")
|
|
974
|
-
def format_type(self) -> Optional[pulumi.Input[
|
|
973
|
+
def format_type(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
975
974
|
"""
|
|
976
975
|
Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
977
976
|
"""
|
|
978
977
|
return pulumi.get(self, "format_type")
|
|
979
978
|
|
|
980
979
|
@format_type.setter
|
|
981
|
-
def format_type(self, value: Optional[pulumi.Input[
|
|
980
|
+
def format_type(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
982
981
|
pulumi.set(self, "format_type", value)
|
|
983
982
|
|
|
984
|
-
@property
|
|
983
|
+
@_builtins.property
|
|
985
984
|
@pulumi.getter(name="fullyQualifiedName")
|
|
986
|
-
def fully_qualified_name(self) -> Optional[pulumi.Input[
|
|
985
|
+
def fully_qualified_name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
987
986
|
"""
|
|
988
987
|
Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
989
988
|
"""
|
|
990
989
|
return pulumi.get(self, "fully_qualified_name")
|
|
991
990
|
|
|
992
991
|
@fully_qualified_name.setter
|
|
993
|
-
def fully_qualified_name(self, value: Optional[pulumi.Input[
|
|
992
|
+
def fully_qualified_name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
994
993
|
pulumi.set(self, "fully_qualified_name", value)
|
|
995
994
|
|
|
996
|
-
@property
|
|
995
|
+
@_builtins.property
|
|
997
996
|
@pulumi.getter(name="ignoreUtf8Errors")
|
|
998
|
-
def ignore_utf8_errors(self) -> Optional[pulumi.Input[
|
|
997
|
+
def ignore_utf8_errors(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
999
998
|
"""
|
|
1000
999
|
Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
1001
1000
|
"""
|
|
1002
1001
|
return pulumi.get(self, "ignore_utf8_errors")
|
|
1003
1002
|
|
|
1004
1003
|
@ignore_utf8_errors.setter
|
|
1005
|
-
def ignore_utf8_errors(self, value: Optional[pulumi.Input[
|
|
1004
|
+
def ignore_utf8_errors(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1006
1005
|
pulumi.set(self, "ignore_utf8_errors", value)
|
|
1007
1006
|
|
|
1008
|
-
@property
|
|
1007
|
+
@_builtins.property
|
|
1009
1008
|
@pulumi.getter
|
|
1010
|
-
def name(self) -> Optional[pulumi.Input[
|
|
1009
|
+
def name(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1011
1010
|
"""
|
|
1012
1011
|
Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
1013
1012
|
"""
|
|
1014
1013
|
return pulumi.get(self, "name")
|
|
1015
1014
|
|
|
1016
1015
|
@name.setter
|
|
1017
|
-
def name(self, value: Optional[pulumi.Input[
|
|
1016
|
+
def name(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1018
1017
|
pulumi.set(self, "name", value)
|
|
1019
1018
|
|
|
1020
|
-
@property
|
|
1019
|
+
@_builtins.property
|
|
1021
1020
|
@pulumi.getter(name="nullIfs")
|
|
1022
|
-
def null_ifs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1021
|
+
def null_ifs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
|
|
1023
1022
|
"""
|
|
1024
1023
|
String used to convert to and from SQL NULL.
|
|
1025
1024
|
"""
|
|
1026
1025
|
return pulumi.get(self, "null_ifs")
|
|
1027
1026
|
|
|
1028
1027
|
@null_ifs.setter
|
|
1029
|
-
def null_ifs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1028
|
+
def null_ifs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
|
|
1030
1029
|
pulumi.set(self, "null_ifs", value)
|
|
1031
1030
|
|
|
1032
|
-
@property
|
|
1031
|
+
@_builtins.property
|
|
1033
1032
|
@pulumi.getter(name="parseHeader")
|
|
1034
|
-
def parse_header(self) -> Optional[pulumi.Input[
|
|
1033
|
+
def parse_header(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1035
1034
|
"""
|
|
1036
1035
|
Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
1037
1036
|
"""
|
|
1038
1037
|
return pulumi.get(self, "parse_header")
|
|
1039
1038
|
|
|
1040
1039
|
@parse_header.setter
|
|
1041
|
-
def parse_header(self, value: Optional[pulumi.Input[
|
|
1040
|
+
def parse_header(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1042
1041
|
pulumi.set(self, "parse_header", value)
|
|
1043
1042
|
|
|
1044
|
-
@property
|
|
1043
|
+
@_builtins.property
|
|
1045
1044
|
@pulumi.getter(name="preserveSpace")
|
|
1046
|
-
def preserve_space(self) -> Optional[pulumi.Input[
|
|
1045
|
+
def preserve_space(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1047
1046
|
"""
|
|
1048
1047
|
Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
1049
1048
|
"""
|
|
1050
1049
|
return pulumi.get(self, "preserve_space")
|
|
1051
1050
|
|
|
1052
1051
|
@preserve_space.setter
|
|
1053
|
-
def preserve_space(self, value: Optional[pulumi.Input[
|
|
1052
|
+
def preserve_space(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1054
1053
|
pulumi.set(self, "preserve_space", value)
|
|
1055
1054
|
|
|
1056
|
-
@property
|
|
1055
|
+
@_builtins.property
|
|
1057
1056
|
@pulumi.getter(name="recordDelimiter")
|
|
1058
|
-
def record_delimiter(self) -> Optional[pulumi.Input[
|
|
1057
|
+
def record_delimiter(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1059
1058
|
"""
|
|
1060
1059
|
Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
1061
1060
|
"""
|
|
1062
1061
|
return pulumi.get(self, "record_delimiter")
|
|
1063
1062
|
|
|
1064
1063
|
@record_delimiter.setter
|
|
1065
|
-
def record_delimiter(self, value: Optional[pulumi.Input[
|
|
1064
|
+
def record_delimiter(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1066
1065
|
pulumi.set(self, "record_delimiter", value)
|
|
1067
1066
|
|
|
1068
|
-
@property
|
|
1067
|
+
@_builtins.property
|
|
1069
1068
|
@pulumi.getter(name="replaceInvalidCharacters")
|
|
1070
|
-
def replace_invalid_characters(self) -> Optional[pulumi.Input[
|
|
1069
|
+
def replace_invalid_characters(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1071
1070
|
"""
|
|
1072
1071
|
Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
1073
1072
|
"""
|
|
1074
1073
|
return pulumi.get(self, "replace_invalid_characters")
|
|
1075
1074
|
|
|
1076
1075
|
@replace_invalid_characters.setter
|
|
1077
|
-
def replace_invalid_characters(self, value: Optional[pulumi.Input[
|
|
1076
|
+
def replace_invalid_characters(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1078
1077
|
pulumi.set(self, "replace_invalid_characters", value)
|
|
1079
1078
|
|
|
1080
|
-
@property
|
|
1079
|
+
@_builtins.property
|
|
1081
1080
|
@pulumi.getter
|
|
1082
|
-
def schema(self) -> Optional[pulumi.Input[
|
|
1081
|
+
def schema(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1083
1082
|
"""
|
|
1084
1083
|
The schema in which to create the file format.
|
|
1085
1084
|
"""
|
|
1086
1085
|
return pulumi.get(self, "schema")
|
|
1087
1086
|
|
|
1088
1087
|
@schema.setter
|
|
1089
|
-
def schema(self, value: Optional[pulumi.Input[
|
|
1088
|
+
def schema(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1090
1089
|
pulumi.set(self, "schema", value)
|
|
1091
1090
|
|
|
1092
|
-
@property
|
|
1091
|
+
@_builtins.property
|
|
1093
1092
|
@pulumi.getter(name="skipBlankLines")
|
|
1094
|
-
def skip_blank_lines(self) -> Optional[pulumi.Input[
|
|
1093
|
+
def skip_blank_lines(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1095
1094
|
"""
|
|
1096
1095
|
Boolean that specifies to skip any blank lines encountered in the data files.
|
|
1097
1096
|
"""
|
|
1098
1097
|
return pulumi.get(self, "skip_blank_lines")
|
|
1099
1098
|
|
|
1100
1099
|
@skip_blank_lines.setter
|
|
1101
|
-
def skip_blank_lines(self, value: Optional[pulumi.Input[
|
|
1100
|
+
def skip_blank_lines(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1102
1101
|
pulumi.set(self, "skip_blank_lines", value)
|
|
1103
1102
|
|
|
1104
|
-
@property
|
|
1103
|
+
@_builtins.property
|
|
1105
1104
|
@pulumi.getter(name="skipByteOrderMark")
|
|
1106
|
-
def skip_byte_order_mark(self) -> Optional[pulumi.Input[
|
|
1105
|
+
def skip_byte_order_mark(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1107
1106
|
"""
|
|
1108
1107
|
Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
1109
1108
|
"""
|
|
1110
1109
|
return pulumi.get(self, "skip_byte_order_mark")
|
|
1111
1110
|
|
|
1112
1111
|
@skip_byte_order_mark.setter
|
|
1113
|
-
def skip_byte_order_mark(self, value: Optional[pulumi.Input[
|
|
1112
|
+
def skip_byte_order_mark(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1114
1113
|
pulumi.set(self, "skip_byte_order_mark", value)
|
|
1115
1114
|
|
|
1116
|
-
@property
|
|
1115
|
+
@_builtins.property
|
|
1117
1116
|
@pulumi.getter(name="skipHeader")
|
|
1118
|
-
def skip_header(self) -> Optional[pulumi.Input[
|
|
1117
|
+
def skip_header(self) -> Optional[pulumi.Input[_builtins.int]]:
|
|
1119
1118
|
"""
|
|
1120
1119
|
Number of lines at the start of the file to skip.
|
|
1121
1120
|
"""
|
|
1122
1121
|
return pulumi.get(self, "skip_header")
|
|
1123
1122
|
|
|
1124
1123
|
@skip_header.setter
|
|
1125
|
-
def skip_header(self, value: Optional[pulumi.Input[
|
|
1124
|
+
def skip_header(self, value: Optional[pulumi.Input[_builtins.int]]):
|
|
1126
1125
|
pulumi.set(self, "skip_header", value)
|
|
1127
1126
|
|
|
1128
|
-
@property
|
|
1127
|
+
@_builtins.property
|
|
1129
1128
|
@pulumi.getter(name="stripNullValues")
|
|
1130
|
-
def strip_null_values(self) -> Optional[pulumi.Input[
|
|
1129
|
+
def strip_null_values(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1131
1130
|
"""
|
|
1132
1131
|
Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
1133
1132
|
"""
|
|
1134
1133
|
return pulumi.get(self, "strip_null_values")
|
|
1135
1134
|
|
|
1136
1135
|
@strip_null_values.setter
|
|
1137
|
-
def strip_null_values(self, value: Optional[pulumi.Input[
|
|
1136
|
+
def strip_null_values(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1138
1137
|
pulumi.set(self, "strip_null_values", value)
|
|
1139
1138
|
|
|
1140
|
-
@property
|
|
1139
|
+
@_builtins.property
|
|
1141
1140
|
@pulumi.getter(name="stripOuterArray")
|
|
1142
|
-
def strip_outer_array(self) -> Optional[pulumi.Input[
|
|
1141
|
+
def strip_outer_array(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1143
1142
|
"""
|
|
1144
1143
|
Boolean that instructs the JSON parser to remove outer brackets.
|
|
1145
1144
|
"""
|
|
1146
1145
|
return pulumi.get(self, "strip_outer_array")
|
|
1147
1146
|
|
|
1148
1147
|
@strip_outer_array.setter
|
|
1149
|
-
def strip_outer_array(self, value: Optional[pulumi.Input[
|
|
1148
|
+
def strip_outer_array(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1150
1149
|
pulumi.set(self, "strip_outer_array", value)
|
|
1151
1150
|
|
|
1152
|
-
@property
|
|
1151
|
+
@_builtins.property
|
|
1153
1152
|
@pulumi.getter(name="stripOuterElement")
|
|
1154
|
-
def strip_outer_element(self) -> Optional[pulumi.Input[
|
|
1153
|
+
def strip_outer_element(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1155
1154
|
"""
|
|
1156
1155
|
Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
1157
1156
|
"""
|
|
1158
1157
|
return pulumi.get(self, "strip_outer_element")
|
|
1159
1158
|
|
|
1160
1159
|
@strip_outer_element.setter
|
|
1161
|
-
def strip_outer_element(self, value: Optional[pulumi.Input[
|
|
1160
|
+
def strip_outer_element(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1162
1161
|
pulumi.set(self, "strip_outer_element", value)
|
|
1163
1162
|
|
|
1164
|
-
@property
|
|
1163
|
+
@_builtins.property
|
|
1165
1164
|
@pulumi.getter(name="timeFormat")
|
|
1166
|
-
def time_format(self) -> Optional[pulumi.Input[
|
|
1165
|
+
def time_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1167
1166
|
"""
|
|
1168
1167
|
Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
1169
1168
|
"""
|
|
1170
1169
|
return pulumi.get(self, "time_format")
|
|
1171
1170
|
|
|
1172
1171
|
@time_format.setter
|
|
1173
|
-
def time_format(self, value: Optional[pulumi.Input[
|
|
1172
|
+
def time_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1174
1173
|
pulumi.set(self, "time_format", value)
|
|
1175
1174
|
|
|
1176
|
-
@property
|
|
1175
|
+
@_builtins.property
|
|
1177
1176
|
@pulumi.getter(name="timestampFormat")
|
|
1178
|
-
def timestamp_format(self) -> Optional[pulumi.Input[
|
|
1177
|
+
def timestamp_format(self) -> Optional[pulumi.Input[_builtins.str]]:
|
|
1179
1178
|
"""
|
|
1180
1179
|
Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
1181
1180
|
"""
|
|
1182
1181
|
return pulumi.get(self, "timestamp_format")
|
|
1183
1182
|
|
|
1184
1183
|
@timestamp_format.setter
|
|
1185
|
-
def timestamp_format(self, value: Optional[pulumi.Input[
|
|
1184
|
+
def timestamp_format(self, value: Optional[pulumi.Input[_builtins.str]]):
|
|
1186
1185
|
pulumi.set(self, "timestamp_format", value)
|
|
1187
1186
|
|
|
1188
|
-
@property
|
|
1187
|
+
@_builtins.property
|
|
1189
1188
|
@pulumi.getter(name="trimSpace")
|
|
1190
|
-
def trim_space(self) -> Optional[pulumi.Input[
|
|
1189
|
+
def trim_space(self) -> Optional[pulumi.Input[_builtins.bool]]:
|
|
1191
1190
|
"""
|
|
1192
1191
|
Boolean that specifies whether to remove white space from fields.
|
|
1193
1192
|
"""
|
|
1194
1193
|
return pulumi.get(self, "trim_space")
|
|
1195
1194
|
|
|
1196
1195
|
@trim_space.setter
|
|
1197
|
-
def trim_space(self, value: Optional[pulumi.Input[
|
|
1196
|
+
def trim_space(self, value: Optional[pulumi.Input[_builtins.bool]]):
|
|
1198
1197
|
pulumi.set(self, "trim_space", value)
|
|
1199
1198
|
|
|
1200
1199
|
|
|
@@ -1204,42 +1203,42 @@ class FileFormat(pulumi.CustomResource):
|
|
|
1204
1203
|
def __init__(__self__,
|
|
1205
1204
|
resource_name: str,
|
|
1206
1205
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1207
|
-
allow_duplicate: Optional[pulumi.Input[
|
|
1208
|
-
binary_as_text: Optional[pulumi.Input[
|
|
1209
|
-
binary_format: Optional[pulumi.Input[
|
|
1210
|
-
comment: Optional[pulumi.Input[
|
|
1211
|
-
compression: Optional[pulumi.Input[
|
|
1212
|
-
database: Optional[pulumi.Input[
|
|
1213
|
-
date_format: Optional[pulumi.Input[
|
|
1214
|
-
disable_auto_convert: Optional[pulumi.Input[
|
|
1215
|
-
disable_snowflake_data: Optional[pulumi.Input[
|
|
1216
|
-
empty_field_as_null: Optional[pulumi.Input[
|
|
1217
|
-
enable_octal: Optional[pulumi.Input[
|
|
1218
|
-
encoding: Optional[pulumi.Input[
|
|
1219
|
-
error_on_column_count_mismatch: Optional[pulumi.Input[
|
|
1220
|
-
escape: Optional[pulumi.Input[
|
|
1221
|
-
escape_unenclosed_field: Optional[pulumi.Input[
|
|
1222
|
-
field_delimiter: Optional[pulumi.Input[
|
|
1223
|
-
field_optionally_enclosed_by: Optional[pulumi.Input[
|
|
1224
|
-
file_extension: Optional[pulumi.Input[
|
|
1225
|
-
format_type: Optional[pulumi.Input[
|
|
1226
|
-
ignore_utf8_errors: Optional[pulumi.Input[
|
|
1227
|
-
name: Optional[pulumi.Input[
|
|
1228
|
-
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1229
|
-
parse_header: Optional[pulumi.Input[
|
|
1230
|
-
preserve_space: Optional[pulumi.Input[
|
|
1231
|
-
record_delimiter: Optional[pulumi.Input[
|
|
1232
|
-
replace_invalid_characters: Optional[pulumi.Input[
|
|
1233
|
-
schema: Optional[pulumi.Input[
|
|
1234
|
-
skip_blank_lines: Optional[pulumi.Input[
|
|
1235
|
-
skip_byte_order_mark: Optional[pulumi.Input[
|
|
1236
|
-
skip_header: Optional[pulumi.Input[
|
|
1237
|
-
strip_null_values: Optional[pulumi.Input[
|
|
1238
|
-
strip_outer_array: Optional[pulumi.Input[
|
|
1239
|
-
strip_outer_element: Optional[pulumi.Input[
|
|
1240
|
-
time_format: Optional[pulumi.Input[
|
|
1241
|
-
timestamp_format: Optional[pulumi.Input[
|
|
1242
|
-
trim_space: Optional[pulumi.Input[
|
|
1206
|
+
allow_duplicate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1207
|
+
binary_as_text: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1208
|
+
binary_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1209
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1210
|
+
compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1211
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1212
|
+
date_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1213
|
+
disable_auto_convert: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1214
|
+
disable_snowflake_data: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1215
|
+
empty_field_as_null: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1216
|
+
enable_octal: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1217
|
+
encoding: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1218
|
+
error_on_column_count_mismatch: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1219
|
+
escape: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1220
|
+
escape_unenclosed_field: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1221
|
+
field_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1222
|
+
field_optionally_enclosed_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1223
|
+
file_extension: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1224
|
+
format_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1225
|
+
ignore_utf8_errors: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1226
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1227
|
+
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1228
|
+
parse_header: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1229
|
+
preserve_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1230
|
+
record_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1231
|
+
replace_invalid_characters: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1232
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1233
|
+
skip_blank_lines: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1234
|
+
skip_byte_order_mark: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1235
|
+
skip_header: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1236
|
+
strip_null_values: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1237
|
+
strip_outer_array: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1238
|
+
strip_outer_element: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1239
|
+
time_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1240
|
+
timestamp_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1241
|
+
trim_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1243
1242
|
__props__=None):
|
|
1244
1243
|
"""
|
|
1245
1244
|
## Import
|
|
@@ -1252,42 +1251,42 @@ class FileFormat(pulumi.CustomResource):
|
|
|
1252
1251
|
|
|
1253
1252
|
:param str resource_name: The name of the resource.
|
|
1254
1253
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1255
|
-
:param pulumi.Input[
|
|
1256
|
-
:param pulumi.Input[
|
|
1257
|
-
:param pulumi.Input[
|
|
1258
|
-
:param pulumi.Input[
|
|
1259
|
-
:param pulumi.Input[
|
|
1260
|
-
:param pulumi.Input[
|
|
1261
|
-
:param pulumi.Input[
|
|
1262
|
-
:param pulumi.Input[
|
|
1263
|
-
:param pulumi.Input[
|
|
1264
|
-
:param pulumi.Input[
|
|
1265
|
-
:param pulumi.Input[
|
|
1266
|
-
:param pulumi.Input[
|
|
1267
|
-
:param pulumi.Input[
|
|
1268
|
-
:param pulumi.Input[
|
|
1269
|
-
:param pulumi.Input[
|
|
1270
|
-
:param pulumi.Input[
|
|
1271
|
-
:param pulumi.Input[
|
|
1272
|
-
:param pulumi.Input[
|
|
1273
|
-
:param pulumi.Input[
|
|
1274
|
-
:param pulumi.Input[
|
|
1275
|
-
:param pulumi.Input[
|
|
1276
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1277
|
-
:param pulumi.Input[
|
|
1278
|
-
:param pulumi.Input[
|
|
1279
|
-
:param pulumi.Input[
|
|
1280
|
-
:param pulumi.Input[
|
|
1281
|
-
:param pulumi.Input[
|
|
1282
|
-
:param pulumi.Input[
|
|
1283
|
-
:param pulumi.Input[
|
|
1284
|
-
:param pulumi.Input[
|
|
1285
|
-
:param pulumi.Input[
|
|
1286
|
-
:param pulumi.Input[
|
|
1287
|
-
:param pulumi.Input[
|
|
1288
|
-
:param pulumi.Input[
|
|
1289
|
-
:param pulumi.Input[
|
|
1290
|
-
:param pulumi.Input[
|
|
1254
|
+
:param pulumi.Input[_builtins.bool] allow_duplicate: Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
1255
|
+
:param pulumi.Input[_builtins.bool] binary_as_text: Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
1256
|
+
:param pulumi.Input[_builtins.str] binary_format: Defines the encoding format for binary input or output.
|
|
1257
|
+
:param pulumi.Input[_builtins.str] comment: Specifies a comment for the file format.
|
|
1258
|
+
:param pulumi.Input[_builtins.str] compression: Specifies the current compression algorithm for the data file.
|
|
1259
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the file format.
|
|
1260
|
+
:param pulumi.Input[_builtins.str] date_format: Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
1261
|
+
:param pulumi.Input[_builtins.bool] disable_auto_convert: Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
1262
|
+
:param pulumi.Input[_builtins.bool] disable_snowflake_data: Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
1263
|
+
:param pulumi.Input[_builtins.bool] empty_field_as_null: Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
1264
|
+
:param pulumi.Input[_builtins.bool] enable_octal: Boolean that enables parsing of octal numbers.
|
|
1265
|
+
:param pulumi.Input[_builtins.str] encoding: String (constant) that specifies the character set of the source data when loading data into a table.
|
|
1266
|
+
:param pulumi.Input[_builtins.bool] error_on_column_count_mismatch: Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
1267
|
+
:param pulumi.Input[_builtins.str] escape: Single character string used as the escape character for field values.
|
|
1268
|
+
:param pulumi.Input[_builtins.str] escape_unenclosed_field: Single character string used as the escape character for unenclosed field values only.
|
|
1269
|
+
:param pulumi.Input[_builtins.str] field_delimiter: Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
1270
|
+
:param pulumi.Input[_builtins.str] field_optionally_enclosed_by: Character used to enclose strings.
|
|
1271
|
+
:param pulumi.Input[_builtins.str] file_extension: Specifies the extension for files unloaded to a stage.
|
|
1272
|
+
:param pulumi.Input[_builtins.str] format_type: Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
1273
|
+
:param pulumi.Input[_builtins.bool] ignore_utf8_errors: Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
1274
|
+
:param pulumi.Input[_builtins.str] name: Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
1275
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] null_ifs: String used to convert to and from SQL NULL.
|
|
1276
|
+
:param pulumi.Input[_builtins.bool] parse_header: Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
1277
|
+
:param pulumi.Input[_builtins.bool] preserve_space: Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
1278
|
+
:param pulumi.Input[_builtins.str] record_delimiter: Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
1279
|
+
:param pulumi.Input[_builtins.bool] replace_invalid_characters: Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
1280
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the file format.
|
|
1281
|
+
:param pulumi.Input[_builtins.bool] skip_blank_lines: Boolean that specifies to skip any blank lines encountered in the data files.
|
|
1282
|
+
:param pulumi.Input[_builtins.bool] skip_byte_order_mark: Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
1283
|
+
:param pulumi.Input[_builtins.int] skip_header: Number of lines at the start of the file to skip.
|
|
1284
|
+
:param pulumi.Input[_builtins.bool] strip_null_values: Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
1285
|
+
:param pulumi.Input[_builtins.bool] strip_outer_array: Boolean that instructs the JSON parser to remove outer brackets.
|
|
1286
|
+
:param pulumi.Input[_builtins.bool] strip_outer_element: Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
1287
|
+
:param pulumi.Input[_builtins.str] time_format: Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
1288
|
+
:param pulumi.Input[_builtins.str] timestamp_format: Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
1289
|
+
:param pulumi.Input[_builtins.bool] trim_space: Boolean that specifies whether to remove white space from fields.
|
|
1291
1290
|
"""
|
|
1292
1291
|
...
|
|
1293
1292
|
@overload
|
|
@@ -1319,42 +1318,42 @@ class FileFormat(pulumi.CustomResource):
|
|
|
1319
1318
|
def _internal_init(__self__,
|
|
1320
1319
|
resource_name: str,
|
|
1321
1320
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1322
|
-
allow_duplicate: Optional[pulumi.Input[
|
|
1323
|
-
binary_as_text: Optional[pulumi.Input[
|
|
1324
|
-
binary_format: Optional[pulumi.Input[
|
|
1325
|
-
comment: Optional[pulumi.Input[
|
|
1326
|
-
compression: Optional[pulumi.Input[
|
|
1327
|
-
database: Optional[pulumi.Input[
|
|
1328
|
-
date_format: Optional[pulumi.Input[
|
|
1329
|
-
disable_auto_convert: Optional[pulumi.Input[
|
|
1330
|
-
disable_snowflake_data: Optional[pulumi.Input[
|
|
1331
|
-
empty_field_as_null: Optional[pulumi.Input[
|
|
1332
|
-
enable_octal: Optional[pulumi.Input[
|
|
1333
|
-
encoding: Optional[pulumi.Input[
|
|
1334
|
-
error_on_column_count_mismatch: Optional[pulumi.Input[
|
|
1335
|
-
escape: Optional[pulumi.Input[
|
|
1336
|
-
escape_unenclosed_field: Optional[pulumi.Input[
|
|
1337
|
-
field_delimiter: Optional[pulumi.Input[
|
|
1338
|
-
field_optionally_enclosed_by: Optional[pulumi.Input[
|
|
1339
|
-
file_extension: Optional[pulumi.Input[
|
|
1340
|
-
format_type: Optional[pulumi.Input[
|
|
1341
|
-
ignore_utf8_errors: Optional[pulumi.Input[
|
|
1342
|
-
name: Optional[pulumi.Input[
|
|
1343
|
-
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1344
|
-
parse_header: Optional[pulumi.Input[
|
|
1345
|
-
preserve_space: Optional[pulumi.Input[
|
|
1346
|
-
record_delimiter: Optional[pulumi.Input[
|
|
1347
|
-
replace_invalid_characters: Optional[pulumi.Input[
|
|
1348
|
-
schema: Optional[pulumi.Input[
|
|
1349
|
-
skip_blank_lines: Optional[pulumi.Input[
|
|
1350
|
-
skip_byte_order_mark: Optional[pulumi.Input[
|
|
1351
|
-
skip_header: Optional[pulumi.Input[
|
|
1352
|
-
strip_null_values: Optional[pulumi.Input[
|
|
1353
|
-
strip_outer_array: Optional[pulumi.Input[
|
|
1354
|
-
strip_outer_element: Optional[pulumi.Input[
|
|
1355
|
-
time_format: Optional[pulumi.Input[
|
|
1356
|
-
timestamp_format: Optional[pulumi.Input[
|
|
1357
|
-
trim_space: Optional[pulumi.Input[
|
|
1321
|
+
allow_duplicate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1322
|
+
binary_as_text: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1323
|
+
binary_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1324
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1325
|
+
compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1326
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1327
|
+
date_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1328
|
+
disable_auto_convert: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1329
|
+
disable_snowflake_data: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1330
|
+
empty_field_as_null: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1331
|
+
enable_octal: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1332
|
+
encoding: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1333
|
+
error_on_column_count_mismatch: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1334
|
+
escape: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1335
|
+
escape_unenclosed_field: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1336
|
+
field_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1337
|
+
field_optionally_enclosed_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1338
|
+
file_extension: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1339
|
+
format_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1340
|
+
ignore_utf8_errors: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1341
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1342
|
+
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1343
|
+
parse_header: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1344
|
+
preserve_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1345
|
+
record_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1346
|
+
replace_invalid_characters: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1347
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1348
|
+
skip_blank_lines: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1349
|
+
skip_byte_order_mark: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1350
|
+
skip_header: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1351
|
+
strip_null_values: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1352
|
+
strip_outer_array: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1353
|
+
strip_outer_element: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1354
|
+
time_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1355
|
+
timestamp_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1356
|
+
trim_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1358
1357
|
__props__=None):
|
|
1359
1358
|
opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
|
|
1360
1359
|
if not isinstance(opts, pulumi.ResourceOptions):
|
|
@@ -1417,43 +1416,43 @@ class FileFormat(pulumi.CustomResource):
|
|
|
1417
1416
|
def get(resource_name: str,
|
|
1418
1417
|
id: pulumi.Input[str],
|
|
1419
1418
|
opts: Optional[pulumi.ResourceOptions] = None,
|
|
1420
|
-
allow_duplicate: Optional[pulumi.Input[
|
|
1421
|
-
binary_as_text: Optional[pulumi.Input[
|
|
1422
|
-
binary_format: Optional[pulumi.Input[
|
|
1423
|
-
comment: Optional[pulumi.Input[
|
|
1424
|
-
compression: Optional[pulumi.Input[
|
|
1425
|
-
database: Optional[pulumi.Input[
|
|
1426
|
-
date_format: Optional[pulumi.Input[
|
|
1427
|
-
disable_auto_convert: Optional[pulumi.Input[
|
|
1428
|
-
disable_snowflake_data: Optional[pulumi.Input[
|
|
1429
|
-
empty_field_as_null: Optional[pulumi.Input[
|
|
1430
|
-
enable_octal: Optional[pulumi.Input[
|
|
1431
|
-
encoding: Optional[pulumi.Input[
|
|
1432
|
-
error_on_column_count_mismatch: Optional[pulumi.Input[
|
|
1433
|
-
escape: Optional[pulumi.Input[
|
|
1434
|
-
escape_unenclosed_field: Optional[pulumi.Input[
|
|
1435
|
-
field_delimiter: Optional[pulumi.Input[
|
|
1436
|
-
field_optionally_enclosed_by: Optional[pulumi.Input[
|
|
1437
|
-
file_extension: Optional[pulumi.Input[
|
|
1438
|
-
format_type: Optional[pulumi.Input[
|
|
1439
|
-
fully_qualified_name: Optional[pulumi.Input[
|
|
1440
|
-
ignore_utf8_errors: Optional[pulumi.Input[
|
|
1441
|
-
name: Optional[pulumi.Input[
|
|
1442
|
-
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[
|
|
1443
|
-
parse_header: Optional[pulumi.Input[
|
|
1444
|
-
preserve_space: Optional[pulumi.Input[
|
|
1445
|
-
record_delimiter: Optional[pulumi.Input[
|
|
1446
|
-
replace_invalid_characters: Optional[pulumi.Input[
|
|
1447
|
-
schema: Optional[pulumi.Input[
|
|
1448
|
-
skip_blank_lines: Optional[pulumi.Input[
|
|
1449
|
-
skip_byte_order_mark: Optional[pulumi.Input[
|
|
1450
|
-
skip_header: Optional[pulumi.Input[
|
|
1451
|
-
strip_null_values: Optional[pulumi.Input[
|
|
1452
|
-
strip_outer_array: Optional[pulumi.Input[
|
|
1453
|
-
strip_outer_element: Optional[pulumi.Input[
|
|
1454
|
-
time_format: Optional[pulumi.Input[
|
|
1455
|
-
timestamp_format: Optional[pulumi.Input[
|
|
1456
|
-
trim_space: Optional[pulumi.Input[
|
|
1419
|
+
allow_duplicate: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1420
|
+
binary_as_text: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1421
|
+
binary_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1422
|
+
comment: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1423
|
+
compression: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1424
|
+
database: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1425
|
+
date_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1426
|
+
disable_auto_convert: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1427
|
+
disable_snowflake_data: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1428
|
+
empty_field_as_null: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1429
|
+
enable_octal: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1430
|
+
encoding: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1431
|
+
error_on_column_count_mismatch: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1432
|
+
escape: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1433
|
+
escape_unenclosed_field: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1434
|
+
field_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1435
|
+
field_optionally_enclosed_by: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1436
|
+
file_extension: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1437
|
+
format_type: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1438
|
+
fully_qualified_name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1439
|
+
ignore_utf8_errors: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1440
|
+
name: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1441
|
+
null_ifs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
|
|
1442
|
+
parse_header: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1443
|
+
preserve_space: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1444
|
+
record_delimiter: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1445
|
+
replace_invalid_characters: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1446
|
+
schema: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1447
|
+
skip_blank_lines: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1448
|
+
skip_byte_order_mark: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1449
|
+
skip_header: Optional[pulumi.Input[_builtins.int]] = None,
|
|
1450
|
+
strip_null_values: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1451
|
+
strip_outer_array: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1452
|
+
strip_outer_element: Optional[pulumi.Input[_builtins.bool]] = None,
|
|
1453
|
+
time_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1454
|
+
timestamp_format: Optional[pulumi.Input[_builtins.str]] = None,
|
|
1455
|
+
trim_space: Optional[pulumi.Input[_builtins.bool]] = None) -> 'FileFormat':
|
|
1457
1456
|
"""
|
|
1458
1457
|
Get an existing FileFormat resource's state with the given name, id, and optional extra
|
|
1459
1458
|
properties used to qualify the lookup.
|
|
@@ -1461,43 +1460,43 @@ class FileFormat(pulumi.CustomResource):
|
|
|
1461
1460
|
:param str resource_name: The unique name of the resulting resource.
|
|
1462
1461
|
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
|
|
1463
1462
|
:param pulumi.ResourceOptions opts: Options for the resource.
|
|
1464
|
-
:param pulumi.Input[
|
|
1465
|
-
:param pulumi.Input[
|
|
1466
|
-
:param pulumi.Input[
|
|
1467
|
-
:param pulumi.Input[
|
|
1468
|
-
:param pulumi.Input[
|
|
1469
|
-
:param pulumi.Input[
|
|
1470
|
-
:param pulumi.Input[
|
|
1471
|
-
:param pulumi.Input[
|
|
1472
|
-
:param pulumi.Input[
|
|
1473
|
-
:param pulumi.Input[
|
|
1474
|
-
:param pulumi.Input[
|
|
1475
|
-
:param pulumi.Input[
|
|
1476
|
-
:param pulumi.Input[
|
|
1477
|
-
:param pulumi.Input[
|
|
1478
|
-
:param pulumi.Input[
|
|
1479
|
-
:param pulumi.Input[
|
|
1480
|
-
:param pulumi.Input[
|
|
1481
|
-
:param pulumi.Input[
|
|
1482
|
-
:param pulumi.Input[
|
|
1483
|
-
:param pulumi.Input[
|
|
1484
|
-
:param pulumi.Input[
|
|
1485
|
-
:param pulumi.Input[
|
|
1486
|
-
:param pulumi.Input[Sequence[pulumi.Input[
|
|
1487
|
-
:param pulumi.Input[
|
|
1488
|
-
:param pulumi.Input[
|
|
1489
|
-
:param pulumi.Input[
|
|
1490
|
-
:param pulumi.Input[
|
|
1491
|
-
:param pulumi.Input[
|
|
1492
|
-
:param pulumi.Input[
|
|
1493
|
-
:param pulumi.Input[
|
|
1494
|
-
:param pulumi.Input[
|
|
1495
|
-
:param pulumi.Input[
|
|
1496
|
-
:param pulumi.Input[
|
|
1497
|
-
:param pulumi.Input[
|
|
1498
|
-
:param pulumi.Input[
|
|
1499
|
-
:param pulumi.Input[
|
|
1500
|
-
:param pulumi.Input[
|
|
1463
|
+
:param pulumi.Input[_builtins.bool] allow_duplicate: Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
1464
|
+
:param pulumi.Input[_builtins.bool] binary_as_text: Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
1465
|
+
:param pulumi.Input[_builtins.str] binary_format: Defines the encoding format for binary input or output.
|
|
1466
|
+
:param pulumi.Input[_builtins.str] comment: Specifies a comment for the file format.
|
|
1467
|
+
:param pulumi.Input[_builtins.str] compression: Specifies the current compression algorithm for the data file.
|
|
1468
|
+
:param pulumi.Input[_builtins.str] database: The database in which to create the file format.
|
|
1469
|
+
:param pulumi.Input[_builtins.str] date_format: Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
1470
|
+
:param pulumi.Input[_builtins.bool] disable_auto_convert: Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
1471
|
+
:param pulumi.Input[_builtins.bool] disable_snowflake_data: Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
1472
|
+
:param pulumi.Input[_builtins.bool] empty_field_as_null: Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
1473
|
+
:param pulumi.Input[_builtins.bool] enable_octal: Boolean that enables parsing of octal numbers.
|
|
1474
|
+
:param pulumi.Input[_builtins.str] encoding: String (constant) that specifies the character set of the source data when loading data into a table.
|
|
1475
|
+
:param pulumi.Input[_builtins.bool] error_on_column_count_mismatch: Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
1476
|
+
:param pulumi.Input[_builtins.str] escape: Single character string used as the escape character for field values.
|
|
1477
|
+
:param pulumi.Input[_builtins.str] escape_unenclosed_field: Single character string used as the escape character for unenclosed field values only.
|
|
1478
|
+
:param pulumi.Input[_builtins.str] field_delimiter: Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
1479
|
+
:param pulumi.Input[_builtins.str] field_optionally_enclosed_by: Character used to enclose strings.
|
|
1480
|
+
:param pulumi.Input[_builtins.str] file_extension: Specifies the extension for files unloaded to a stage.
|
|
1481
|
+
:param pulumi.Input[_builtins.str] format_type: Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
1482
|
+
:param pulumi.Input[_builtins.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).
|
|
1483
|
+
:param pulumi.Input[_builtins.bool] ignore_utf8_errors: Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
1484
|
+
:param pulumi.Input[_builtins.str] name: Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
1485
|
+
:param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] null_ifs: String used to convert to and from SQL NULL.
|
|
1486
|
+
:param pulumi.Input[_builtins.bool] parse_header: Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
1487
|
+
:param pulumi.Input[_builtins.bool] preserve_space: Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
1488
|
+
:param pulumi.Input[_builtins.str] record_delimiter: Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
1489
|
+
:param pulumi.Input[_builtins.bool] replace_invalid_characters: Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
1490
|
+
:param pulumi.Input[_builtins.str] schema: The schema in which to create the file format.
|
|
1491
|
+
:param pulumi.Input[_builtins.bool] skip_blank_lines: Boolean that specifies to skip any blank lines encountered in the data files.
|
|
1492
|
+
:param pulumi.Input[_builtins.bool] skip_byte_order_mark: Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
1493
|
+
:param pulumi.Input[_builtins.int] skip_header: Number of lines at the start of the file to skip.
|
|
1494
|
+
:param pulumi.Input[_builtins.bool] strip_null_values: Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
1495
|
+
:param pulumi.Input[_builtins.bool] strip_outer_array: Boolean that instructs the JSON parser to remove outer brackets.
|
|
1496
|
+
:param pulumi.Input[_builtins.bool] strip_outer_element: Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
1497
|
+
:param pulumi.Input[_builtins.str] time_format: Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
1498
|
+
:param pulumi.Input[_builtins.str] timestamp_format: Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
1499
|
+
:param pulumi.Input[_builtins.bool] trim_space: Boolean that specifies whether to remove white space from fields.
|
|
1501
1500
|
"""
|
|
1502
1501
|
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
|
|
1503
1502
|
|
|
@@ -1542,297 +1541,297 @@ class FileFormat(pulumi.CustomResource):
|
|
|
1542
1541
|
__props__.__dict__["trim_space"] = trim_space
|
|
1543
1542
|
return FileFormat(resource_name, opts=opts, __props__=__props__)
|
|
1544
1543
|
|
|
1545
|
-
@property
|
|
1544
|
+
@_builtins.property
|
|
1546
1545
|
@pulumi.getter(name="allowDuplicate")
|
|
1547
|
-
def allow_duplicate(self) -> pulumi.Output[Optional[
|
|
1546
|
+
def allow_duplicate(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1548
1547
|
"""
|
|
1549
1548
|
Boolean that specifies to allow duplicate object field names (only the last one will be preserved).
|
|
1550
1549
|
"""
|
|
1551
1550
|
return pulumi.get(self, "allow_duplicate")
|
|
1552
1551
|
|
|
1553
|
-
@property
|
|
1552
|
+
@_builtins.property
|
|
1554
1553
|
@pulumi.getter(name="binaryAsText")
|
|
1555
|
-
def binary_as_text(self) -> pulumi.Output[Optional[
|
|
1554
|
+
def binary_as_text(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1556
1555
|
"""
|
|
1557
1556
|
Boolean that specifies whether to interpret columns with no defined logical data type as UTF-8 text.
|
|
1558
1557
|
"""
|
|
1559
1558
|
return pulumi.get(self, "binary_as_text")
|
|
1560
1559
|
|
|
1561
|
-
@property
|
|
1560
|
+
@_builtins.property
|
|
1562
1561
|
@pulumi.getter(name="binaryFormat")
|
|
1563
|
-
def binary_format(self) -> pulumi.Output[
|
|
1562
|
+
def binary_format(self) -> pulumi.Output[_builtins.str]:
|
|
1564
1563
|
"""
|
|
1565
1564
|
Defines the encoding format for binary input or output.
|
|
1566
1565
|
"""
|
|
1567
1566
|
return pulumi.get(self, "binary_format")
|
|
1568
1567
|
|
|
1569
|
-
@property
|
|
1568
|
+
@_builtins.property
|
|
1570
1569
|
@pulumi.getter
|
|
1571
|
-
def comment(self) -> pulumi.Output[Optional[
|
|
1570
|
+
def comment(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1572
1571
|
"""
|
|
1573
1572
|
Specifies a comment for the file format.
|
|
1574
1573
|
"""
|
|
1575
1574
|
return pulumi.get(self, "comment")
|
|
1576
1575
|
|
|
1577
|
-
@property
|
|
1576
|
+
@_builtins.property
|
|
1578
1577
|
@pulumi.getter
|
|
1579
|
-
def compression(self) -> pulumi.Output[
|
|
1578
|
+
def compression(self) -> pulumi.Output[_builtins.str]:
|
|
1580
1579
|
"""
|
|
1581
1580
|
Specifies the current compression algorithm for the data file.
|
|
1582
1581
|
"""
|
|
1583
1582
|
return pulumi.get(self, "compression")
|
|
1584
1583
|
|
|
1585
|
-
@property
|
|
1584
|
+
@_builtins.property
|
|
1586
1585
|
@pulumi.getter
|
|
1587
|
-
def database(self) -> pulumi.Output[
|
|
1586
|
+
def database(self) -> pulumi.Output[_builtins.str]:
|
|
1588
1587
|
"""
|
|
1589
1588
|
The database in which to create the file format.
|
|
1590
1589
|
"""
|
|
1591
1590
|
return pulumi.get(self, "database")
|
|
1592
1591
|
|
|
1593
|
-
@property
|
|
1592
|
+
@_builtins.property
|
|
1594
1593
|
@pulumi.getter(name="dateFormat")
|
|
1595
|
-
def date_format(self) -> pulumi.Output[
|
|
1594
|
+
def date_format(self) -> pulumi.Output[_builtins.str]:
|
|
1596
1595
|
"""
|
|
1597
1596
|
Defines the format of date values in the data files (data loading) or table (data unloading).
|
|
1598
1597
|
"""
|
|
1599
1598
|
return pulumi.get(self, "date_format")
|
|
1600
1599
|
|
|
1601
|
-
@property
|
|
1600
|
+
@_builtins.property
|
|
1602
1601
|
@pulumi.getter(name="disableAutoConvert")
|
|
1603
|
-
def disable_auto_convert(self) -> pulumi.Output[Optional[
|
|
1602
|
+
def disable_auto_convert(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1604
1603
|
"""
|
|
1605
1604
|
Boolean that specifies whether the XML parser disables automatic conversion of numeric and Boolean values from text to native representation.
|
|
1606
1605
|
"""
|
|
1607
1606
|
return pulumi.get(self, "disable_auto_convert")
|
|
1608
1607
|
|
|
1609
|
-
@property
|
|
1608
|
+
@_builtins.property
|
|
1610
1609
|
@pulumi.getter(name="disableSnowflakeData")
|
|
1611
|
-
def disable_snowflake_data(self) -> pulumi.Output[Optional[
|
|
1610
|
+
def disable_snowflake_data(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1612
1611
|
"""
|
|
1613
1612
|
Boolean that specifies whether the XML parser disables recognition of Snowflake semi-structured data tags.
|
|
1614
1613
|
"""
|
|
1615
1614
|
return pulumi.get(self, "disable_snowflake_data")
|
|
1616
1615
|
|
|
1617
|
-
@property
|
|
1616
|
+
@_builtins.property
|
|
1618
1617
|
@pulumi.getter(name="emptyFieldAsNull")
|
|
1619
|
-
def empty_field_as_null(self) -> pulumi.Output[Optional[
|
|
1618
|
+
def empty_field_as_null(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1620
1619
|
"""
|
|
1621
1620
|
Specifies whether to insert SQL NULL for empty fields in an input file, which are represented by two successive delimiters.
|
|
1622
1621
|
"""
|
|
1623
1622
|
return pulumi.get(self, "empty_field_as_null")
|
|
1624
1623
|
|
|
1625
|
-
@property
|
|
1624
|
+
@_builtins.property
|
|
1626
1625
|
@pulumi.getter(name="enableOctal")
|
|
1627
|
-
def enable_octal(self) -> pulumi.Output[Optional[
|
|
1626
|
+
def enable_octal(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1628
1627
|
"""
|
|
1629
1628
|
Boolean that enables parsing of octal numbers.
|
|
1630
1629
|
"""
|
|
1631
1630
|
return pulumi.get(self, "enable_octal")
|
|
1632
1631
|
|
|
1633
|
-
@property
|
|
1632
|
+
@_builtins.property
|
|
1634
1633
|
@pulumi.getter
|
|
1635
|
-
def encoding(self) -> pulumi.Output[
|
|
1634
|
+
def encoding(self) -> pulumi.Output[_builtins.str]:
|
|
1636
1635
|
"""
|
|
1637
1636
|
String (constant) that specifies the character set of the source data when loading data into a table.
|
|
1638
1637
|
"""
|
|
1639
1638
|
return pulumi.get(self, "encoding")
|
|
1640
1639
|
|
|
1641
|
-
@property
|
|
1640
|
+
@_builtins.property
|
|
1642
1641
|
@pulumi.getter(name="errorOnColumnCountMismatch")
|
|
1643
|
-
def error_on_column_count_mismatch(self) -> pulumi.Output[Optional[
|
|
1642
|
+
def error_on_column_count_mismatch(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1644
1643
|
"""
|
|
1645
1644
|
Boolean that specifies whether to generate a parsing error if the number of delimited columns (i.e. fields) in an input file does not match the number of columns in the corresponding table.
|
|
1646
1645
|
"""
|
|
1647
1646
|
return pulumi.get(self, "error_on_column_count_mismatch")
|
|
1648
1647
|
|
|
1649
|
-
@property
|
|
1648
|
+
@_builtins.property
|
|
1650
1649
|
@pulumi.getter
|
|
1651
|
-
def escape(self) -> pulumi.Output[
|
|
1650
|
+
def escape(self) -> pulumi.Output[_builtins.str]:
|
|
1652
1651
|
"""
|
|
1653
1652
|
Single character string used as the escape character for field values.
|
|
1654
1653
|
"""
|
|
1655
1654
|
return pulumi.get(self, "escape")
|
|
1656
1655
|
|
|
1657
|
-
@property
|
|
1656
|
+
@_builtins.property
|
|
1658
1657
|
@pulumi.getter(name="escapeUnenclosedField")
|
|
1659
|
-
def escape_unenclosed_field(self) -> pulumi.Output[
|
|
1658
|
+
def escape_unenclosed_field(self) -> pulumi.Output[_builtins.str]:
|
|
1660
1659
|
"""
|
|
1661
1660
|
Single character string used as the escape character for unenclosed field values only.
|
|
1662
1661
|
"""
|
|
1663
1662
|
return pulumi.get(self, "escape_unenclosed_field")
|
|
1664
1663
|
|
|
1665
|
-
@property
|
|
1664
|
+
@_builtins.property
|
|
1666
1665
|
@pulumi.getter(name="fieldDelimiter")
|
|
1667
|
-
def field_delimiter(self) -> pulumi.Output[
|
|
1666
|
+
def field_delimiter(self) -> pulumi.Output[_builtins.str]:
|
|
1668
1667
|
"""
|
|
1669
1668
|
Specifies one or more singlebyte or multibyte characters that separate fields in an input file (data loading) or unloaded file (data unloading).
|
|
1670
1669
|
"""
|
|
1671
1670
|
return pulumi.get(self, "field_delimiter")
|
|
1672
1671
|
|
|
1673
|
-
@property
|
|
1672
|
+
@_builtins.property
|
|
1674
1673
|
@pulumi.getter(name="fieldOptionallyEnclosedBy")
|
|
1675
|
-
def field_optionally_enclosed_by(self) -> pulumi.Output[
|
|
1674
|
+
def field_optionally_enclosed_by(self) -> pulumi.Output[_builtins.str]:
|
|
1676
1675
|
"""
|
|
1677
1676
|
Character used to enclose strings.
|
|
1678
1677
|
"""
|
|
1679
1678
|
return pulumi.get(self, "field_optionally_enclosed_by")
|
|
1680
1679
|
|
|
1681
|
-
@property
|
|
1680
|
+
@_builtins.property
|
|
1682
1681
|
@pulumi.getter(name="fileExtension")
|
|
1683
|
-
def file_extension(self) -> pulumi.Output[Optional[
|
|
1682
|
+
def file_extension(self) -> pulumi.Output[Optional[_builtins.str]]:
|
|
1684
1683
|
"""
|
|
1685
1684
|
Specifies the extension for files unloaded to a stage.
|
|
1686
1685
|
"""
|
|
1687
1686
|
return pulumi.get(self, "file_extension")
|
|
1688
1687
|
|
|
1689
|
-
@property
|
|
1688
|
+
@_builtins.property
|
|
1690
1689
|
@pulumi.getter(name="formatType")
|
|
1691
|
-
def format_type(self) -> pulumi.Output[
|
|
1690
|
+
def format_type(self) -> pulumi.Output[_builtins.str]:
|
|
1692
1691
|
"""
|
|
1693
1692
|
Specifies the format of the input files (for data loading) or output files (for data unloading).
|
|
1694
1693
|
"""
|
|
1695
1694
|
return pulumi.get(self, "format_type")
|
|
1696
1695
|
|
|
1697
|
-
@property
|
|
1696
|
+
@_builtins.property
|
|
1698
1697
|
@pulumi.getter(name="fullyQualifiedName")
|
|
1699
|
-
def fully_qualified_name(self) -> pulumi.Output[
|
|
1698
|
+
def fully_qualified_name(self) -> pulumi.Output[_builtins.str]:
|
|
1700
1699
|
"""
|
|
1701
1700
|
Fully qualified name of the resource. For more information, see [object name resolution](https://docs.snowflake.com/en/sql-reference/name-resolution).
|
|
1702
1701
|
"""
|
|
1703
1702
|
return pulumi.get(self, "fully_qualified_name")
|
|
1704
1703
|
|
|
1705
|
-
@property
|
|
1704
|
+
@_builtins.property
|
|
1706
1705
|
@pulumi.getter(name="ignoreUtf8Errors")
|
|
1707
|
-
def ignore_utf8_errors(self) -> pulumi.Output[Optional[
|
|
1706
|
+
def ignore_utf8_errors(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1708
1707
|
"""
|
|
1709
1708
|
Boolean that specifies whether UTF-8 encoding errors produce error conditions.
|
|
1710
1709
|
"""
|
|
1711
1710
|
return pulumi.get(self, "ignore_utf8_errors")
|
|
1712
1711
|
|
|
1713
|
-
@property
|
|
1712
|
+
@_builtins.property
|
|
1714
1713
|
@pulumi.getter
|
|
1715
|
-
def name(self) -> pulumi.Output[
|
|
1714
|
+
def name(self) -> pulumi.Output[_builtins.str]:
|
|
1716
1715
|
"""
|
|
1717
1716
|
Specifies the identifier for the file format; must be unique for the database and schema in which the file format is created.
|
|
1718
1717
|
"""
|
|
1719
1718
|
return pulumi.get(self, "name")
|
|
1720
1719
|
|
|
1721
|
-
@property
|
|
1720
|
+
@_builtins.property
|
|
1722
1721
|
@pulumi.getter(name="nullIfs")
|
|
1723
|
-
def null_ifs(self) -> pulumi.Output[Sequence[
|
|
1722
|
+
def null_ifs(self) -> pulumi.Output[Sequence[_builtins.str]]:
|
|
1724
1723
|
"""
|
|
1725
1724
|
String used to convert to and from SQL NULL.
|
|
1726
1725
|
"""
|
|
1727
1726
|
return pulumi.get(self, "null_ifs")
|
|
1728
1727
|
|
|
1729
|
-
@property
|
|
1728
|
+
@_builtins.property
|
|
1730
1729
|
@pulumi.getter(name="parseHeader")
|
|
1731
|
-
def parse_header(self) -> pulumi.Output[Optional[
|
|
1730
|
+
def parse_header(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1732
1731
|
"""
|
|
1733
1732
|
Boolean that specifies whether to use the first row headers in the data files to determine column names.
|
|
1734
1733
|
"""
|
|
1735
1734
|
return pulumi.get(self, "parse_header")
|
|
1736
1735
|
|
|
1737
|
-
@property
|
|
1736
|
+
@_builtins.property
|
|
1738
1737
|
@pulumi.getter(name="preserveSpace")
|
|
1739
|
-
def preserve_space(self) -> pulumi.Output[Optional[
|
|
1738
|
+
def preserve_space(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1740
1739
|
"""
|
|
1741
1740
|
Boolean that specifies whether the XML parser preserves leading and trailing spaces in element content.
|
|
1742
1741
|
"""
|
|
1743
1742
|
return pulumi.get(self, "preserve_space")
|
|
1744
1743
|
|
|
1745
|
-
@property
|
|
1744
|
+
@_builtins.property
|
|
1746
1745
|
@pulumi.getter(name="recordDelimiter")
|
|
1747
|
-
def record_delimiter(self) -> pulumi.Output[
|
|
1746
|
+
def record_delimiter(self) -> pulumi.Output[_builtins.str]:
|
|
1748
1747
|
"""
|
|
1749
1748
|
Specifies one or more singlebyte or multibyte characters that separate records in an input file (data loading) or unloaded file (data unloading).
|
|
1750
1749
|
"""
|
|
1751
1750
|
return pulumi.get(self, "record_delimiter")
|
|
1752
1751
|
|
|
1753
|
-
@property
|
|
1752
|
+
@_builtins.property
|
|
1754
1753
|
@pulumi.getter(name="replaceInvalidCharacters")
|
|
1755
|
-
def replace_invalid_characters(self) -> pulumi.Output[Optional[
|
|
1754
|
+
def replace_invalid_characters(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1756
1755
|
"""
|
|
1757
1756
|
Boolean that specifies whether to replace invalid UTF-8 characters with the Unicode replacement character (�).
|
|
1758
1757
|
"""
|
|
1759
1758
|
return pulumi.get(self, "replace_invalid_characters")
|
|
1760
1759
|
|
|
1761
|
-
@property
|
|
1760
|
+
@_builtins.property
|
|
1762
1761
|
@pulumi.getter
|
|
1763
|
-
def schema(self) -> pulumi.Output[
|
|
1762
|
+
def schema(self) -> pulumi.Output[_builtins.str]:
|
|
1764
1763
|
"""
|
|
1765
1764
|
The schema in which to create the file format.
|
|
1766
1765
|
"""
|
|
1767
1766
|
return pulumi.get(self, "schema")
|
|
1768
1767
|
|
|
1769
|
-
@property
|
|
1768
|
+
@_builtins.property
|
|
1770
1769
|
@pulumi.getter(name="skipBlankLines")
|
|
1771
|
-
def skip_blank_lines(self) -> pulumi.Output[Optional[
|
|
1770
|
+
def skip_blank_lines(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1772
1771
|
"""
|
|
1773
1772
|
Boolean that specifies to skip any blank lines encountered in the data files.
|
|
1774
1773
|
"""
|
|
1775
1774
|
return pulumi.get(self, "skip_blank_lines")
|
|
1776
1775
|
|
|
1777
|
-
@property
|
|
1776
|
+
@_builtins.property
|
|
1778
1777
|
@pulumi.getter(name="skipByteOrderMark")
|
|
1779
|
-
def skip_byte_order_mark(self) -> pulumi.Output[Optional[
|
|
1778
|
+
def skip_byte_order_mark(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1780
1779
|
"""
|
|
1781
1780
|
Boolean that specifies whether to skip the BOM (byte order mark), if present in a data file.
|
|
1782
1781
|
"""
|
|
1783
1782
|
return pulumi.get(self, "skip_byte_order_mark")
|
|
1784
1783
|
|
|
1785
|
-
@property
|
|
1784
|
+
@_builtins.property
|
|
1786
1785
|
@pulumi.getter(name="skipHeader")
|
|
1787
|
-
def skip_header(self) -> pulumi.Output[Optional[
|
|
1786
|
+
def skip_header(self) -> pulumi.Output[Optional[_builtins.int]]:
|
|
1788
1787
|
"""
|
|
1789
1788
|
Number of lines at the start of the file to skip.
|
|
1790
1789
|
"""
|
|
1791
1790
|
return pulumi.get(self, "skip_header")
|
|
1792
1791
|
|
|
1793
|
-
@property
|
|
1792
|
+
@_builtins.property
|
|
1794
1793
|
@pulumi.getter(name="stripNullValues")
|
|
1795
|
-
def strip_null_values(self) -> pulumi.Output[Optional[
|
|
1794
|
+
def strip_null_values(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1796
1795
|
"""
|
|
1797
1796
|
Boolean that instructs the JSON parser to remove object fields or array elements containing null values.
|
|
1798
1797
|
"""
|
|
1799
1798
|
return pulumi.get(self, "strip_null_values")
|
|
1800
1799
|
|
|
1801
|
-
@property
|
|
1800
|
+
@_builtins.property
|
|
1802
1801
|
@pulumi.getter(name="stripOuterArray")
|
|
1803
|
-
def strip_outer_array(self) -> pulumi.Output[Optional[
|
|
1802
|
+
def strip_outer_array(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1804
1803
|
"""
|
|
1805
1804
|
Boolean that instructs the JSON parser to remove outer brackets.
|
|
1806
1805
|
"""
|
|
1807
1806
|
return pulumi.get(self, "strip_outer_array")
|
|
1808
1807
|
|
|
1809
|
-
@property
|
|
1808
|
+
@_builtins.property
|
|
1810
1809
|
@pulumi.getter(name="stripOuterElement")
|
|
1811
|
-
def strip_outer_element(self) -> pulumi.Output[Optional[
|
|
1810
|
+
def strip_outer_element(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1812
1811
|
"""
|
|
1813
1812
|
Boolean that specifies whether the XML parser strips out the outer XML element, exposing 2nd level elements as separate documents.
|
|
1814
1813
|
"""
|
|
1815
1814
|
return pulumi.get(self, "strip_outer_element")
|
|
1816
1815
|
|
|
1817
|
-
@property
|
|
1816
|
+
@_builtins.property
|
|
1818
1817
|
@pulumi.getter(name="timeFormat")
|
|
1819
|
-
def time_format(self) -> pulumi.Output[
|
|
1818
|
+
def time_format(self) -> pulumi.Output[_builtins.str]:
|
|
1820
1819
|
"""
|
|
1821
1820
|
Defines the format of time values in the data files (data loading) or table (data unloading).
|
|
1822
1821
|
"""
|
|
1823
1822
|
return pulumi.get(self, "time_format")
|
|
1824
1823
|
|
|
1825
|
-
@property
|
|
1824
|
+
@_builtins.property
|
|
1826
1825
|
@pulumi.getter(name="timestampFormat")
|
|
1827
|
-
def timestamp_format(self) -> pulumi.Output[
|
|
1826
|
+
def timestamp_format(self) -> pulumi.Output[_builtins.str]:
|
|
1828
1827
|
"""
|
|
1829
1828
|
Defines the format of timestamp values in the data files (data loading) or table (data unloading).
|
|
1830
1829
|
"""
|
|
1831
1830
|
return pulumi.get(self, "timestamp_format")
|
|
1832
1831
|
|
|
1833
|
-
@property
|
|
1832
|
+
@_builtins.property
|
|
1834
1833
|
@pulumi.getter(name="trimSpace")
|
|
1835
|
-
def trim_space(self) -> pulumi.Output[Optional[
|
|
1834
|
+
def trim_space(self) -> pulumi.Output[Optional[_builtins.bool]]:
|
|
1836
1835
|
"""
|
|
1837
1836
|
Boolean that specifies whether to remove white space from fields.
|
|
1838
1837
|
"""
|