o
    [hw'                     @   s   d dl mZ ddlmZ ddlmZ ddlmZ dZej	ej
 Zejdeddd	Zejd
eddd	Zejdeddd	Zejdeddd	Zejdeddd	Zejdeddd	Zejdeddd	ZG dd dejjZG dd dejZG dd deZdS )    )absolute_import   )types)util)	operators)JSONJSONBz->>T)
precedenceZnatural_self_precedentZeager_groupingz#>>?z?&z?|z@>z<@c                   @   s   e Zd Zdd Zdd ZdS )JSONPathTypec                       |  |  fdd}|S )Nc                    >   t | tjjs	J dd | D }dd| }  r | } | S )Nc                 S      g | ]}t |qS  r   	text_type.0elemr   r   /home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/sqlalchemy/dialects/postgresql/json.py
<listcomp>K       z@JSONPathType.bind_processor.<locals>.process.<locals>.<listcomp>{%s}, 
isinstancer   collections_abcSequencejoinvaluetokensZ
super_procr   r   processI      z,JSONPathType.bind_processor.<locals>.process)Zstring_bind_processorselfdialectr#   r   r"   r   bind_processorF      
zJSONPathType.bind_processorc                    r   )Nc                    r   )Nc                 S   r   r   r   r   r   r   r   r   X   r   zCJSONPathType.literal_processor.<locals>.process.<locals>.<listcomp>r   r   r   r   r"   r   r   r#   V   r$   z/JSONPathType.literal_processor.<locals>.process)Zstring_literal_processorr%   r   r"   r   literal_processorS   r)   zJSONPathType.literal_processorN)__name__
__module____qualname__r(   r*   r   r   r   r   r   E   s    r   c                       sB   e Zd ZdZe Zd fdd	ZG dd dejj	Z	e	Z
  ZS )	r   aB
  Represent the PostgreSQL JSON type.

    This type is a specialization of the Core-level :class:`_types.JSON`
    type.   Be sure to read the documentation for :class:`_types.JSON` for
    important tips regarding treatment of NULL values and ORM use.

    .. versionchanged:: 1.1 :class:`_postgresql.JSON` is now a PostgreSQL-
       specific specialization of the new :class:`_types.JSON` type.

    The operators provided by the PostgreSQL version of :class:`_types.JSON`
    include:

    * Index operations (the ``->`` operator)::

        data_table.c.data['some key']

        data_table.c.data[5]


    * Index operations returning text (the ``->>`` operator)::

        data_table.c.data['some key'].astext == 'some value'

      Note that equivalent functionality is available via the
      :attr:`.JSON.Comparator.as_string` accessor.

    * Index operations with CAST
      (equivalent to ``CAST(col ->> ['some key'] AS <type>)``)::

        data_table.c.data['some key'].astext.cast(Integer) == 5

      Note that equivalent functionality is available via the
      :attr:`.JSON.Comparator.as_integer` and similar accessors.

    * Path index operations (the ``#>`` operator)::

        data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')]

    * Path index operations returning text (the ``#>>`` operator)::

        data_table.c.data[('key_1', 'key_2', 5, ..., 'key_n')].astext == 'some value'

    .. versionchanged:: 1.1  The :meth:`_expression.ColumnElement.cast`
       operator on
       JSON objects now requires that the :attr:`.JSON.Comparator.astext`
       modifier be called explicitly, if the cast works only from a textual
       string.

    Index operations return an expression object whose type defaults to
    :class:`_types.JSON` by default,
    so that further JSON-oriented instructions
    may be called upon the result type.

    Custom serializers and deserializers are specified at the dialect level,
    that is using :func:`_sa.create_engine`.  The reason for this is that when
    using psycopg2, the DBAPI only allows serializers at the per-cursor
    or per-connection level.   E.g.::

        engine = create_engine("postgresql://scott:tiger@localhost/test",
                                json_serializer=my_serialize_fn,
                                json_deserializer=my_deserialize_fn
                        )

    When using the psycopg2 dialect, the json_deserializer is registered
    against the database using ``psycopg2.extras.register_default_json``.

    .. seealso::

        :class:`_types.JSON` - Core level JSON type

        :class:`_postgresql.JSONB`

    FNc                    s(   t t| j|d |dur|| _dS dS )a+  Construct a :class:`_types.JSON` type.

        :param none_as_null: if True, persist the value ``None`` as a
         SQL NULL value, not the JSON encoding of ``null``.   Note that
         when this flag is False, the :func:`.null` construct can still
         be used to persist a NULL value::

             from sqlalchemy import null
             conn.execute(table.insert(), data=null())

         .. versionchanged:: 0.9.8 - Added ``none_as_null``, and :func:`.null`
            is now supported in order to persist a NULL value.

         .. seealso::

              :attr:`_types.JSON.NULL`

        :param astext_type: the type to use for the
         :attr:`.JSON.Comparator.astext`
         accessor on indexed attributes.  Defaults to :class:`_types.Text`.

         .. versionadded:: 1.1

        )none_as_nullN)superr   __init__astext_type)r&   r.   r1   	__class__r   r   r0      s   
