o EDi@sddlZddlZddlmZddlZddlmZmZddlm Z m Z m Z m Z m Z mZmZmZddlmZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'ddl(m)Z)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8ddl9m:Z:ddl;mZ>ddl?m@Z@mAZAmBZBmCZCmDZDddlEmFZFde_GeHeIZJdZKGdddeZLdS)N)tzinfo)ABCabstractmethod)IterableOptionalAnyUnionSequenceDict GeneratorBinaryIO)UnknownTimeZoneError)common)version get_from_name)ClickHouseType)dynamic)tzutil) dict_copy StreamContext coerce_int coerce_bool)CH_VERSION_WITH_PROTOCOLPROTOCOL_VERSION_WITH_LOW_CARD)ProgrammingErrorOperationalError DataError) ExternalData) InsertContext) check_arrow check_pandas check_numpy check_polarspdarrowpl IS_PANDAS_2) QuerySummary) ColumnDef SettingDef SettingStatus) QueryResultto_arrowto_arrow_batches QueryContext arrow_buffer)quote_identifieri$output_format_arrow_string_as_stringc,@szeZdZUdZdZeed<dZeed<dZe Z e Z dZ dZ dZdZdZded ed ed ed eed eeeefdeedeefddZd eeeeffddZdeeeefdeeeffddZdedededeefddZdedefddZdefd d!Zdeefd"d#Z e!defd$d%Z"e!d&d'Z#e!deefd(d)Z$e!d*efd+d,Z%                dd-eed.eee&eeeffdeeeefd/eeeefd0eeeeeeeefffd1eed2eed3eed4eed5eeded6eeeefd7eeeeeeffdeed8ee'd9eeeefde(f"d:d;Z)             dd-eed.eee&eeeffdeeeefd/eeeefd0eeeeeeeefffd1eed2eeded6eeeefd7eeeeeeffdeed8ee'd9eeeefde*fdd?Z,             dd-eed.eee&eeeffdeeeefd/eeeefd0eeeeeeeefffd1eed2eeded6eeeefd7eeeeeeffdeed8ee'd9eeeefde*fd@dAZ-e!      dd-ed.eee&eeeffdeeeefdBedCed8ee'd9eeeefde.fdDdEZ/e!      dd-ed.eee&eeeffdeeeefdBedCed8ee'd9eeeefde0j1fdFdGZ2           dd-eed.eee&eeeffdeeeefd/eeeefd0eeeefd1eed2eed5eeded8ee'd9eeeeffdHdIZ3           dd-eed.eee&eeeffdeeeefd/eeeefd0eeeefd1eed2eed5eeded8ee'd9eeeefde*fdJdKZ4                dd-eed.eee&eeeffdeeeefd/eeeefd0eeeefd1eed2eed5eedLeed6eed7eeeeeeffdeeded8ee'dMeed9eeeeff dNdOZ5                dd-eed.eee&eeeffdeeeefd/eeeefd0eeeefd1eed2eed5eedLeed6eed7eeeeeeffdeeded8ee'dMeed9eeeefde*f"dPdQZ6                    dd-eeee.fd.eee&eeeffdeeeefd/eeeefd0eeeeeeeefffd1eed2eed3eed4eed5eedeed6eeeefd7eeeeeeffdeedLeedRedSed8ee'dMeed9eeeefdef*dTdUZ7     dd-ed.eee&eeeffdeeeefdVeed8ee'd9eeeeff dWdXZ8     dd-ed.eee&eeeffdeeeefdVeed8ee'd9eeeefde*fdYdZZ9      [dd-ed.eee&eeeffdeeeefdVeed8ee'd9eeeefd\eded]fd^d_Z:      [dd-ed.eee&eeeffdeeeefdVeed8ee'd9eeeefd\ede*fd`daZ;deeeefdVeedeeeffdbdcZe!defdhdiZ?   j       ddkeedee&e&edleee@efdeedme&eAdne&ed3edeeeefdeBd9eeeefde=fdodpZC         ddkedeedeedlee&edme&eAdne&edeBd9eeeefde=fdqdrZD   ddkededeed9eeeefde=f dsdtZE   ddkedued]deedeed9eeeefde=f dvdwZF        ddkedleeee&efdeedme&eAdne&ed3edeeeefdeee&e&ed9eeeefdeBfdxdyZGdzedefd{d|ZHd}eddfd~dZIe!deBde=fddZJe!      ddkedlee&edeee.eKe.ddfeLfdeedBeedeed9eeeefde=fddZMe!ddZNe!ddZOdePfddZQddZRddZSdS)Clientz( Base ClickHouse Connect client N compressionwrite_compressionrFTdatabase query_limituri query_retriesserver_host_nameapply_server_timezone utc_tz_awareshow_clickhouse_errorsc Cs\t||_t||_|r|dks||_|durt||_||_||_t||_ | |dS)a Shared initialization of ClickHouse Connect client :param database: database name :param query_limit: default LIMIT for queries :param uri: uri for error messages :param utc_tz_aware: Default timezone behavior when the active timezone resolves to UTC. If True, timezone-aware UTC datetimes are returned; otherwise legacy naive datetimes are used. __default__N) rr7r9r6rr=r:r8boolr<_init_common_settings) selfr6r7r8r9r:r;r<r=rBY/var/www/Datamplify/venv/lib/python3.10/site-packages/clickhouse_connect/driver/client.py__init__2s     zClient.__init__cCstjd|_}t|jddd\|_}z t|}t|\}}|dur&|}|dkp-t ||_ ||_Wnt yBt d|Ynw|j sStjsSt dtjdd}|d s_td}|d |d }d d |D|_|trtdr|jdddtid}|dddkrt|_|djr|dd|djr|djr|dd|dr|dsdt_ dSdSdS)NTzSELECT version(), timezone()F) use_databasealwayszJWarning, server is using an unrecognized timezone %s, will use UTC defaultzblocal timezone %s may return unexpected times due to Daylight Savings Time/Summer Time differencesreadonlyz19.17zSELECT name, value, z- as readonly FROM system.settings LIMIT 10000cSs i|] }|dtdi|qS)namerB)r*.0rowrBrBrC c z0Client._init_common_settings..use_protocol_versionzSELECT 1 AS checkNativeclient_protocol_version)fmtsettingsscheckdate_time_input_format best_effortallow_experimental_json_type$cast_string_to_dynamic_use_inference1z24.8z24.10r)!pytzUTC server_tztuplecommandserver_versiontimezonernormalize_timezonerr;r loggerwarninglocal_tz_dst_safelocal_tztzname min_versionr get_settingquery named_resultsserver_settingsr raw_queryrprotocol_version_setting_status is_writableset_client_settingis_setdynamic_modulejson_serialization_format)rAr;dst_safer\rGrk test_datarBrBrCr@NsJ             zClient._init_common_settingsrRreturncCsBi}td}|D]\}}||||}|dur|||<q |S)z This strips any ClickHouse settings that are not recognized or are read only. :param settings: Dictionary of setting name and values :return: A filtered dictionary of settings with values rendered as strings invalid_setting_actionN)rrhitems_validate_setting)rArR validatedinvalid_actionkeyvalue str_valuerBrBrC_validate_settingsus zClient._validate_settingsr|r}r{cCst|}|dur d}n|durd}||jvrb|j|}||}|r3|j|kr3|dus1||jkr3dS|dus:|jrb||jvrAdS|dkrMt d||S|dkrYt d|dSt d |d d|S) NTrYF0sendz6Attempting to send unrecognized or readonly setting %sdropz-Dropping unrecognized or readonly settings %szSetting z is unknown or readonly) strvalid_transport_settingsrkgetget_client_settingr}rGoptional_transport_settingsrbrcr)rAr|r}r{r~ setting_defcurrent_settingrBrBrCrys*       zClient._validate_settingcCs0|j|}|s tddSt|jdk|jdkS)NFr)rkrr+r}rG)rAr| comp_settingrBrBrCrns  zClient._setting_statuscontextcCsH|jr!|js!|jr!d|j}t|jtr|j|S|j|S|jS)Nz LIMIT ) is_select has_limitr7 isinstanceribytes final_queryencode)rArlimitrBrBrC _prep_querys    zClient._prep_querycCsJ|r#zt|}||jkr|WSWdSty"td|YdSwdS)Nz1Unrecognized timezone %s received from ClickHouse)rZr`r\r rbrc)rAnew_tz new_tzinforBrBrC_check_tz_changes   zClient._check_tz_changecCsdSNrBrArrBrBrC_query_with_contextzClient._query_with_contextcCdS)a Set a clickhouse setting for the client after initialization. If a setting is not recognized by ClickHouse, or the setting is identified as "read_only", this call will either throw a Programming exception or attempt to send the setting anyway based on the common setting 'invalid_setting_action' :param key: ClickHouse setting name :param value: ClickHouse setting value NrB)rAr|r}rBrBrCrpzClient.set_client_settingcCr)zu :param key: The setting key :return: The string value of the setting, if it exists, or None NrB)rAr|rBrBrCrrzClient.get_client_setting access_tokencCr)zq Set the ClickHouse access token for the client :param access_token: Access token string NrB)rArrBrBrCset_access_tokenrzClient.set_access_tokenri parameters query_formatscolumn_formatsencodinguse_nonecolumn_oriented use_numpy max_str_lenquery_tz column_tzs external_datatransport_settingscCs|r|drtdtdggddtdfSt}|d=|jd i|}|j rU|j ||j |j |j |jd}t|trF|Stt|trP|gS|ggS||S) z Main query method for SELECT, DESCRIBE and other SQL statements that return a result matrix. For parameters, see the create_query_context method :return: QueryResult -- data and metadata from response zselect __connect_version__zClickHouse Connect v.u ⓒ ClickHouse Inc.N)connect_versionStringrA)rrRrrrB)lowerstrip startswithr,rrlocalscopycreate_query_context is_commandr^rrRrrrr(as_query_resultlistr)rArirrRrrrrrrrrrrr<rrkwargs query_contextresponserBrBrCris$    z Client.querycC|jtdddjS)z Variation of main query method that returns a stream of column oriented blocks. For parameters, see the create_query_context method. :return: StreamContext -- Iterable stream context that returns column oriented blocks FTr streaming)_context_queryrcolumn_block_streamrArirrRrrrrrrrr<rrrBrBrCquery_column_block_streamz Client.query_column_block_streamcCrz Variation of main query method that returns a stream of row oriented blocks. For parameters, see the create_query_context method. :return: StreamContext -- Iterable stream context that returns blocks of rows FTr)rrrow_block_streamrrBrBrCquery_row_block_stream rzClient.query_row_block_streamcCrr)rr rows_streamrrBrBrCquery_rows_stream rzClient.query_rows_streamrQrEcCr)a Query method that simply returns the raw ClickHouse format bytes :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param fmt: ClickHouse output format :param use_database: Send the database parameter to ClickHouse so the command will be executed in the client database context. :param external_data: External data to send with the query :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: bytes representing raw ClickHouse return value based on format NrBrArirrRrQrErrrBrBrCrl5rzClient.raw_querycCr)a Query method that returns the result as an io.IOBase iterator :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param fmt: ClickHouse output format :param use_database Send the database parameter to ClickHouse so the command will be executed in the client database context. :param external_data: External data to send with the query. :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: io.IOBase stream/iterator for the result NrBrrBrBrC raw_streamJrzClient.raw_streamc Cs"t|d|jtddjS)z Query method that returns the results as a numpy array. For parameter values, see the create_query_context method :return: Numpy array representing the result set numpyT)r)r"_add_integration_tagrr np_result rArirrRrrrrrrrrrBrBrCquery_np`s zClient.query_npc C$t|d|jtdddjS)z Query method that returns the results as a stream of numpy arrays. For parameter values, see the create_query_context method :return: Generator that yield a numpy array per block representing the result set rTr)r"rrr np_streamrrBrBrCquery_np_streamvs zClient.query_np_stream use_na_valuesuse_extended_dtypescCr)z Query method that results the results as a pandas dataframe. For parameter values, see the create_query_context method :return: Pandas dataframe representing the result set pandasT)r as_pandas)r!rrr df_resultrArirrRrrrrrrrrr<rrrrrBrBrCquery_dfs zClient.query_dfcCs&t|d|jtddddjS)z Query method that returns the results as a StreamContext. For parameter values, see the create_query_context method :return: Generator that yields a Pandas dataframe per block representing the result set rT)rrr)r!rrr df_streamrrBrBrCquery_df_streams  zClient.query_df_streamrrcCsH|dur|jn|}| rK| jdid|d|d|d|d|d|d|jd |d |d | d | d | d| d|d|d|d|d|d|S| rS| durSd} |durY|}|ra|durad}tdid|d|d|d|d|d|d|jd |d |d | d | d | d| d|d|d|d|d|jd|d|S)a Creates or updates a reusable QueryContext object :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param query_formats: See QueryContext __init__ docstring :param column_formats: See QueryContext __init__ docstring :param encoding: See QueryContext __init__ docstring :param use_none: Use None for ClickHouse NULL instead of default values. Note that using None in Numpy arrays will force the numpy array dtype to 'object', which is often inefficient. This effect also will impact the performance of Pandas dataframes. :param column_oriented: Deprecated. Controls orientation of the QueryResult result_set property :param use_numpy: Return QueryResult columns as one-dimensional numpy arrays :param max_str_len: Limit returned ClickHouse String values to this length, which allows a Numpy structured array even with ClickHouse variable length String columns. If 0, Numpy arrays for String columns will always be object arrays :param context: An existing QueryContext to be updated with any provided parameter values :param query_tz: Either a string or a pytz tzinfo object. (Strings will be converted to tzinfo objects). Values for any DateTime or DateTime64 column in the query will be converted to Python datetime.datetime objects with the selected timezone. :param column_tzs: A dictionary of column names to tzinfo objects (or strings that will be converted to tzinfo objects). The timezone will be applied to datetime objects returned in the query :param utc_tz_aware: Override the client default for handling UTC results. True forces timezone-aware UTC datetimes while False returns naive UTC datetimes. :param use_na_values: Deprecated alias for use_advanced_dtypes :param as_pandas Return the result columns as pandas.Series objects :param streaming Marker used to correctly configure streaming queries :param external_data ClickHouse "external data" to send with query :param use_extended_dtypes: Only relevant to Pandas Dataframe queries. Use Pandas "missing types", such as pandas.NA and pandas.NaT for ClickHouse NULL values, as well as extended Pandas dtypes such as IntegerArray and StringArray. Defaulted to True for query_df methods :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: Reusable QueryContext NrirrRrrrr\rrrrrrr<rrrrrrTapply_server_tzrB)r< updated_copyr\r/r;)rArirrRrrrrrrrrrrr<rrrrrrresolved_utc_tz_awarerBrBrCrs7            zClient.create_query_context use_stringsc C6t|d|||}t|j|||d||dS)ae Query method using the ClickHouse Arrow format to return a PyArrow table :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param use_strings: Convert ClickHouse String type to Arrow string type (instead of binary) :param external_data: ClickHouse "external data" to send with query :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: PyArrow.Table r%ArrowrQrr)r r_update_arrow_settingsr-rlrArirrRrrrrBrBrC query_arrow*  zClient.query_arrowc Cr)a Query method that returns the results as a stream of Arrow tables :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param use_strings: Convert ClickHouse String type to Arrow string type (instead of binary) :param external_data: ClickHouse "external data" to send with query :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: Generator that yields a PyArrow.Table for per block representing the result set r% ArrowStreamr)r rrr.rrrBrBrCquery_arrow_streamErzClient.query_arrow_streamrdataframe_library) pd.DataFramez pl.DataFramec Cst|dkr!t|dtstddtjdtjfdd}n |dkr9t |ddtjdt jfdd}nt d |d |j ||||||d } || S) a Query method using the ClickHouse Arrow format to return a DataFrame with PyArrow dtype backend. This provides better performance and memory efficiency compared to the standard query_df method, though fewer output formatting options. :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param use_strings: Convert ClickHouse String type to Arrow string type (instead of binary) :param external_data: ClickHouse "external data" to send with query :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :param dataframe_library: Library to use for DataFrame creation ("pandas" or "polars") :return: DataFrame (pandas or polars based on dataframe_library parameter) r?PyArrow-backed dtypes are only supported when using pandas 2.x.tablervcS|jtjddSNF) types_mappersafe to_pandasr$ ArrowDtyperrBrBrC converterz(Client.query_df_arrow..converterpolarscS t|Srr& from_arrowrrBrBrCr 5dataframe_library must be 'pandas' or 'polars', got '')rirrRrrr) r r!rr'rr%Tabler$ DataFramer#r& ValueErrorr) rArirrRrrrrr arrow_tablerBrBrCquery_df_arrow`s*   zClient.query_df_arrowc st|dkrt|dtstddddn |d kr3t|d dtjdtj fd dnt d |d | ||}|j |||d ||d}tj |fdd} t|| S)ao Query method that returns the results as a stream of DataFrames with PyArrow dtype backend. Each DataFrame represents a block from the ClickHouse response. :param query: Query statement/format string :param parameters: Optional dictionary used to format the query :param settings: Optional dictionary of ClickHouse settings (key/string values) :param use_strings: Convert ClickHouse String type to Arrow string type (instead of binary) :param external_data: ClickHouse "external data" to send with query :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :param dataframe_library: Library to use for DataFrame creation ("pandas" or "polars") :return: StreamContext that yields DataFrames (pandas or polars based on dataframe_library parameter) rrr arrow.TablervrcSrrrrrBrBrCrrz/Client.query_df_arrow_stream..converterrcSrrrrrBrBrCrrrrrrc3sD]}|VqdSrrB)batchrreaderrBrC df_generators z2Client.query_df_arrow_stream..df_generatorN)rrrvr)r r!rr'rr#r%rr&rrrripc open_streamr) rArirrRrrrrrrrBrrCquery_df_arrow_streams&       zClient.query_df_arrow_streamcCszt|}|jr |j|d<|t}|dur!|jr|jsd|t<|S||jkr;|js3tdtd||r7dnd|t<|S)Nr6rYzCannot change readonly z to r)rr6rnarrow_str_settingrorqr)rArRr str_statusrBrBrCrs    zClient._update_arrow_settingscmddatacCr)a Client method that returns a single value instead of a result set :param cmd: ClickHouse query/command as a python format string :param parameters: Optional dictionary of key/values pairs to be formatted :param data: Optional 'data' for the command (for INSERT INTO in particular) :param settings: Optional dictionary of ClickHouse settings (key/string values) :param use_database: Send the database parameter to ClickHouse so the command will be executed in the client database context. Otherwise, no database will be specified with the command. This is useful for determining the default user database :param external_data: ClickHouse "external data" to send with command/query :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: Decoded response from ClickHouse as either a string, int, or sequence of strings, or QuerySummary if no data returned NrB)rAr rr rRrErrrBrBrCr^rzClient.commandcCr)z Validate the connection, does not throw an Exception (see debug logs) :return: ClickHouse server is up and reachable NrBrArBrBrCpingrz Client.ping*r column_names column_typescolumn_type_namesc Csj| dus| jr|durtdd| dur!|j|||||||| d} |dur0| js-tdd|| _|| S)a Method to insert multiple rows/data matrix of native Python objects. If context is specified arguments other than data are ignored :param table: Target table :param data: Sequence of sequences of Python data :param column_names: Ordered list of column names or '*' if column types should be retrieved from the ClickHouse table definition :param database: Target database -- will use client default database if not specified. :param column_types: ClickHouse column types. If set then column data does not need to be retrieved from the server :param column_type_names: ClickHouse column type names. If set then column data does not need to be retrieved from the server :param column_oriented: If true the data is already "pivoted" in column form :param settings: Optional dictionary of ClickHouse settings (key/string values) :param context: Optional reusable insert context to allow repeated inserts into the same table with different data batches :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: QuerySummary with summary information, throws exception if insert fails NzNo data specified for insert)rz;Attempting to insert new data with non-empty insert context)emptyrcreate_insert_contextr  data_insert) rArr rr6rrrrRrrrBrBrCinserts"   z Client.insertc Cs`t|d|dur"|dur|j}nt|t|jkr"tdd|j|||||||| |d S)aX Insert a pandas DataFrame into ClickHouse. If context is specified arguments other than df are ignored :param table: ClickHouse table :param df: two-dimensional pandas dataframe :param database: Optional ClickHouse database :param settings: Optional dictionary of ClickHouse settings (key/string values) :param column_names: An optional list of ClickHouse column names. If not set, the DataFrame column names will be used :param column_types: ClickHouse column types. If set then column data does not need to be retrieved from the server :param column_type_names: ClickHouse column type names. If set then column data does not need to be retrieved from the server :param context: Optional reusable insert context to allow repeated inserts into the same table with different data batches :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: QuerySummary with summary information, throws exception if insert fails rNz4DataFrame column count does not match insert_columns)rrrRrr)r!rcolumnslenrr) rArdfr6rRrrrrrrBrBrC insert_df's"  zClient.insert_dfc Csdt|dd|vs|s|n|d|}|jdvr|jnd}t||\}} |||| |d|S)a Insert a PyArrow table DataFrame into ClickHouse using raw Arrow format :param table: ClickHouse table :param arrow_table: PyArrow Table object :param database: Optional ClickHouse database :param settings: Optional dictionary of ClickHouse settings (key/string values) :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) r%.)zstdlz4Nr)r rr5r0 raw_insert) rArrr6rRr full_tabler4r insert_blockrBrBrC insert_arrowRs  zClient.insert_arrowrc Cs:ttdurt|tjrd}n#tdurt|tjrd}ntdur)tdur)tdtdt|j|dkrst s=t ddd|j D}|rTt d d |d z tjj|d d }Wn/tyr} ztd| | d} ~ wwz|}Wnty} ztd| | d} ~ ww|||j|||||dS)a Insert a pandas DataFrame with PyArrow backend or a polars DataFrame into ClickHouse using Arrow format. This method is optimized for DataFrames that already use Arrow format, providing better performance than the standard insert_df method. Validation is performed and an exception will be raised if this requirement is not met. Polars DataFrames are natively Arrow-based and don't require additional validation. :param table: ClickHouse table name :param df: Pandas DataFrame with PyArrow dtype backend or Polars DataFrame :param database: Optional ClickHouse database name :param settings: Optional dictionary of ClickHouse settings (key/string values) :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: QuerySummary with summary information, throws exception if insert fails NrrzPA DataFrame library (pandas or polars) must be installed to use insert_df_arrow.z>df must be either a pandas DataFrame or polars DataFrame, got rcSs g|] \}}t|tjs|qSrB)rr$r)rJcoldtyperBrBrC rMz*Client.insert_df_arrow..zVinsert_df_arrow requires all columns to use PyArrow dtypes. Non-Arrow columns found: [z, z]. F)preserve_indexz3Failed to convert pandas DataFrame to Arrow table: z3Failed to convert polars DataFrame to Arrow table: )rrr6rRr)r r$rrr& ImportError TypeErrortype__name__r'rdtypesrxjoinr%r from_pandas Exceptionrr-rr!) rArrr6rRrdf_libnon_arrow_colsrerBrBrCinsert_df_arrowfsH  zClient.insert_df_arrowc  sb|} d|vr|rt|dt|} nt|} g} |dur5|dur5|jd| |d} dd| D} |dusBt|trQ|dkrQdd| D}d d| D}nt|trY|g}t|d krctd |s|rod d|D}n*d d| Dz fdd|D}Wnty} z td| d|dd} ~ wwt|t|krtddt | ||||| |dS)a Builds a reusable insert context to hold state for a duration of an insert :param table: Target table :param database: Target database. If not set, uses the client default database :param column_names: Optional ordered list of column names. If not set, all columns ('*') will be assumed in the order specified by the table definition :param database: Target database -- will use client default database if not specified :param column_types: ClickHouse column types. Optional Sequence of ClickHouseType objects. If neither column types nor column type names are set, actual column types will be retrieved from the server. :param column_type_names: ClickHouse column type names. Specified column types by name string :param column_oriented: If true the data is already "pivoted" in column form :param settings: Optional dictionary of ClickHouse settings (key/string values) :param data: Initial dataset for insert :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) :return: Reusable insert context rNzDESCRIBE TABLE )rRcSs&g|]}|ddvrtdi|qS) default_type)ALIAS MATERIALIZEDrB)r)rIrBrBrCr$s  z0Client.create_insert_context..rcSg|]}|jqSrBrHrJcdrBrBrCr$cSr5rBch_typer7rBrBrCr$r9rz)Column names must be specified for insertcSg|]}t|qSrBrrJrHrBrBrCr$cSsi|]}|j|qSrBr6)rJdrBrBrCrLr>z0Client.create_insert_context..csg|]}|jqSrBr:r= column_maprBrCr$szUnrecognized column z in table z&Column names do not match column types)rrRrr ) r1rirjrrrrKeyErrorrr)rArrr6rrrrRr rr column_defsdescribe_resultexrBr@rCrsH   zClient.create_insert_context version_strcCsz/dd|jdD}|dgdt|dd|dD}|dgdt|WntyAtd|j|YdSwt||D]\}}||krRd S||krYdSqGd S) a Determine whether the connected server is at least the submitted version For Altinity Stable versions like 22.8.15.25.altinitystable the last condition in the first list comprehension expression is added :param version_str: A version string consisting of up to 4 integers delimited by dots :return: True if version_str is greater than the server_version, False if less than cSsg|] }|rt|qSrB) isnumericintrJxrBrBrCr$sz&Client.min_version..rrcSr<rB)rHrIrBrBrCr$r>zTServer %s or requested version %s does not match format of numbers separated by dotsFT)r_splitextendrrrbrczip)rArF server_parts version_partsrJyrBrBrCrgs$ zClient.min_versionrHcCr)zJTransport hook to surface 3rd party lib integration info (default: no-op).NrB)rArHrBrBrCrrzClient._add_integration_tagcCr)z Subclass implementation of the data insert :context: InsertContext parameter object :return: No return, throws an exception if the insert fails NrBrrBrBrCrrzClient.data_insertr cCr)ar Insert data already formatted in a bytes object :param table: Table name (whether qualified with the database name or not) :param column_names: Sequence of column names :param insert_block: Binary or string data already in a recognized ClickHouse format :param settings: Optional dictionary of ClickHouse settings (key/string values) :param fmt: Valid clickhouse format :param compression: Recognized ClickHouse `Accept-Encoding` header compression value :param transport_settings: Optional dictionary of transport level settings (HTTP headers, etc.) NrB)rArrr rRrQr4rrBrBrCrrzClient.raw_insertcCr)ze Subclass implementation to close the connection to the server/deallocate the client NrBr rBrBrCcloserz Client.closecCr)zX Subclass implementation to disconnect all "re-used" client connections NrBr rBrBrCclose_connectionsrzClient.close_connectionslclscKs2|}|d||||jdi|S)NrArB)rpopupdaterr)rArT overridesrrBrBrCr%s  zClient._context_querycCs|SrrBr rBrBrC __enter__+szClient.__enter__cCs |dSr)rR)rAexc_type exc_value exc_tracebackrBrBrC__exit__.s zClient.__exit__)NNNNNNNNNNNNNNNN) NNNNNNNNNNNNN)NNNTNN) NNNNNNNNNNN)NNNNNNNNFrNNNNNFFNNN)NNNNN)NNNNNr) NNrNNNFNNN) NNNNNNNNN)NNN)NNNNFNNN)NNNNNN)Tr) __module__ __qualname____doc__r4r__annotations__r5rmsetrrr6max_error_messager;r<r=rHrrr?rDr@r rrryr+rnr/rrrrrrprrr rr,rirrrrrrlioIOBaserrrrrrrrrrrr(r^rrrrrrr!r1rrgrrr r rrRrSdictrrXr\rBrBrBrCr3#s    &'         (                                             i   9 2         /  -  >  ?     r3)MrcloggingdatetimerrZabcrrtypingrrrrr r r r pytz.exceptionsr clickhouse_connectrclickhouse_connect.commonr%clickhouse_connect.datatypes.registryr!clickhouse_connect.datatypes.baserclickhouse_connect.datatypesrrrclickhouse_connect.driverr clickhouse_connect.driver.commonrrrr#clickhouse_connect.driver.constantsrr$clickhouse_connect.driver.exceptionsrrr"clickhouse_connect.driver.externalr clickhouse_connect.driver.insertr!clickhouse_connect.driver.optionsr r!r"r#r$r%r&r'!clickhouse_connect.driver.summaryr( clickhouse_connect.driver.modelsr)r*r+clickhouse_connect.driver.queryr,r-r.r/r0!clickhouse_connect.driver.bindingr1DEFAULT_BUFFER_SIZE getLoggerr)rbr r3rBrBrBrCs6 (         (