ɯeiddlZddlmZddlmZmZmZmZmZm Z m Z ddl Z ddl mcmcmcmcmZddlmZmZmZmZddlmZmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$ddl%m&Z&ddl'm(Z(m)Z)dd l*m+Z+m,Z,dd l-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7dd l8m9Z9m:Z:dd l;mZ>dd l?m@Z@ddlAmBZBddlCmDZDddlEmFZFejdkrddlmHZHnddlImHZHdddddddZJeeKZLGddZMy)N) getLogger)AnyDictListLiteralOptionalUnionoverload)CopyIntoLocationNodeSaveModeSnowflakeCreateTableTableCreationSource) +build_expr_from_snowpark_column_or_col_name*build_expr_from_snowpark_column_or_sql_str-build_expr_from_snowpark_column_or_python_valbuild_expr_from_python_valdebug_check_missing_astfill_save_modefill_write_filewith_src_positionDATAFRAME_AST_PARAMETERbuild_table_name)"track_data_source_statement_params)open_telemetry_context_manager) add_api_calldfw_collect_api_telemetry) ColumnOrNameColumnOrSqlExpr) SUPPORTED_TABLE_TYPESget_aliased_option_nameget_copy_into_location_options is_cloud_pathnormalize_remote_file_or_dirparse_table_name publicapi str_to_enumvalidate_object_namewarning)AsyncJob_AsyncResultType)Column_to_col_if_str_to_col_if_sql_expr)SnowparkClientException)sql_expr)MockServerConnection)Row) )IterableFIELD_DELIMITERRECORD_DELIMITERFIELD_OPTIONALLY_ENCLOSED_BYNULL_IF DATE_FORMATTIMESTAMP_FORMAT)SEPLINESEPQUOTE NULLVALUE DATEFORMATTIMESTAMPFORMATc, eZdZdZe dJdddeddfdZedJd ededdfd Ze dJd e deddfd Z edJd ede deddfdZ e dKde ededdfdZeeddddddddddeeeefde ededededde eede eeefdedede eee fddfd Zeeddddddddddeeeefde ededededde eede eeefdedede eee fdefd!Zeedddddddddddddddddd"deeeefde ededededde eede eeefded#e ed$e ed%e ed&e ed'e ed(ed)e eeeeee ffd*e ed+e e dede eee fde ef(d,Zeeddddddddddddd- d.ed/e e d0e ed1e ed2e eeefd3ede eeefdedd4e ed5e ed6e ed7e eded8e eee fdeefd9Zeeddddddddddddd- d.ed/e e d0e ed1e ed2e eeefd3ede eeefdedd4e ed5e ed6e ed7e eded8e eee fdefd:Zeddddddddddddd- d.ed/e e d0e ed1e ed2e eeefd3ede eeefded4e ed;d5e ed6e ed7e eded8e eee fdeeeeffd<Zddddddddddddd- d=ed.ed/e e d0e ed1e ed2e eeefd3ede eeefded4e ed5e ed6e ed7e eded8e eee fdeeeeff d>Zedefd?Zej@deddfd@Ze dJd0edAdeddfdBZ!edddddddddddC d.ed/e e d2e eeefd3ede eeefded4e ed5e ed6e ed7e eded8e edeeeeffdDZ"edddddddddddC d.ed/e e d2e eeefd3ede eeefded4e ed5e ed6e ed7e eded8e edeeeeffdEZ#edddddddddddC d.ed/e e d2e eeefd3ede eeefded4e ed5e ed6e ed7e eded8e edeeeeffdFZ$edddddddddddC d.ed/e e d2e eeefd3ede eeefded4e ed5e ed6e ed7e eded8e edeeeeffdGZ%e dLdeeeefdHededdfdIZ&e&Z'eZ(y)MDataFrameWritera;Provides methods for writing data from a :class:`DataFrame` to supported output destinations. To use this object: 1. Create an instance of a :class:`DataFrameWriter` by accessing the :attr:`DataFrame.write` property. 2. (Optional) Specify the save mode by calling :meth:`mode`, which returns the same :class:`DataFrameWriter` that is configured to save data using the specified mode. The default mode is "errorifexists". 3. Call :meth:`save_as_table` or :meth:`copy_into_location` to save the data to the specified destination. T dataframez&snowflake.snowpark.dataframe.DataFrame _emit_astreturnNcz||_tj|_d|_i|_d|_d|_|rt|j|j|tj}t|j||_|j|jjj yyN) _dataframer ERROR_IF_EXISTS _save_mode _partition_by _cur_options_DataFrameWriter__format_astr_ast_id_sessionprotoExprrdataframe_writer _set_ast_refdf)selfrCrDwriters e/var/www/html/glpi_dashboard/venv/lib/python3.12/site-packages/snowflake/snowpark/dataframe_writer.py__init__zDataFrameWriter.__init__Zs $"228<,.'+   #I$5$5y7I7I9 UZZ\F f55 6DI  " "499#=#=#@#@ A  save_modect|jtd|_|r@|j4t |jj j|j|S)aSet the save mode of this :class:`DataFrameWriter`. Args: save_mode: One of the following strings. "append": Append data of this DataFrame to the existing table. Creates a table if it does not exist. "overwrite": Overwrite the existing table by dropping old table. "truncate": Overwrite the existing table by truncating old table. "errorifexists": Throw an exception if the table already exists. "ignore": Ignore this operation if the table already exists. Default value is "errorifexists". Returns: The :class:`DataFrameWriter` itself. z `save_mode`)r&lowerr rJrNrrSr[)rVr[rDs rXmodezDataFrameWriter.modeosO2%0 OO x%  . 49955?? Q rZexprc||_|r6|j*t|jjj||S)zSpecifies an expression used to partition the unloaded table rows into separate files. It can be a :class:`Column`, a column name, or a SQL expression. )rKrNrrS partition_by)rVr_rDs rXrazDataFrameWriter.partition_bys>" . 6 **77  rZkeyvaluect|t}||j|<|rW|jK|jjj j }||_t|j||S)aDepending on the ``file_format_type`` specified, you can include more format specific options. Use the options documented in the `Format Type Options `__. ) r WRITER_OPTIONS_ALIAS_MAPrLrNrSoptionsadd_1r_2)rVrbrcrD aliased_keyts rXoptionzDataFrameWriter.optionsg .c3KL ).+& . **22668AAD 9!$$ F rZconfigsc |r |r td||s td|}|jD]\}}|j||||S)zSets multiple specified options for this :class:`DataFrameWriter`. This method is same as calling :meth:`option` except that you can set multiple options at once. z]Cannot set options with both a dictionary and keyword arguments. Please use one or the other.zNo options were provided)rD) ValueErroritemsrl)rVrmrDkwargskvs rXrfzDataFrameWriter.optionssd vo  ? !;<<GMMO 3DAq KK1 K 2 3 rZindexF)r^ column_ordercreate_temp_table table_typeclustering_keysstatement_paramsblockrD table_namer^rvrwrx)rutemp temporary transientryrzr{rqc yrG rVr|r^rvrwrxryrzr{rDrqs rX save_as_tablezDataFrameWriter.save_as_table rZc yrGrrs rXrzDataFrameWriter.save_as_tablerrZ)r^rvrwrxryrzr{commentenable_schema_evolutiondata_retention_timemax_data_extension_timechange_tracking copy_grantsiceberg_config table_existsoverwrite_conditionrDrrrrrrrrrc * t|j|xs|jj}|r|jw|jjj j }t|jj}|jj|jt|j||t|j||||_||_||_|+|D]&}t'|j(j+|(|@|j-D]-\}}|j.j+}||_||_/||_| | |j6_| | |j:_| | |j<_| | |j>_| | |j@_||_!|O|j-D]<\}}|jDj+}||_tG|j2|>|||jH_|tK|jL||jjj jO||jjj jQ|\}|tR<tU|jV|j5|rtY|j[t\dn |j^}ta|tbr|ndje|}tg|ta|tbr ti|n|}||j[dvr tkdd}|j[dk(r;|jjljoDcgc]}|jp}}|r$|Dcgc]}ts|djtc}ng} |rtwdd d }|r(|j[txvrtkd tx|,|t\jzk7rtkd |j8d |t}|djtnd}!|jj}"|t\j~t\jfvxs|t\jzk(xr|du}#|-ta|"jts|#r|"j|}t||||jjtj|| | | | | | ||||!}$|"jj|$}%|"jj|%f||tjd|}&|s|&ndcdddScc}wcc}w#1swYyxYw)a[#Writes the data to the specified table in a Snowflake database. Args: table_name: A string or list of strings representing table name. If input is a string, it represents the table name; if input is of type iterable of strings, it represents the fully-qualified object identifier (database name, schema name, and table name). mode: One of the following values. When it's ``None`` or not provided, the save mode set by :meth:`mode` is used. "append": Append data of this DataFrame to the existing table. Creates a table if it does not exist. "overwrite": Overwrite the existing table. By default, drops and recreates the table. When ``overwrite_condition`` is specified, performs selective overwrite: deletes only rows matching the condition, then inserts new data. "truncate": Overwrite the existing table by truncating old table. "errorifexists": Throw an exception if the table already exists. "ignore": Ignore this operation if the table already exists. column_order: When ``mode`` is "append", data will be inserted into the target table by matching column sequence or column name. Default is "index". When ``mode`` is not "append", the ``column_order`` makes no difference. "index": Data will be inserted into the target table by column sequence. "name": Data will be inserted into the target table by matching column names. If the target table has more columns than the source DataFrame, use this one. create_temp_table: (Deprecated) The to-be-created table will be temporary if this is set to ``True``. table_type: The table type of table to be created. The supported values are: ``temp``, ``temporary``, and ``transient``. An empty string means to create a permanent table. Not applicable for iceberg tables. Learn more about table types `here `_. clustering_keys: Specifies one or more columns or column expressions in the table as the clustering key. See `Clustering Keys & Clustered Tables `_ for more details. comment: Adds a comment for the created table. See `COMMENT `_. This argument is ignored if a table already exists and save mode is ``append`` or ``truncate``. enable_schema_evolution: Enables or disables automatic changes to the table schema from data loaded into the table from source files. Setting to ``True`` enables automatic schema evolution and setting to ``False`` disables it. If not set, the default behavior is used. data_retention_time: Specifies the retention period for the table in days so that Time Travel actions (SELECT, CLONE, UNDROP) can be performed on historical data in the table. max_data_extension_time: Specifies the maximum number of days for which Snowflake can extend the data retention period for the table to prevent streams on the table from becoming stale. change_tracking: Specifies whether to enable change tracking for the table. If not set, the default behavior is used. copy_grants: When true, retain the access privileges from the original table when a new table is created with "overwrite" mode. statement_params: Dictionary of statement level parameters to be set while executing this action. block: A bool value indicating whether this function will wait until the result is available. When it is ``False``, this function executes the underlying queries of the dataframe asynchronously and returns an :class:`AsyncJob`. iceberg_config: A dictionary that can contain the following iceberg configuration values: * partition_by: specifies one or more partition expressions for the Iceberg table. Can be a single Column, column name, SQL expression string, or a list of these. Supports identity partitioning (column names) as well as partition transform functions like bucket(), truncate(), year(), month(), day(), hour(). * external_volume: specifies the identifier for the external volume where the Iceberg table stores its metadata files and data in Parquet format * catalog: specifies either Snowflake or a catalog integration to use for this table * base_location: the base directory that snowflake can write iceberg metadata and files to * target_file_size: specifies a target Parquet file size for the table. Valid values: 'AUTO' (default), '16MB', '32MB', '64MB', '128MB' * catalog_sync: optionally sets the catalog integration configured for Polaris Catalog * storage_serialization_policy: specifies the storage serialization policy for the table * iceberg_version: Overrides the version of iceberg to use. Defaults to 2 when unset. table_exists: Optional parameter to specify if the table is known to exist or not. Set to ``True`` if table exists, ``False`` if it doesn't, or ``None`` (default) for automatic detection. Primarily useful for "append", "truncate", and "overwrite" with overwrite_condition modes to avoid running query for automatic detection. overwrite_condition: Specifies the overwrite condition to perform atomic targeted delete-insert. Can only be used when ``mode`` is "overwrite". When provided and the table exists, rows matching the condition are atomically deleted and all rows from the DataFrame are inserted, preserving non-matching rows. When not provided, the default "overwrite" behavior applies (drop and recreate table). If the table does not exist, ``overwrite_condition`` is ignored and the table is created normally. Example 1:: Basic table saves >>> df = session.create_dataframe([[1,2],[3,4]], schema=["a", "b"]) >>> df.write.mode("overwrite").save_as_table("my_table", table_type="temporary") >>> session.table("my_table").collect() [Row(A=1, B=2), Row(A=3, B=4)] >>> df.write.save_as_table("my_table", mode="append", table_type="temporary") >>> session.table("my_table").collect() [Row(A=1, B=2), Row(A=3, B=4), Row(A=1, B=2), Row(A=3, B=4)] >>> df.write.mode("overwrite").save_as_table("my_transient_table", table_type="transient") >>> session.table("my_transient_table").collect() [Row(A=1, B=2), Row(A=3, B=4)] Example 2:: Saving DataFrame to an Iceberg table. Note that the external_volume, catalog, and base_location should have been setup externally. See `Create your first Iceberg table `_ for more information on creating iceberg resources. >>> df = session.create_dataframe([[1,2],[3,4]], schema=["a", "b"]) >>> from snowflake.snowpark.functions import col, bucket >>> iceberg_config = { ... "external_volume": "example_volume", ... "catalog": "example_catalog", ... "base_location": "/iceberg_root", ... "storage_serialization_policy": "OPTIMIZED", ... "target_file_size": "128MB", ... "partition_by": ["a", bucket(3, col("b"))], ... } >>> df.write.mode("overwrite").save_as_table("my_table", iceberg_config=iceberg_config) # doctest: +SKIP Example 3:: Using overwrite_condition for targeted delete and insert: >>> from snowflake.snowpark.functions import col >>> df = session.create_dataframe([[1, "a"], [2, "b"], [3, "c"]], schema=["id", "val"]) >>> df.write.mode("overwrite").save_as_table("my_table", table_type="temporary") >>> session.table("my_table").order_by("id").collect() [Row(ID=1, VAL='a'), Row(ID=2, VAL='b'), Row(ID=3, VAL='c')] >>> new_df = session.create_dataframe([[2, "updated2"], [5, "updated5"]], schema=["id", "val"]) >>> new_df.write.mode("overwrite").save_as_table("my_table", overwrite_condition="id = 1 or val = 'b'") >>> session.table("my_table").order_by("id").collect() [Row(ID=2, VAL='updated2'), Row(ID=3, VAL='c'), Row(ID=5, VAL='updated5')] Nz'mode'.)namertz/'column_order' must be either 'name' or 'index'rzDataFrameWriter.save_as_tablezsave_as_table.create_temp_tablezcreate_temp_table is deprecated. We still respect this parameter when it is True but please consider using `table_type="temporary"` instead.r~z.Unsupported table type. Expected table types: zI'overwrite_condition' is only supported with mode='overwrite'. Got mode='z'.)_statement_paramsr{ data_type)MrrHrrNrP _ast_batchbindrr_ write_tablerWCopyFromrr|rr^rvrwrxrryrgrprzrhrir{rrcrrrrrrrrrrevalflushrrrr&r]r rJ isinstancestrjoinr'r$roschema_to_attributesrr, _expressionr(r OVERWRITEr-APPENDTRUNCATE_connr0 _table_existsr _planrOTHERS _analyzerresolveexecuter* NO_RESULT)'rVr|r^rvrwrxryrzr{rrrrrrrrrrDrqstmtr_ col_or_namerrrsrk_r[full_table_name column_namesxcolclustering_exprsoverwrite_condition_exprsessionneeds_table_exists_checkcreate_table_logic_plansnowflake_planresults' rXrzDataFrameWriter.save_as_tablesx> OO-R1R1R  .??++66;;=D$TYY%:%:;D KK  +, T__j 9tyy$/'$0!%6D "(DO*#2K?,,002K  +,224DAq--113AADAD DJ"%, "&25L,,2".1D((.&25L,,2*-<$$**D )*0028DAq++//1AAD.qttQ78'*6!!'".:,,.A OO $ $ / / 4 4T : ((3399$? ./,D,>,> Pe 1DJJL(H=__  )S9 sxx ?S  ! 1j#.!,  #|'9'9';CT'T !RSSL!!#v-040F0F0U0U0WX1X X# /#3(GHTT  !5N ) j..08MM DEZD[\ #.9@R@R3R !!* 15'2$')H+ %oo..G'0!!5((Wx111U6IQU6U % $"7==2FG, '44Z@ &:%%#** '#'(!' #$%..667NON*W]]**"2*44   F"'6DKe 1e 1( Y/e 1e 1s,CV )U?<V V!FV ? V  V) rafile_format_namefile_format_typeformat_type_optionsheaderrzr{validation_modestorage_integration credentials encryptionrDlocationrarrrrrrrr copy_optionsc yrGrrVrrarrrrrzr{rrrrrDrs rXcopy_into_locationz"DataFrameWriter.copy_into_locationC( rZc yrGrrs rXrz"DataFrameWriter.copy_into_locationYrrZ RETURN_ROWSc  D|jdd||||||||| | | | | d|S)aExecutes a `COPY INTO `__ to unload data from a ``DataFrame`` into one or more files in a stage or external stage. Args: location: The destination stage location. partition_by: Specifies an expression used to partition the unloaded table rows into separate files. It can be a :class:`Column`, a column name, or a SQL expression. file_format_name: Specifies an existing named file format to use for unloading data from the table. The named file format determines the format type (CSV, JSON, PARQUET), as well as any other format options, for the data files. file_format_type: Specifies the type of files unloaded from the table. If a format type is specified, additional format-specific options can be specified in ``format_type_options``. format_type_options: Depending on the ``file_format_type`` specified, you can include more format specific options. Use the options documented in the `Format Type Options `__. header: Specifies whether to include the table column headings in the output files. statement_params: Dictionary of statement level parameters to be set while executing this action. copy_options: The kwargs that are used to specify the copy options. Use the options documented in the `Copy Options `__. block: A bool value indicating whether this function will wait until the result is available. When it is ``False``, this function executes the underlying queries of the dataframe asynchronously and returns an :class:`AsyncJob`. validation_mode: String (constant) that instructs the COPY command to return the results of the query in the SQL statement instead of unloading the results to the specified cloud storage location. The only supported validation option is RETURN_ROWS. This option returns all rows produced by the query. storage_integration: Specifies the name of the storage integration used to delegate authentication responsibility for external cloud storage to a Snowflake identity and access management (IAM) entity. credentials: Specifies the security credentials for connecting to the cloud provider and accessing the private/protected cloud storage. encryption: Specifies the encryption settings used to decrypt encrypted files in the storage location. Returns: A list of :class:`Row` objects containing unloading results. Example:: >>> # save this dataframe to a parquet file on the session stage >>> df = session.create_dataframe([["John", "Berry"], ["Rick", "Berry"], ["Anthony", "Davis"]], schema = ["FIRST_NAME", "LAST_NAME"]) >>> remote_file_path = f"{session.get_session_stage()}/names.parquet" >>> copy_result = df.write.copy_into_location(remote_file_path, file_format_type="parquet", header=True, overwrite=True, single=True) >>> copy_result[0].rows_unloaded 3 >>> # the following code snippet just verifies the file content and is actually irrelevant to Snowpark >>> # download this file and read it using pyarrow >>> import os >>> import tempfile >>> import pyarrow.parquet as pq >>> with tempfile.TemporaryDirectory() as tmpdirname: ... _ = session.file.get(remote_file_path, tmpdirname) ... pq.read_table(os.path.join(tmpdirname, "names.parquet")) pyarrow.Table FIRST_NAME: string not null LAST_NAME: string not null ---- FIRST_NAME: [["John","Rick","Anthony"]] LAST_NAME: [["Berry","Berry","Davis"]] r)callerrrarrrrrzr{rrrrrDr_internal_copy_into_locationrs rXrz"DataFrameWriter.copy_into_locationosSD1t00 '%-- 3-+ 3#!   rZrc  li}t|j|xs|jj}|r,|j|jjj j }tt|jd|z}|jj|jt||f||||| | | | | d ||dk(r&|||j_|||j_|jjj j!||jjj j#|\}|t$<t'|s t)|n|}||n |j*}t-|t.rt1|j2}n6t-|t4r |j2}n|t7dt9|t;|j<\}}|r|j?||r@i}|jAD]\}}tC|tD}|||<|j?||jjGtI|jjJ|||||||| | | |  }tM|d|jNd|| d|S) zInternal method to return a DataFrame that represents the result of the COPY INTO operation. This is used by the public copy_into_location method to perform the actual operation. write_) rarrrzr{rrrrrz_'partition_by' is expected to be a column name, a Column object, or a sql expression. Got type ) rarrrrrrrrrz"DataFrameWriter.copy_into_location)rzr{r)(rrHrrNrPrrrgetattrr_rWrrrrcrrrrr"r#rKrrr/rr+ TypeErrortyper!rLupdaterpr re _with_planr rr_internal_collect_with_tag)rVrrrarrrrrzr{rrrrrDrrqrr_rstage_locationcur_format_type_optionscur_copy_optionsformat_type_aliased_optionsrbrcrjrUs rXrz,DataFrameWriter._internal_copy_into_locations0= OO-R1R1R  .??++66;;=D$WTYY68I%JKD KK  +  *$7!1 /$7'%  --#/2BD))/#/2BD))/ OO $ $ / / 4 4T : ((3399$? ./ !* ) 2  (4'?|TEWEW lC (#L1==L  f -'33L  %qrvxDsErFG  5S   5 1!1   # #L 1 *, '1779 A U5c;ST ;@+K8 A $ * *+F G __ ' ' %%)!1!1$;- /$7'%   R=>,r,, -   rZc|jSrG)rM)rVs rX_formatzDataFrameWriter._format9s }}rZcgd}|jj}||vrtd|d|d||_y)Ncsvjsonparquetz0Unsupported file format. Expected file formats: z, got '')stripr]rorM)rVrcallowed_formatscanon_file_format_names rXrzDataFrameWriter._format=sQ4!&!4!4!6 ! 8B?BSSZ[`Zaabc / rZrc||_|r;|j/|j|jjj_|S)zSpecifies the file format type to use for unloading data from the table. Allowed values are "csv", "json", and "parquet". The file format name can be case insensitive and will be used when calling :meth:`save`. )rrNrSformatrc)rVrrDs rXrzDataFrameWriter.formatHs8( .6:llDII & & - - 3 rZ) rarrrzr{rrrrrDc  |j td|jdd||j|||||||| | | d | S)a Executes internally a `COPY INTO `__ to unload data from a ``DataFrame`` into a file in a stage or external stage. The file format type is determined by the last call to :meth:`format`. Args: location: The destination stage location. partition_by: Specifies an expression used to partition the unloaded table rows into separate files. It can be a :class:`Column`, a column name, or a SQL expression. format_type_options: Depending on the ``file_format_type`` specified, you can include more format specific options. Use the options documented in the `Format Type Options `__. header: Specifies whether to include the table column headings in the output files. statement_params: Dictionary of statement level parameters to be set while executing this action. copy_options: The kwargs that are used to specify the copy options. Use the options documented in the `Copy Options `__. block: A bool value indicating whether this function will wait until the result is available. When it is ``False``, this function executes the underlying queries of the dataframe asynchronously and returns an :class:`AsyncJob`. validation_mode: Specifies the validation mode to use for unloading data from the table. storage_integration: Specifies the name of the storage integration used to delegate authentication responsibility for external cloud storage to a Snowflake identity and access management (IAM) entity. credentials: Specifies the security credentials for connecting to the cloud provider and accessing the private/protected cloud storage. encryption: Specifies the encryption settings used to decrypt encrypted files in the storage location. Returns: A list of :class:`Row` objects containing unloading results. Example:: >>> # save this dataframe to a csv file on the session stage >>> df = session.create_dataframe([["John", "Berry"], ["Rick", "Berry"], ["Anthony", "Davis"]], schema = ["FIRST_NAME", "LAST_NAME"]) >>> remote_file_path = f"{session.get_session_stage()}/names.csv" >>> copy_result = df.write.format("csv").save(remote_file_path, overwrite=True, single=True) >>> copy_result[0].rows_unloaded 3 zGFile format type is not specified. Call `format` before calling `save`.save rrrrarrrzr{rrrrrDr)rror rVrrarrrzr{rrrrrDrs rXrzDataFrameWriter.saveVsp^ << Y 1t00 !\\% 3-+ 3#!   rZc  B|jdd|d|||||||| | | d | S)a3 Executes internally a `COPY INTO `__ to unload data from a ``DataFrame`` into one or more CSV files in a stage or external stage. Args: location: The destination stage location. partition_by: Specifies an expression used to partition the unloaded table rows into separate files. It can be a :class:`Column`, a column name, or a SQL expression. format_type_options: Depending on the ``file_format_type`` specified, you can include more format specific options. Use the options documented in the `Format Type Options `__. header: Specifies whether to include the table column headings in the output files. statement_params: Dictionary of statement level parameters to be set while executing this action. copy_options: The kwargs that are used to specify the copy options. Use the options documented in the `Copy Options `__. block: A bool value indicating whether this function will wait until the result is available. When it is ``False``, this function executes the underlying queries of the dataframe asynchronously and returns an :class:`AsyncJob`. validation_mode: Specifies the validation mode to use for unloading data from the table. storage_integration: Specifies the name of the storage integration used to delegate authentication responsibility for external cloud storage to a Snowflake identity and access management (IAM) entity. credentials: Specifies the security credentials for connecting to the cloud provider and accessing the private/protected cloud storage. encryption: Specifies the encryption settings used to decrypt encrypted files in the storage location. Returns: A list of :class:`Row` objects containing unloading results. Example:: >>> # save this dataframe to a csv file on the session stage >>> df = session.create_dataframe([["John", "Berry"], ["Rick", "Berry"], ["Anthony", "Davis"]], schema = ["FIRST_NAME", "LAST_NAME"]) >>> remote_file_path = f"{session.get_session_stage()}/names.csv" >>> copy_result = df.write.csv(remote_file_path, overwrite=True, single=True) >>> copy_result[0].rows_unloaded 3 rCSVrrrrs rXrzDataFrameWriter.csvsP\1t00 "% 3-+ 3#!   rZc  B|jdd|d|||||||| | | d | S)a Executes internally a `COPY INTO `__ to unload data from a ``DataFrame`` into a JSON file in a stage or external stage. Args: location: The destination stage location. partition_by: Specifies an expression used to partition the unloaded table rows into separate files. It can be a :class:`Column`, a column name, or a SQL expression. format_type_options: Depending on the ``file_format_type`` specified, you can include more format specific options. Use the options documented in the `Format Type Options `__. header: Specifies whether to include the table column headings in the output files. statement_params: Dictionary of statement level parameters to be set while executing this action. copy_options: The kwargs that are used to specify the copy options. Use the options documented in the `Copy Options `__. block: A bool value indicating whether this function will wait until the result is available. When it is ``False``, this function executes the underlying queries of the dataframe asynchronously and returns an :class:`AsyncJob`. validation_mode: Specifies the validation mode to use for unloading data from the table. storage_integration: Specifies the name of the storage integration used to delegate authentication responsibility for external cloud storage to a Snowflake identity and access management (IAM) entity. credentials: Specifies the security credentials for connecting to the cloud provider and accessing the private/protected cloud storage. encryption: Specifies the encryption settings used to decrypt encrypted files in the storage location. Returns: A list of :class:`Row` objects containing unloading results. Example:: >>> # save this dataframe to a json file on the session stage >>> df = session.sql("select parse_json('[{a: 1, b: 2}, {a: 3, b: 0}]')") >>> remote_file_path = f"{session.get_session_stage()}/names.json" >>> copy_result = df.write.json(remote_file_path, overwrite=True, single=True) >>> copy_result[0].rows_unloaded 1 rJSONrrrrs rXrzDataFrameWriter.jsonsP\1t00 #% 3-+ 3#!   rZc  B|jdd|d|||||||| | | d | S)a- Executes internally a `COPY INTO `__ to unload data from a ``DataFrame`` into a PARQUET file in a stage or external stage. Args: location: The destination stage location. partition_by: Specifies an expression used to partition the unloaded table rows into separate files. It can be a :class:`Column`, a column name, or a SQL expression. format_type_options: Depending on the ``file_format_type`` specified, you can include more format specific options. Use the options documented in the `Format Type Options `__. header: Specifies whether to include the table column headings in the output files. statement_params: Dictionary of statement level parameters to be set while executing this action. copy_options: The kwargs that are used to specify the copy options. Use the options documented in the `Copy Options `__. block: A bool value indicating whether this function will wait until the result is available. When it is ``False``, this function executes the underlying queries of the dataframe asynchronously and returns an :class:`AsyncJob`. validation_mode: String (constant) that instructs the COPY command to return the results of the query in the SQL statement instead of unloading the results to the specified cloud storage location. The only supported validation option is RETURN_ROWS. This option returns all rows produced by the query. storage_integration: Specifies the name of the storage integration used to delegate authentication responsibility for external cloud storage to a Snowflake identity and access management (IAM) entity. credentials: Specifies the security credentials for connecting to the cloud provider and accessing the private/protected cloud storage. encryption: Specifies the encryption settings used to decrypt encrypted files in the storage location. Returns: A list of :class:`Row` objects containing unloading results. Example:: >>> # save this dataframe to a parquet file on the session stage >>> df = session.create_dataframe([["John", "Berry"], ["Rick", "Berry"], ["Anthony", "Davis"]], schema = ["FIRST_NAME", "LAST_NAME"]) >>> remote_file_path = f"{session.get_session_stage()}/names.parquet" >>> copy_result = df.write.parquet(remote_file_path, overwrite=True, single=True) >>> copy_result[0].rows_unloaded 3 rPARQUETrrrrs rXrzDataFrameWriter.parquetsP`1t00 &% 3-+ 3#!   rZ overwritecFt|tr|ndj|}t|t|tr t |n|}|j j j|std|di}|r|j|j j jj}t|jj}|jj!|jt#|j$|||_|j j jj)||j j jj+|\} |t,<|j.|f|rdnddd|y) a Inserts the content of the DataFrame to the specified table. It requires that the schema of the DataFrame is the same as the schema of the table. Args: table_name: A string or list of strings representing table name. If input is a string, it represents the table name; if input is of type iterable of strings, it represents the fully-qualified object identifier (database name, schema name, and table name). overwrite: If True, the content of table will be overwritten. If False, the data will be appended to the table. Default is False. Example:: >>> # save this dataframe to a json file on the session stage >>> df = session.create_dataframe([["John", "Berry"]], schema = ["FIRST_NAME", "LAST_NAME"]) >>> df.write.save_as_table("my_table", table_type="temporary") >>> df2 = session.create_dataframe([["Rick", "Berry"]], schema = ["FIRST_NAME", "LAST_NAME"]) >>> df2.write.insert_into("my_table") >>> session.table("my_table").collect() [Row(FIRST_NAME='John', LAST_NAME='Berry'), Row(FIRST_NAME='Rick', LAST_NAME='Berry')] rzTable z" does not exist or not authorized.NtruncateappendF)r^rD)rrrr'r$rHrPrr.rNrrrr_write_insert_intorWrrr|rrrrr) rVr|rrDrqualified_table_namerqrr_rs rX insert_intozDataFrameWriter.insert_intoZsh:%Z5J388J;O  _-,6z3,G Z (Z ''556JK)))KL   .??++66;;=D$TYY%@%@AD KK  + T__j 9&DN OO $ $ / / 4 4T : ((3399$? ./   (h   rZ)T)NT)FT))__name__ __module__ __qualname____doc__r%boolrYrr^rrarrlrrrfr r r4rrrr)rintdictrr1rrpropertyrsetterrrrrrr insertInto saveAsTablerrZrXrBrBMs  B;BB  BB( c d >O  D7;#04   # c d FW  @D~9= ( ##"'DF<@59 #x},- sm      @A "(<"89 #4S>2   4S>*     ##"'DF<@59 #x},- sm      @A "(<"89 #4S>2   4S>*     ##"'DF<@59!%26-115*.! '+9=-S1#x},-S1sm S1  S1  S1@AS1"(<"89S1#4S>2S1S1#S1"*$S1&c]S1"*#S1"$S1 !S1"! eC/!::;; < #S1(tn)S1*&o6+S1,-S1.4S>*/S10 ( 1S1S1j  37*.*.8<59#)--1&*%)  /  #3-  #3-  &d38n5  #4S>2 t} "# &c] d^ TN  !c3h0! " c#  ( 37*.*.8<59 %)--1&*%)  /  #3-  #3-  &d38n5  #4S>2 u~ "# &c] d^ TN  !c3h0! " #  ( 37*.*.8<59<@-1&*%)Q Q / Q #3- Q #3- Q &d38n5Q Q #4S>2Q Q "'-"89Q &c]Q d^Q TNQ Q !c3h0!Q " tCy(" ##Q Q p37*.*.8<59)--1&*%)!t t t / t #3- t #3-t &d38n5t t #4S>2t t "#t &c]t d^t TNt !t "!c3h0#t $ tCy(" #%t l ^^/S/T// !":;      378<59)--1&*%)B B / B &d38n5 B  B #4S>2B B "#B &c]B d^B TNB B ! B  tCy(" #B B H 378<59)--1&*%)< < / < &d38n5 <  < #4S>2< < "#< &c]< d^< TN< < ! <  tCy(" #< < | 378<59)--1&*%)< < / < &d38n5 <  < #4S>2< < "#< &c]< d^< TN< < ! <  tCy(" #< < | 378<59)--1&*%)> > / > &d38n5 >  > #4S>2> > "#> &c]> d^> TN> > ! >  tCy(" #> > @  C #x},-C C  C  C C JJKrZrB)Nsysloggingrtypingrrrrrr r snowflake.snowpark snowflake4snowflake.snowpark._internal.proto.generated.ast_pb2snowpark _internalrQ generatedast_pb29snowflake.snowpark._internal.analyzer.snowflake_plan_noder r r r&snowflake.snowpark._internal.ast.utilsrrrrrrrrrr.snowflake.snowpark._internal.data_source.utilsr+snowflake.snowpark._internal.open_telemetryr&snowflake.snowpark._internal.telemetryrr'snowflake.snowpark._internal.type_utilsrr"snowflake.snowpark._internal.utilsrr r!r"r#r$r%r&r'r(snowflake.snowpark.async_jobr)r*snowflake.snowpark.columnr+r,r-snowflake.snowpark.exceptionsr.snowflake.snowpark.functionsr/#snowflake.snowpark.mock._connectionr0snowflake.snowpark.rowr1 version_infor4collections.abcrer_loggerrBrrZrXrs  FFFDDD   WR   DQQA1D& v( ! +)  H T T rZ