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