o NDi@sdZddlmZddlmZmZmZddlZddlZddlZddl Z ddl m Z m Z ddl mZddlmZddlZ ddlmZdd lmZdd l mZmZddlZeeZeZ ed Zed Zed ZiZ ddZ!ddZ"Gddde#Z$ddZ%ddZ&ddZ'ddZ(e#Z)Gddde#Z*Gddde*Z+Gd d!d!e#Z,Gd"d#d#e*Z-Gd$d%d%e#Z.e.d&de._/e.d'd(e._0e.d)d*e._1Gd+d,d,e*Z2e j3j4Z4 d-d.Z5Gd/d0d0e6Z7Gd1d2d2e#Z8Gd3d4d4e#Z9Gd5d6d6e#Z:dS)7z This module holds classes for working with prepared statements and specifying consistency levels and retry policies for individual queries. ) namedtuple)datetime timedeltatimezoneN)ConsistencyLevelOperationTimedOut)unix_time_from_uuid1)Encoder)ColDesc) _UNSET_VALUE) OrderedDict_sanitize_identifiersz [^a-zA-Z0-9]z^[^a-zA-Z0-9]*z[^a-zA-Z0-9_]*$c CsFzt|WSty"tdtdtd|}|t|<|YSw)N_)_clean_name_cacheKeyErrorNON_ALPHA_REGEXsubSTART_BADCHAR_REGEXEND_BADCHAR_REGEX)namecleanrH/var/www/Datamplify/venv/lib/python3.10/site-packages/cassandra/query.py_clean_column_name;s  rcCs|S)a Returns each row as a tuple Example:: >>> from cassandra.query import tuple_factory >>> session = cluster.connect('mykeyspace') >>> session.row_factory = tuple_factory >>> rows = session.execute("SELECT name, age FROM users LIMIT 1") >>> print(rows[0]) ('Bob', 42) .. versionchanged:: 2.0.0 moved from ``cassandra.decoder`` to ``cassandra.query`` rcolnamesrowsrrr tuple_factoryDsrc@s8eZdZdZddZddZddZdd Zd d Zd S) PseudoNamedTupleRowz Helper class for pseudo_named_tuple_factory. These objects provide an __iter__ interface, as well as index- and attribute-based access to values, but otherwise do not attempt to implement the full namedtuple or iterable interface. cCs||_t||_dSN)_dicttuplevalues_tuple)self ordered_dictrrr__init__]szPseudoNamedTupleRow.__init__cC |j|Sr )r!)r%rrrr __getattr__a zPseudoNamedTupleRow.__getattr__cCr(r )r$)r%idxrrr __getitem__dr*zPseudoNamedTupleRow.__getitem__cC t|jSr )iterr$r%rrr__iter__gr*zPseudoNamedTupleRow.__iter__cCsdj|jj|jdS)Nz {t}({od}))tod)format __class____name__r!r/rrr__repr__js zPseudoNamedTupleRow.__repr__N) r5 __module__ __qualname____doc__r'r)r,r0r6rrrrrVs rcCsddt||DS)z Returns each row as a :class:`.PseudoNamedTupleRow`. This is the fallback factory for cases where :meth:`.named_tuple_factory` fails to create rows. cSsg|]}t|qSr)r).0r2rrr ts z-pseudo_namedtuple_factory..)ordered_dict_factoryrrrrpseudo_namedtuple_factoryosr=c stt|}ztd|Wn8ty%tdjtj|dt||YSt yDt tt|}t d||ftdt |Ynwfdd|DS)a Returns each row as a `namedtuple `_. This is the default row factory. Example:: >>> from cassandra.query import named_tuple_factory >>> session = cluster.connect('mykeyspace') >>> session.row_factory = named_tuple_factory >>> rows = session.execute("SELECT name, age FROM users LIMIT 1") >>> user = rows[0] >>> # you can access field by their name: >>> print("name: %s, age: %d" % (user.name, user.age)) name: Bob, age: 42 >>> # or you can access fields by their position (like a tuple) >>> name, age = user >>> print("name: %s, age: %d" % (name, age)) name: Bob, age: 42 >>> name = user[0] >>> age = user[1] >>> print("name: %s, age: %d" % (name, age)) name: Bob, age: 42 .. versionchanged:: 2.0.0 moved from ``cassandra.decoder`` to ``cassandra.query`` RowaFailed creating namedtuple for a result because there were too many columns. This is due to a Python limitation that affects namedtuple in Python 3.0-3.6 (see issue18896). The row will be created with {substitute_factory_name}, which lacks some namedtuple features and is slower. To avoid slower performance accessing values on row objects, Upgrade to Python 3.7, or use a different row factory. (column names: {colnames}))substitute_factory_nameraAFailed creating named tuple for results with column names %s (cleaned: %s) (see Python 'namedtuple' documentation for details on name rules). Results will be returned with positional names. Avoid this by choosing different names, using SELECT "" AS aliases, or specifying a different row_factory on your Sessioncsg|]}|qSrrr:rowr>rrr;sz'named_tuple_factory..)maprr SyntaxErrorwarningswarnr3r=r5 Exceptionlistlogwarningr )rrclean_column_namesrrBrnamed_tuple_factoryxs(    rLcfdd|DS)a Returns each row as a dict. Example:: >>> from cassandra.query import dict_factory >>> session = cluster.connect('mykeyspace') >>> session.row_factory = dict_factory >>> rows = session.execute("SELECT name, age FROM users LIMIT 1") >>> print(rows[0]) {u'age': 42, u'name': u'Bob'} .. versionchanged:: 2.0.0 moved from ``cassandra.decoder`` to ``cassandra.query`` cg|] }tt|qSr)dictzipr@rrrr;z dict_factory..rrrrQr dict_factorysrScrM)z Like :meth:`~cassandra.query.dict_factory`, but returns each row as an OrderedDict, so the order of the columns is preserved. .. versionchanged:: 2.0.0 moved from ``cassandra.decoder`` to ``cassandra.query`` crNr)r rPr@rQrrr;rRz(ordered_dict_factory..rrrrQrr<sr<c@seZdZdZdZ dZ eZ dZ dZ dZ dZ dZ ddddedddfddZ ddZdd Zd d Zd d ZeeeedZddZddZddZeeeedZdS) Statementz An abstract class representing a single query. There are three subclasses: :class:`.SimpleStatement`, :class:`.BoundStatement`, and :class:`.BatchStatement`. These can be passed to :meth:`.Session.execute()`. NFc Csz|r t|ds td|dur||_|dur||_||_|dur#||_|tur*||_|dur1||_|dur8||_ ||_ dS)Non_read_timeoutzH%dsBr)lenstructpack)r%partsplrrr_key_parts_packed$s zStatement._key_parts_packedcC|jSr rZr/rrr_get_routing_key)zStatement._get_routing_keycCsHt|ttfrt|dkr|d|_dSd|||_dS||_dS)Nr) isinstancerHr"rbrZjoinrh)r%keyrrr_set_routing_key,s   zStatement._set_routing_keycC d|_dSr rjr/rrr_del_routing_key5r*zStatement._del_routing_keyah The :attr:`~.TableMetadata.partition_key` portion of the primary key, which can be used to determine which nodes are replicas for the query. If the partition key is a composite, a list or tuple must be passed in. Each key component should be in its packed (binary) format, so all components should be strings. cCrir _serial_consistency_levelr/rrr_get_serial_consistency_levelErlz'Statement._get_serial_consistency_levelcCs$|dur t|s td||_dS)Nz`serial_consistency_level must be either ConsistencyLevel.SERIAL or ConsistencyLevel.LOCAL_SERIAL)r is_serialrWrv)r%r[rrr_set_serial_consistency_levelHs z'Statement._set_serial_consistency_levelcCrsr rur/rrr_del_serial_consistency_levelPr*z'Statement._del_serial_consistency_levela The serial consistency level is only used by conditional updates (``INSERT``, ``UPDATE`` and ``DELETE`` with an ``IF`` condition). For those, the ``serial_consistency_level`` defines the consistency level of the serial phase (or "paxos" phase) while the normal :attr:`~.consistency_level` defines the consistency for the "learn" phase, i.e. what type of reads will be guaranteed to see the update right away. For example, if a conditional write has a :attr:`~.consistency_level` of :attr:`~.ConsistencyLevel.QUORUM` (and is successful), then a :attr:`~.ConsistencyLevel.QUORUM` read is guaranteed to see that write. But if the regular :attr:`~.consistency_level` of that write is :attr:`~.ConsistencyLevel.ANY`, then only a read with a :attr:`~.consistency_level` of :attr:`~.ConsistencyLevel.SERIAL` is guaranteed to see it (even a read with consistency :attr:`~.ConsistencyLevel.ALL` is not guaranteed to be enough). The serial consistency can only be one of :attr:`~.ConsistencyLevel.SERIAL` or :attr:`~.ConsistencyLevel.LOCAL_SERIAL`. While ``SERIAL`` guarantees full linearizability (with other ``SERIAL`` updates), ``LOCAL_SERIAL`` only guarantees it in the local data center. The serial consistency level is ignored for any query that is not a conditional update. Serial reads should use the regular :attr:`consistency_level`. Serial consistency levels may only be used against Cassandra 2.0+ and the :attr:`~.Cluster.protocol_version` must be set to 2 or higher. See :doc:`/lwt` for a discussion on how to work with results returned from conditional statements. .. versionadded:: 2.0.0 )r5r7r8r9rXrYr\r]r^r_r`rvrZr'rhrkrrrtpropertyrarwryrzr[rrrrrTsN     rTc@sBeZdZdZddddedddfddZeddZdd ZeZ dS) SimpleStatementz& A simple, un-prepared query. NFc Cs$t||||||||| ||_dS)a* `query_string` should be a literal CQL statement with the exception of parameter placeholders that will be filled through the `parameters` argument of :meth:`.Session.execute()`. See :class:`Statement` attributes for a description of the other parameters. N)rTr' _query_string) r% query_stringrXrYrar[r]r^r_r`rrrr's  zSimpleStatement.__init__cCrir )r}r/rrrr~szSimpleStatement.query_stringcCtj|jd}d|j|fS)NNot Setz,r value_to_namegetrYr~r% consistencyrrr__str__zSimpleStatement.__str__) r5r7r8r9r\r'r{r~rr6rrrrr|zs  r|c@seZdZdZdZdZdZdZeZ dZ dZ dZ dZ dZdZdZdZdZdZ d ddZe d ddZddZd d Zd d ZeZdS)PreparedStatementa A statement that has been prepared against at least one Cassandra node. Instances of this class should not be created directly, but through :meth:`.Session.prepare()`. A :class:`.PreparedStatement` should be prepared only once. Re-preparing a statement may affect performance (as the operation requires a network roundtrip). |prepared_stmt_head|: Do not use ``*`` in prepared statements if you might change the schema of the table being queried. The driver and server each maintain a map between metadata for a schema and statements that were prepared against that schema. When a user changes a schema, e.g. by adding or removing a column, the server invalidates its mappings involving that schema. However, there is currently no way to propagate that invalidation to drivers. Thus, after a schema change, the driver will incorrectly interpret the results of ``SELECT *`` queries prepared before the schema change. This is currently being addressed in `CASSANDRA-10786 `_. .. |prepared_stmt_head| raw:: html A note about * in prepared statements Nc Cs@||_||_||_||_||_||_||_||_| |_d|_ dS)NF) column_metadataquery_idrouting_key_indexesr~r^protocol_versionresult_metadataresult_metadata_idcolumn_encryption_policyr`) r%rrrqueryr^rrrrrrrr's zPreparedStatement.__init__c  s|st||d||||| | S|r|} n;d} |d} |j| j} | rN| j| j}|rN|j}tddt|Dz fdd|D} Wn t yMYnwt||| ||||| | S)Nrcss|] \}}|j|fVqdSr r)r:icrrr sz1PreparedStatement.from_message..csg|]}|jqSrr)r:rstatement_indexesrrr;sz2PreparedStatement.from_message..) r keyspacesr keyspace_nametables table_name partition_keyrO enumerater)clsrr pk_indexescluster_metadatarprepared_keyspacerrrrr first_colks_meta table_metapartition_key_columnsrrr from_messages4  zPreparedStatement.from_messagecCst||S)z Creates and returns a :class:`BoundStatement` instance using `values`. See :meth:`BoundStatement.bind` for rules on input ``values``. )BoundStatementbind)r%r#rrrrszPreparedStatement.bindcCs,|jdur|jr t|jnt|_||jvSr )_routing_key_index_setrset)r%rrrris_routing_key_indexs  z&PreparedStatement.is_routing_key_indexcCr)Nrz.rrrrrrrzPreparedStatement.__str__r )r5r7r8r9rrXrYr_r\r]r^rrr~rrrrrr[r' classmethodrrrrr6rrrrrs4  "rc@s\eZdZdZdZ dZ ddddeddfddZddZddZ e d d Z d d Z e Z dS) rz A prepared statement that has been bound to a particular set of values. These may be created directly or through :meth:`.PreparedStatement.bind()`. Nc Csr||_|j|_|j|_|j|_|j|_|j|_|j|_g|_|j} | r)| dj |_ t |||||||||j dS)z `prepared_statement` should be an instance of :class:`PreparedStatement`. See :class:`Statement` attributes for a description of the other parameters. rN) prepared_statementrXrYr[r]r_r`r#rrr^rTr') r%rrXrYrar[r]r^r_metarrrr's  zBoundStatement.__init__c Cs(|durd}|jj}|jj}|jj}t|trD|}g}|D]&}z |||jWqtyC|dkr:|t ntd|jYqwt |}t |}||kr\t dt |t |f|dkrx|jj rx|t |jj krxt d|t |jj f||_ g|_t||D]s\} } | dur|jdq| t ur|dkr|qt d|z0t| j| j| j} |o|| } | r|| n| j} | | |}| r|| |}|j|Wqttjfy}zt| }d| j| j||f}t|d}~ww|dkr|t |j}|rt|D]}|q |S) a Binds a sequence of values for the prepared statement parameters and returns this instance. Note that `values` *must* be: * a sequence, even if you are only binding one value, or * a dict that relates 1-to-1 between dict keys and columns .. versionchanged:: 2.6.0 :data:`~.UNSET_VALUE` was introduced. These can be bound as positional parameters in a sequence, or by name in a dict. Additionally, when using protocol v4+: * short sequences will be extended to match bind parameters with UNSET_VALUE * names may be omitted from a dict with UNSET_VALUE implied. .. versionchanged:: 3.0.0 method will not throw if extra keys are present in bound dict (PYTHON-178) Nrz)Column name `%s` not found in bound dict.z;Too many arguments provided to bind() (got %d, expected %d)zJToo few arguments provided to bind() (got %d, required %d for routing key)zLAttempt to bind UNSET_VALUE while using unsuitable protocol version (%d < 4)zQReceived an argument of invalid type for column "%s". Expected: %s, Got: %s; (%s))rrrrrorOappendrr UNSET_VALUErbrWr raw_valuesr#rP_append_unset_valuer rrcontains_column column_typetype serializeencrypt TypeErrorrcerrorrange)r%r# proto_versioncol_meta ce_policy values_dictcol value_len col_meta_lenvaluecol_speccol_descuses_cecol_type col_bytesexc actual_typemessagediffrrrrr0s          zBoundStatement.bindcCs@t|j}|j|r|jj|}td|j|jtdS)Nz9Cannot bind UNSET_VALUE as a part of the routing key '%s') rbr#rrrrWrrr)r% next_indexrrrrrs   z"BoundStatement._append_unset_valuecsljjsdSjdurjSjj}t|dkr#j|d_jSdfdd|D_jS)Nrmrrnc3s|]}j|VqdSr )r#)r:rr/rrrz-BoundStatement.routing_key..)rrrZrbr#rprh)r%routing_indexesrr/rras   zBoundStatement.routing_keycCs$tj|jd}d|jj|j|fS)Nrz6)rrrrYrr~rrrrrrzBoundStatement.__str__)r5r7r8r9rr#r\r'rrr{rarr6rrrrrs  \ rc@s:eZdZdZdZ dZ dZ ddZddZddZ dS) BatchTypez A BatchType is used with :class:`.BatchStatement` instances to control the atomicity of the batch operation. .. versionadded:: 2.0.0 NcC||_||_dSr )rr)r%rrrrrr' zBatchType.__init__cCrir rr/rrrrrlzBatchType.__str__cCs d|jfS)Nz BatchType.%srr/rrrr6s zBatchType.__repr__) r5r7r8r9LOGGEDUNLOGGEDCOUNTERr'rr6rrrrrs rrrrmrc@seZdZdZdZ dZ dZdZej dddddfddZ ddZ dddZ d d Z d d Zd dZddZddZddZddZeZdS)BatchStatementzx A protocol-level batch of operations which are applied atomically by default. .. versionadded:: 2.0.0 NcCs*||_g|_||_tj|||||ddS)aF `batch_type` specifies The :class:`.BatchType` for the batch operation. Defaults to :attr:`.BatchType.LOGGED`. `retry_policy` should be a :class:`~.RetryPolicy` instance for controlling retries on the operation. `consistency_level` should be a :class:`~.ConsistencyLevel` value to be used for all operations in the batch. `custom_payload` is a :ref:`custom_payload` passed to the server. Note: as Statement objects are added to the batch, this map is updated with any values found in their custom payloads. These are only allowed when using protocol version 4 or higher. Example usage: .. code-block:: python insert_user = session.prepare("INSERT INTO users (name, age) VALUES (?, ?)") batch = BatchStatement(consistency_level=ConsistencyLevel.QUORUM) for (name, age) in users_to_insert: batch.add(insert_user, (name, age)) session.execute(batch) You can also mix different types of operations within a batch: .. code-block:: python batch = BatchStatement() batch.add(SimpleStatement("INSERT INTO users (name, age) VALUES (%s, %s)"), (name, age)) batch.add(SimpleStatement("DELETE FROM pending_users WHERE name=%s"), (name,)) session.execute(batch) .. versionadded:: 2.0.0 .. versionchanged:: 2.1.0 Added `serial_consistency_level` as a parameter .. versionchanged:: 2.6.0 Added `custom_payload` as a parameter )rXrYr[r_N) batch_type_statements_and_parameters_sessionrTr')r%rrXrYr[sessionr_rrrr's /  zBatchStatement.__init__cCs0|jdd=d|_d|_|jr|jdSdS)z This is a convenience method to clear a batch statement for reuse. *Note:* it should not be used concurrently with uncompleted execution futures executing the same ``BatchStatement``. N)rr^rar_clearr/rrrrs zBatchStatement.clearcCs t|tr"|r|jdurtn|jj}t|||}|d|d|St|trD|j}| |dur2dn|}| ||d||j |St|t r`|rOt d| ||d|jj|j |S|j}|rw|jdurmtn|jj}t|||}| ||d|d|S)z Adds a :class:`.Statement` and optional sequence of parameters to be used with the statement to the batch. Like with other statements, parameters must be a sequence, even if there is only one item. NFrTzIParameters cannot be passed with a BoundStatement to BatchStatement.add())rostrrr encoder bind_params_add_statement_and_paramsrrr _update_stater#rrWrr~)r% statement parametersrrbound_statementr~rrradd*s6         zBatchStatement.addcCs$t||D] \}}|||qdS)a Adds a sequence of :class:`.Statement` objects and a matching sequence of parameters to the batch. Statement and parameter sequences must be of equal length or one will be truncated. :const:`None` can be used in the parameters position where are needed. N)rPr)r% statementsrrrrrradd_allMszBatchStatement.add_allcCs0t|jdkr tdd|j|||fdS)Niz7Batch statement cannot contain more than %d statements.)rbrrWr)r% is_preparedrrrrrrVs z(BatchStatement._add_statement_and_paramscCs6|jdur|jr|jr|j|_|j|_dSdSdSdSr )rar^r%rrrr_maybe_set_routing_attributes[s   z,BatchStatement._maybe_set_routing_attributescCs,|jr|jdur i|_|j|jdSdSr )r_updaterrrr_update_custom_payloadas  z%BatchStatement._update_custom_payloadcCs||||dSr )rrrrrrrgs zBatchStatement._update_statecCr-r )rbrr/rrr__len__kr*zBatchStatement.__len__cCs$tj|jd}d|jt||fS)Nrz7)rrrrYrrbrrrrrnrzBatchStatement.__str__r )r5r7r8r9rr[rrrrr'rrrrrrrrrr6rrrrrs, 5 # rcsBt|tr|tfdd|DS|tfdd|DS)Nc3s"|] \}}||fVqdSr cql_encode_all_types)r:kvrrrrs zbind_params..c3s|]}|VqdSr r)r:rrrrrr)rorOitemsr")rparamsrrrrrs rc@seZdZdZdS)TraceUnavailablezN Raised when complete trace details cannot be fetched from Cassandra. N)r5r7r8r9rrrrrsrc@sreZdZdZdZ dZ dZ dZ dZ dZ dZ dZ dZ dZ dZdZddZdd d Zd d ZddZdS) QueryTracez[ A trace of the duration and events that occurred when executing an operation. Nz:SELECT * FROM system_traces.sessions WHERE session_id = %sz8SELECT * FROM system_traces.events WHERE session_id = %sg~jth?cCrr )trace_idr)r%rrrrrr'rzQueryTrace.__init__@Tc Cs~d}t} t|}|dur||krtd|ftd|j|t|j|d|jf||}|r8|nd}|duoG|j duoG|j du} |rN|r]| s]t |j d||d7}q| rgtd |jntd |j|j |_| rzt|j d nd|_ |j |_ |j|_|j|_t|d d|_td |jt|}|t|j|d|jf||} td|jtdd| D|_dS)a Retrieves the actual tracing details from Cassandra and populates the attributes of this instance. Because tracing details are stored asynchronously by Cassandra, this may need to retry the session detail fetch. If the trace is still not available after `max_wait` seconds, :exc:`.TraceUnavailable` will be raised; if `max_wait` is :const:`None`, this will retry forever. `wait_for_complete=False` bypasses the wait for duration to be populated. This can be used to query events from partial sessions. `query_cl` specifies a consistency level to use for polling the trace tables, if it should be different than the session default. rTNz_Trace information was not available within %f seconds. Consider raising Session.max_trace_wait.z/Attempting to fetch trace info for trace ID: %s)rYrrmz#Fetched trace info for trace ID: %sz,Fetching parital trace info for trace ID: %s microsecondsclientz1Attempting to fetch trace events for trace ID: %sz%Fetched trace events for trace ID: %scss*|]}t|j|j|j|j|jVqdSr ) TraceEventactivityevent_idsourcesource_elapsedthread)r:rrrrrs"z&QueryTrace.populate..)timerrIdebugr_executer|_SELECT_SESSIONS_FORMAToneduration started_atsleep_BASE_RETRY_SLEEPrequest request_typer coordinatorrgetattrr_SELECT_EVENTS_FORMATr"events) r%max_waitwait_for_completequery_clattemptstart time_spentsession_results session_row is_complete event_resultsrrrpopulatesJ    zQueryTrace.populatecCs`|dur||nd}|jj||dd|d}t|_|z|WSty/td|fw)NF)tracer_timeoutz5Trace information was not available within %f seconds)r_create_response_futurerL row_factory send_requestresultrr)r%rrrrrfuturerrrr s  zQueryTrace._executecCs d|j|j|j|j|j|jfS)NzE%s [%s] coordinator: %s, started at: %s, duration: %s, parameters: %s)r rrr rrr/rrrrs zQueryTrace.__str__)rTN)r5r7r8r9rr rrrrr rrrrr r'rrrrrrrrs4 8 rc@s>eZdZdZdZ dZ dZ dZ dZ ddZ ddZ dS)rz@ Representation of a single event within a query trace. NcCsH||_tjt|tjd|_||_|durt|d|_nd|_||_ dS)N)tzr) descriptionr fromtimestamprrutcrrr thread_name)r%r%timeuuidrrr(rrrr'>s zTraceEvent.__init__cCsd|j|j|j|jfS)Nz%s on %s[%s] at %s)r%rr(rr/rrrrHszTraceEvent.__str__) r5r7r8r9r%rrrr(r'rrrrrrs rc@seZdZdZddZdS)HostTargetingStatementz Wraps any query statement and attaches a target host, making it usable in a targeted LBP without modifying the user's statement. cCs,t|jj|j|jfi|_|j|_||_dSr )rr4r5__dict__ target_host)r%inner_statementr,rrrr'Rs   zHostTargetingStatement.__init__N)r5r7r8r9r'rrrrr*Ms r*);r9 collectionsrrrrrercrrE cassandrarrcassandra.utilrcassandra.encoderr cassandra.policiesr cassandra.protocolr r r logging getLoggerr5rIrcompilerrrrrrobjectrr=rLrSr<r\rTr|rrrrrrrr ValueSequencerrGrrrr*rrrrsd          ; 'n% "  % /