zJSON.__init__c                   @   s   e Zd ZdZedd ZdS )zJSON.Comparator6Define comparison operations for :class:`_types.JSON`.c                 C   sL   t | jjjtjjr| jjjt	| jj| jj
dS | jjjt| jj| jj
dS )a  On an indexed expression, use the "astext" (e.g. "->>")
            conversion when rendered in SQL.

            E.g.::

                select([data_table.c.data['some key'].astext])

            .. seealso::

                :meth:`_expression.ColumnElement.cast`

            Zresult_type)r   exprrighttypesqltypesr   r   leftoperateJSONPATH_ASTEXTr1   ASTEXT)r&   r   r   r   astext   s   zJSON.Comparator.astextN)r+   r,   r-   __doc__propertyr>   r   r   r   r   
Comparator   s    rA   )FN)r+   r,   r-   r?   r9   Textr1   r0   r   rA   comparator_factory__classcell__r   r   r2   r   r   a   s    Jr   c                   @   s*   e Zd ZdZd ZG dd dejZeZdS )r   a  Represent the PostgreSQL JSONB type.

    The :class:`_postgresql.JSONB` type stores arbitrary JSONB format data,
    e.g.::

        data_table = Table('data_table', metadata,
            Column('id', Integer, primary_key=True),
            Column('data', JSONB)
        )

        with engine.connect() as conn:
            conn.execute(
                data_table.insert(),
                data = {"key1": "value1", "key2": "value2"}
            )

    The :class:`_postgresql.JSONB` type includes all operations provided by
    :class:`_types.JSON`, including the same behaviors for indexing
    operations.
    It also adds additional operators specific to JSONB, including
    :meth:`.JSONB.Comparator.has_key`, :meth:`.JSONB.Comparator.has_all`,
    :meth:`.JSONB.Comparator.has_any`, :meth:`.JSONB.Comparator.contains`,
    and :meth:`.JSONB.Comparator.contained_by`.

    Like the :class:`_types.JSON` type, the :class:`_postgresql.JSONB`
    type does not detect
    in-place changes when used with the ORM, unless the
    :mod:`sqlalchemy.ext.mutable` extension is used.

    Custom serializers and deserializers
    are shared with the :class:`_types.JSON` class,
    using the ``json_serializer``
    and ``json_deserializer`` keyword arguments.  These must be specified
    at the dialect level using :func:`_sa.create_engine`.  When using
    psycopg2, the serializers are associated with the jsonb type using
    ``psycopg2.extras.register_default_jsonb`` on a per-connection basis,
    in the same way that ``psycopg2.extras.register_default_json`` is used
    to register these handlers with the json type.

    .. versionadded:: 0.9.7

    .. seealso::

        :class:`_types.JSON`

    c                   @   s8   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d ZdS )zJSONB.Comparatorr4   c                 C      | j t|tjdS )zvBoolean expression.  Test for presence of a key.  Note that the
            key may be a SQLA expression.
            r5   )r;   HAS_KEYr9   Booleanr&   otherr   r   r   has_key     zJSONB.Comparator.has_keyc                 C   rE   )z;Boolean expression.  Test for presence of all keys in jsonbr5   )r;   HAS_ALLr9   rG   rH   r   r   r   has_all%     zJSONB.Comparator.has_allc                 C   rE   )z:Boolean expression.  Test for presence of any key in jsonbr5   )r;   HAS_ANYr9   rG   rH   r   r   r   has_any)  rN   zJSONB.Comparator.has_anyc                 K   rE   )zBoolean expression.  Test if keys (or array) are a superset
            of/contained the keys of the argument jsonb expression.
            r5   )r;   CONTAINSr9   rG   )r&   rI   kwargsr   r   r   contains-  rK   zJSONB.Comparator.containsc                 C   rE   )z|Boolean expression.  Test if keys are a proper subset of the
            keys of the argument jsonb expression.
            r5   )r;   CONTAINED_BYr9   rG   rH   r   r   r   contained_by3  s   zJSONB.Comparator.contained_byN)	r+   r,   r-   r?   rJ   rM   rP   rS   rU   r   r   r   r   rA     s    rA   N)r+   r,   r-   r?   Z__visit_name__r   rA   rC   r   r   r   r   r      s
    /r   N)
__future__r    r   r9   r   sqlr   __all__Z_PRECEDENCEZjson_getitem_opZidx_precedenceZ	custom_opr=   r<   rF   rL   rO   rQ   rT   r   r   r   r   r   r   r   <module>   sh    
