Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.12/site-packages/pandas/io/__pycache__/
Upload File :
Current File : //usr/local/lib/python3.12/site-packages/pandas/io/__pycache__/sql.cpython-312.pyc

�

MٜgH�����dZddlmZddlmZmZddlmZmZddl	m
Z
m	Z	mZddlm
Z
ddlZddlmZmZmZmZmZmZddlZddlZdd	lmZdd
lmZddlmZddlm Z m!Z!dd
l"m#Z#ddl$m%Z%ddl&m'Z'm(Z(ddl)m*Z*m+Z+ddl,m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4ddl5m6Z6ddl7m8cm9Z:ddl7m;Z;ddl<m=Z=ddl>m?Z?er*ddl@mAZAmBZBddlCmDZDddlEmFZFmGZGddlHmIZImJZJmKZKmLZLmMZMddl.mNZNd�ZO	dO			dPd�ZPd �ZQ		dQ					dRd#�ZR					dS					dTd$�ZSdddd"d%�							dUd&�ZTdVd'�ZUe							dW													dXd(��ZVe							dW													dYd)��ZVddd!dddej�f																	dZd*�ZVe							dW													d[d+��ZXe							dW													d\d,��ZXdd!ddddej�f															d]d-�ZXe								d^											d_d.��ZYe								d^											d`d/��ZYdd!ddddej�df													dad0�ZY								db																			dcd1�ZZdVddd2�Z[e[Z\		de					dfd4�Z]Gd5�d6e6�Z^Gd7�d3e6e�Z_Gd8�d9�Z`Gd:�d;e`�Zadgd<�ZbGd=�d>e_�ZcGd?�d@e_�ZddAdBdCdDdEdFdCdG�ZedhdH�ZfdhdI�ZgGdJ�dKe^�ZhGdL�dMe_�Zi				di							djdN�Zjy)kz|
Collection of query wrappers / abstractions to both facilitate data
retrieval and to reduce dependency on DB-specific API.
�)�annotations)�ABC�abstractmethod)�	ExitStack�contextmanager)�date�datetime�time)�partialN)�
TYPE_CHECKING�Any�Callable�Literal�cast�overload)�using_pyarrow_string_dtype)�lib��import_optional_dependency)�AbstractMethodError�
DatabaseError)�find_stack_level)�check_dtype_backend)�is_dict_like�is_list_like)�
ArrowDtype�DatetimeTZDtype)�isna)�
get_option)�	DataFrame�Series)�ArrowExtensionArray)�PandasObject)�maybe_make_list)�convert_object_array)�to_datetime)�Iterator�Mapping)�Table)�Select�
TextClause)�DateTimeErrorChoices�DtypeArg�DtypeBackend�
IndexLabel�Self)�Indexc�@�|dus|�|durg}|St|d�s|g}|S)z3Process parse_dates argument for read_sql functionsTF�__iter__)�hasattr)�parse_datess �8/usr/local/lib/python3.12/site-packages/pandas/io/sql.py�_process_parse_dates_argumentr7^s>���d��k�1�[�E�5I������[�*�
-�"�m����c��t|t�r6|jdd�xsd}|dk(r
	t|fi|��St|fd|i|��S|�^t
|jjtj�s.t
|jjtj�rd}|dvrt|d||��St|jt�r
t|d��St|d||�	�S#tt
f$r|cYSwxYw)
N�errors�ignore�s)�D�d�h�mr<�ms�us�ns�coerce)r:�unit�utcT�rF)r:�formatrF)
�
isinstance�dict�popr&�	TypeError�
ValueError�
issubclass�dtype�type�np�floating�integerr)�colrFrH�errors    r6�_handle_date_columnrVis����&�$��
'-�j�j��4�&@�&L�H���H��
�"�3�1�&�1�1��3�7�u�7��7�7��>��s�y�y�~�~�r�{�{�3��#�)�)�.�.�"�*�*�5��F��@�@��s�8�&�c�J�J�
��	�	�?�
3��s��-�-��s�8�F��L�L��'�z�*�
��
�
�s�C0�0D�Dc��t|�}t|j��D]J\}\}}t|jt
�s||vs�(	||}|j|t||����L|S#ttf$rd}Y�4wxYw)zz
    Force non-datetime columns to be read as such.
    Supports both string formatted and integer timestamp columns.
    N�rH)
r7�	enumerate�itemsrIrOr�KeyErrorrL�isetitemrV)�
data_framer5�i�col_name�df_col�fmts      r6�_parse_date_columnsrb�s���
0��<�K�
"+�:�+;�+;�+=�!>����H�f��f�l�l�O�4��K�8O�
�!�(�+��
����#6�v�c�#J�K�
"?����	�i�(�
���
�s�A4�4B�BT�numpyc
��tj|�}tt|j�d||��}|dk(rqtd�}g}|D]]}|j
|d��}	|jdk(r|	j|j��}	|jt|	���_|}|rBtttttt!|���|���}
||
_|
St|��S)N)rO�coerce_float�
dtype_backend�pyarrowT)�from_pandas�string)�columns)r�to_object_array_tuplesr%�list�Tr�arrayrOrri�appendr"r rJ�zip�range�lenrj)�datarjrerf�content�arrays�pa�
result_arrays�arr�pa_array�dfs           r6�_convert_arrays_to_dataframer{�s����(�(��.�G�
!��W�Y�Y���!�#�	�F��	�!�
'�	�
2���
��C��x�x���x�6�H��y�y�H�$�$�=�=�����5��� � �!4�X�!>�?����
�
�t�C��U�3�w�<�%8� 9�6�B�C�
D����
��	���)�)r8c��t||||�}|r|j|�}t||�}|�|j|�}|S�z5Wrap result set of a SQLAlchemy query in a DataFrame.)r{�astyperb�	set_index)rsrj�	index_colrer5rOrf�frames        r6�_wrap_resultr��sJ��
)��w��m�T�E�����U�#����{�3�E������	�*���Lr8)r�r5rOrfc�j�|r|j|�}t||�}|�|j|�}|Sr})r~rbr)rzr�r5rOrfs     r6�_wrap_result_adbcr��s:��
�
�Y�Y�u�
��	�R��	-�B���
�\�\�)�
$��
�Ir8c�4�tjdtt���t	dd��}|�1t|t|jjf�rtd��t|d�	�5}|j||�cddd�S#1swYyxYw)
a�
    Execute the given SQL query using the provided connection object.

    Parameters
    ----------
    sql : string
        SQL query to be executed.
    con : SQLAlchemy connection or sqlite3 connection
        If a DBAPI2 object, only sqlite3 is supported.
    params : list or tuple, optional, default: None
        List of parameters to pass to execute method.

    Returns
    -------
    Results Iterable
    zP`pandas.io.sql.execute` is deprecated and will be removed in the future version.��
stacklevel�
sqlalchemyr;�r:Nz+pandas.io.sql.execute requires a connectionT)�need_transaction)�warnings�warn�
FutureWarningrrrI�str�engine�EnginerL�pandasSQL_builder�execute)�sql�con�paramsr��
pandas_sqls     r6r�r��s���"
�M�M�	1��#�%�	�,�L��J�J���*�S�3�
�8I�8I�8P�8P�2Q�"R��E�F�F�	�3��	6�*��!�!�#�v�.�
7�	6�	6�s�2B�Bc	��y�N��	�
table_namer��schemar�rer5rj�	chunksizerfs	         r6�read_sql_tabler����r8c	��yr�r�r�s	         r6r�r�r�r8c	
�F�t|�|tjurd}|tjusJ�t||d��5}	|	j	|�std|�d���|	j
|||||||��}
ddd�
�|
Std|�d�|��#1swY�xYw)a0

    Read SQL database table into a DataFrame.

    Given a table name and a SQLAlchemy connectable, returns a DataFrame.
    This function does not support DBAPI connections.

    Parameters
    ----------
    table_name : str
        Name of SQL table in database.
    con : SQLAlchemy connectable or str
        A database URI could be provided as str.
        SQLite DBAPI connection mode not supported.
    schema : str, default None
        Name of SQL schema in database to query (if database flavor
        supports this). Uses default schema if None (default).
    index_col : str or list of str, optional, default: None
        Column(s) to set as index(MultiIndex).
    coerce_float : bool, default True
        Attempts to convert values of non-string, non-numeric objects (like
        decimal.Decimal) to floating point. Can result in loss of Precision.
    parse_dates : list or dict, default None
        - List of column names to parse as dates.
        - Dict of ``{column_name: format string}`` where format string is
          strftime compatible in case of parsing string times or is one of
          (D, s, ns, ms, us) in case of parsing integer timestamps.
        - Dict of ``{column_name: arg dict}``, where the arg dict corresponds
          to the keyword arguments of :func:`pandas.to_datetime`
          Especially useful with databases without native Datetime support,
          such as SQLite.
    columns : list, default None
        List of column names to select from SQL table.
    chunksize : int, default None
        If specified, returns an iterator where `chunksize` is the number of
        rows to include in each chunk.
    dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
        Back-end data type applied to the resultant :class:`DataFrame`
        (still experimental). Behaviour is as follows:

        * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
          (default).
        * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
          DataFrame.

        .. versionadded:: 2.0

    Returns
    -------
    DataFrame or Iterator[DataFrame]
        A SQL table is returned as two-dimensional data structure with labeled
        axes.

    See Also
    --------
    read_sql_query : Read SQL query into a DataFrame.
    read_sql : Read SQL query or database table into a DataFrame.

    Notes
    -----
    Any datetime values with time zone information will be converted to UTC.

    Examples
    --------
    >>> pd.read_sql_table('table_name', 'postgres:///db_name')  # doctest:+SKIP
    rcT�r�r�zTable z
 not found�r�rer5rjr�rfN)rr�
no_defaultr��	has_tablerM�
read_table)r�r�r�r�rer5rjr�rfr��tables           r6r�r�.s���Z�
�&�����&��
�����.�.�.�	�3�v��	E���#�#�J�/��v�j�\��<�=�=��%�%���%�#���'�&�
��	
F�
�����6�*��Z�8�#�>�>�#
F�	E�s�9B�B c	��yr�r��	r�r�r�rer�r5r�rOrfs	         r6�read_sql_queryr��r�r8c	��yr�r�r�s	         r6r�r��r�r8c	���t|�|tjurd}|tjusJ�t|�5}	|	j	||||||||��cddd�S#1swYyxYw)a�
    Read SQL query into a DataFrame.

    Returns a DataFrame corresponding to the result set of the query
    string. Optionally provide an `index_col` parameter to use one of the
    columns as the index, otherwise default integer index will be used.

    Parameters
    ----------
    sql : str SQL query or SQLAlchemy Selectable (select or text object)
        SQL query to be executed.
    con : SQLAlchemy connectable, str, or sqlite3 connection
        Using SQLAlchemy makes it possible to use any DB supported by that
        library. If a DBAPI2 object, only sqlite3 is supported.
    index_col : str or list of str, optional, default: None
        Column(s) to set as index(MultiIndex).
    coerce_float : bool, default True
        Attempts to convert values of non-string, non-numeric objects (like
        decimal.Decimal) to floating point. Useful for SQL result sets.
    params : list, tuple or mapping, optional, default: None
        List of parameters to pass to execute method.  The syntax used
        to pass parameters is database driver dependent. Check your
        database driver documentation for which of the five syntax styles,
        described in PEP 249's paramstyle, is supported.
        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}.
    parse_dates : list or dict, default: None
        - List of column names to parse as dates.
        - Dict of ``{column_name: format string}`` where format string is
          strftime compatible in case of parsing string times, or is one of
          (D, s, ns, ms, us) in case of parsing integer timestamps.
        - Dict of ``{column_name: arg dict}``, where the arg dict corresponds
          to the keyword arguments of :func:`pandas.to_datetime`
          Especially useful with databases without native Datetime support,
          such as SQLite.
    chunksize : int, default None
        If specified, return an iterator where `chunksize` is the number of
        rows to include in each chunk.
    dtype : Type name or dict of columns
        Data type for data or columns. E.g. np.float64 or
        {'a': np.float64, 'b': np.int32, 'c': 'Int64'}.

        .. versionadded:: 1.3.0
    dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
        Back-end data type applied to the resultant :class:`DataFrame`
        (still experimental). Behaviour is as follows:

        * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
          (default).
        * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
          DataFrame.

        .. versionadded:: 2.0

    Returns
    -------
    DataFrame or Iterator[DataFrame]

    See Also
    --------
    read_sql_table : Read SQL database table into a DataFrame.
    read_sql : Read SQL query or database table into a DataFrame.

    Notes
    -----
    Any datetime values with time zone information parsed via the `parse_dates`
    parameter will be converted to UTC.

    Examples
    --------
    >>> from sqlalchemy import create_engine  # doctest: +SKIP
    >>> engine = create_engine("sqlite:///database.db")  # doctest: +SKIP
    >>> with engine.connect() as conn, conn.begin():  # doctest: +SKIP
    ...     data = pd.read_sql_table("data", conn)  # doctest: +SKIP
    rc)r�r�rer5r�rOrfN)rrr�r��
read_query)
r�r�r�rer�r5r�rOrfr�s
          r6r�r��sq��l�
�&�����&��
�����.�.�.�	�3�	�:��$�$����%�#���'�%�	
�
 �	�	�s�A"�"A+c
��yr�r��
r�r�r�rer�r5rjr�rfrOs
          r6�read_sqlr����r8c
��yr�r�r�s
          r6r�r�*r�r8c
���t|�|tjurd}|tjusJ�t|�5}
t	|
t
�r"|
j
||||||||	��cddd�S	|
j|�}|r!|
j|||||||��cddd�S|
j
||||||||	��cddd�S#t$rd}Y�RwxYw#1swYyxYw)ak
    Read SQL query or database table into a DataFrame.

    This function is a convenience wrapper around ``read_sql_table`` and
    ``read_sql_query`` (for backward compatibility). It will delegate
    to the specific function depending on the provided input. A SQL query
    will be routed to ``read_sql_query``, while a database table name will
    be routed to ``read_sql_table``. Note that the delegated function might
    have more specific notes about their functionality not listed here.

    Parameters
    ----------
    sql : str or SQLAlchemy Selectable (select or text object)
        SQL query to be executed or a table name.
    con : ADBC Connection, SQLAlchemy connectable, str, or sqlite3 connection
        ADBC provides high performance I/O with native type support, where available.
        Using SQLAlchemy makes it possible to use any DB supported by that
        library. If a DBAPI2 object, only sqlite3 is supported. The user is responsible
        for engine disposal and connection closure for the ADBC connection and
        SQLAlchemy connectable; str connections are closed automatically. See
        `here <https://docs.sqlalchemy.org/en/20/core/connections.html>`_.
    index_col : str or list of str, optional, default: None
        Column(s) to set as index(MultiIndex).
    coerce_float : bool, default True
        Attempts to convert values of non-string, non-numeric objects (like
        decimal.Decimal) to floating point, useful for SQL result sets.
    params : list, tuple or dict, optional, default: None
        List of parameters to pass to execute method.  The syntax used
        to pass parameters is database driver dependent. Check your
        database driver documentation for which of the five syntax styles,
        described in PEP 249's paramstyle, is supported.
        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}.
    parse_dates : list or dict, default: None
        - List of column names to parse as dates.
        - Dict of ``{column_name: format string}`` where format string is
          strftime compatible in case of parsing string times, or is one of
          (D, s, ns, ms, us) in case of parsing integer timestamps.
        - Dict of ``{column_name: arg dict}``, where the arg dict corresponds
          to the keyword arguments of :func:`pandas.to_datetime`
          Especially useful with databases without native Datetime support,
          such as SQLite.
    columns : list, default: None
        List of column names to select from SQL table (only used when reading
        a table).
    chunksize : int, default None
        If specified, return an iterator where `chunksize` is the
        number of rows to include in each chunk.
    dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
        Back-end data type applied to the resultant :class:`DataFrame`
        (still experimental). Behaviour is as follows:

        * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
          (default).
        * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
          DataFrame.

        .. versionadded:: 2.0
    dtype : Type name or dict of columns
        Data type for data or columns. E.g. np.float64 or
        {'a': np.float64, 'b': np.int32, 'c': 'Int64'}.
        The argument is ignored if a table is passed instead of a query.

        .. versionadded:: 2.0.0

    Returns
    -------
    DataFrame or Iterator[DataFrame]

    See Also
    --------
    read_sql_table : Read SQL database table into a DataFrame.
    read_sql_query : Read SQL query into a DataFrame.

    Examples
    --------
    Read data from SQL via either a SQL query or a SQL tablename.
    When using a SQLite database only SQL queries are accepted,
    providing only the SQL tablename will result in an error.

    >>> from sqlite3 import connect
    >>> conn = connect(':memory:')
    >>> df = pd.DataFrame(data=[[0, '10/11/12'], [1, '12/11/10']],
    ...                   columns=['int_column', 'date_column'])
    >>> df.to_sql(name='test_data', con=conn)
    2

    >>> pd.read_sql('SELECT int_column, date_column FROM test_data', conn)
       int_column date_column
    0           0    10/11/12
    1           1    12/11/10

    >>> pd.read_sql('test_data', 'postgres:///db_name')  # doctest:+SKIP

    Apply date parsing to columns through the ``parse_dates`` argument
    The ``parse_dates`` argument calls ``pd.to_datetime`` on the provided columns.
    Custom argument values for applying ``pd.to_datetime`` on a column are specified
    via a dictionary format:

    >>> pd.read_sql('SELECT int_column, date_column FROM test_data',
    ...             conn,
    ...             parse_dates={"date_column": {"format": "%d/%m/%y"}})
       int_column date_column
    0           0  2012-11-10
    1           1  2010-11-12

    .. versionadded:: 2.2.0

       pandas now supports reading via ADBC drivers

    >>> from adbc_driver_postgresql import dbapi  # doctest:+SKIP
    >>> with dbapi.connect('postgres:///db_name') as conn:  # doctest:+SKIP
    ...     pd.read_sql('SELECT int_column FROM test_data', conn)
       int_column
    0           0
    1           1
    rc)r�r�rer5r�rfrONFr�)
rrr�r�rI�SQLiteDatabaser�r��	Exceptionr�)r�r�r�rer�r5rjr�rfrOr��_is_table_names            r6r�r�:s��B�
�&�����&��
�����.�.�.�	�3�	�:��j�.�1��(�(��#��)�'�#�+��)�	�
 �	�	#�'�1�1�#�6�N�
��(�(��#�)�'��#�+�)��)
 �	�<�(�(��#��)�'�#�+��)�	�=
 �	���	#�"�N�	#��
 �	�s5�)C�3C	�C�'C�	C�C�C�C�C#c
�"�|dvrtd|�d���t|t�r|j�}nt|t�std��t
||d��5}|j||f|||||||	|
d�|��cddd�S#1swYyxYw)	a�
    Write records stored in a DataFrame to a SQL database.

    Parameters
    ----------
    frame : DataFrame, Series
    name : str
        Name of SQL table.
    con : ADBC Connection, SQLAlchemy connectable, str, or sqlite3 connection
        or sqlite3 DBAPI2 connection
        ADBC provides high performance I/O with native type support, where available.
        Using SQLAlchemy makes it possible to use any DB supported by that
        library.
        If a DBAPI2 object, only sqlite3 is supported.
    schema : str, optional
        Name of SQL schema in database to write to (if database flavor
        supports this). If None, use default schema (default).
    if_exists : {'fail', 'replace', 'append'}, default 'fail'
        - fail: If table exists, do nothing.
        - replace: If table exists, drop it, recreate it, and insert data.
        - append: If table exists, insert data. Create if does not exist.
    index : bool, default True
        Write DataFrame index as a column.
    index_label : str or sequence, optional
        Column label for index column(s). If None is given (default) and
        `index` is True, then the index names are used.
        A sequence should be given if the DataFrame uses MultiIndex.
    chunksize : int, optional
        Specify the number of rows in each batch to be written at a time.
        By default, all rows will be written at once.
    dtype : dict or scalar, optional
        Specifying the datatype for columns. If a dictionary is used, the
        keys should be the column names and the values should be the
        SQLAlchemy types or strings for the sqlite3 fallback mode. If a
        scalar is provided, it will be applied to all columns.
    method : {None, 'multi', callable}, optional
        Controls the SQL insertion clause used:

        - None : Uses standard SQL ``INSERT`` clause (one per row).
        - ``'multi'``: Pass multiple values in a single ``INSERT`` clause.
        - callable with signature ``(pd_table, conn, keys, data_iter) -> int | None``.

        Details and a sample callable implementation can be found in the
        section :ref:`insert method <io.sql.method>`.
    engine : {'auto', 'sqlalchemy'}, default 'auto'
        SQL engine library to use. If 'auto', then the option
        ``io.sql.engine`` is used. The default ``io.sql.engine``
        behavior is 'sqlalchemy'

        .. versionadded:: 1.3.0

    **engine_kwargs
        Any additional kwargs are passed to the engine.

    Returns
    -------
    None or int
        Number of rows affected by to_sql. None is returned if the callable
        passed into ``method`` does not return an integer number of rows.

        .. versionadded:: 1.4.0

    Notes
    -----
    The returned rows affected is the sum of the ``rowcount`` attribute of ``sqlite3.Cursor``
    or SQLAlchemy connectable. If using ADBC the returned rows are the result
    of ``Cursor.adbc_ingest``. The returned value may not reflect the exact number of written
    rows as stipulated in the
    `sqlite3 <https://docs.python.org/3/library/sqlite3.html#sqlite3.Cursor.rowcount>`__ or
    `SQLAlchemy <https://docs.sqlalchemy.org/en/14/core/connections.html#sqlalchemy.engine.BaseCursorResult.rowcount>`__
    )�fail�replacero�'�' is not valid for if_existsz9'frame' argument should be either a Series or a DataFrameTr�)�	if_exists�index�index_labelr�r�rO�methodr�N)rMrIr!�to_framer �NotImplementedErrorr��to_sql)
r��namer�r�r�r�r�r�rOr�r��
engine_kwargsr�s
             r6r�r��s���j�5�5��1�Y�K�'C�D�E�E��%�� ���� ��
��y�
)�!�G�
�	
�
�3�v��	E�� �z� � ���
� ��#������
��
�
F�	E�	E�s�B�Bc�j�t||��5}|j|�cddd�S#1swYyxYw)a�
    Check if DataBase has named table.

    Parameters
    ----------
    table_name: string
        Name of SQL table.
    con: ADBC Connection, SQLAlchemy connectable, str, or sqlite3 connection
        ADBC provides high performance I/O with native type support, where available.
        Using SQLAlchemy makes it possible to use any DB supported by that
        library.
        If a DBAPI2 object, only sqlite3 is supported.
    schema : string, default None
        Name of SQL schema in database to write to (if database flavor supports
        this). If None, use default schema (default).

    Returns
    -------
    boolean
    �r�N)r�r�)r�r�r�r�s    r6r�r�Ys*��*
�3�v�	.�*��#�#�J�/�
/�	.�	.�s�)�2�	PandasSQLc���ddl}t||j�s|�t|�St	dd��}t|t
�r
|�t
d��|�3t|t
|jjf�r
t|||�St	dd��}|r!t||j�rt|�Stjdtt��	�t|�S)
z�
    Convenience function to return the correct PandasSQL subclass based on the
    provided parameters.  Also creates a sqlalchemy connection and transaction
    if necessary.
    rNr�r;r�z.Using URI string without sqlalchemy installed.zadbc_driver_manager.dbapiz�pandas only supports SQLAlchemy connectable (engine/connection) or database string URI or sqlite3 DBAPI2 connection. Other DBAPI2 objects are not tested. Please consider using SQLAlchemy.r�)�sqlite3rI�
Connectionr�rr��ImportErrorr��Connectable�SQLDatabase�ADBCDatabaser�r��UserWarningr)r�r�r�r�r��adbcs      r6r�r�us�����#�w�)�)�*�c�k��c�"�"�+�L��J�J��#�s��
� 2��J�K�K���*�S�3�
�8I�8I�8U�8U�2V�"W��3��(8�9�9�%�&A�(�S�D��
�3����0��C� � ��M�M�	D�	�#�%���#��r8c��eZdZdZ								d											dd�Zd�Zdd�Zdd�Zdd�Zdd�Z	dd	�Z
dd
�Z		d					dd�Z			d							dd�Z
					d									dd
�Zd�Zd�Zd�Z		d 			d!d�Zd"d�Zd�Zy)#�SQLTablez�
    For mapping Pandas tables to SQL tables.
    Uses fact that table is reflected by SQLAlchemy to
    do better type conversions.
    Also holds various flags needed to avoid having to
    pass them between functions all the time.
    Nc��||_||_||_||_|j	||�|_||_||_|	|_|
|_	|�|j�|_n5|jj|j|j�|_|j�td|�d���t|j�std��y)NzCould not init table 'r�zEmpty table name specified)r��pd_sql�prefixr��_index_namer�r�r��keysrO�_create_table_setupr��	get_tablerMrr)�selfr��pandas_sql_enginer�r�r�r�r�r�r�rOs           r6�__init__zSQLTable.__init__�s�����	�'��������
��%�%�e�[�9��
����"�����	���
����1�1�3�D�J����.�.�t�y�y�$�+�+�F�D�J��:�:���5�d�V�1�=�>�>��4�9�9�~��9�:�:�r8c�b�|jj|j|j�Sr�)r�r�r�r��r�s r6�existszSQLTable.exists�s!���{�{�$�$�T�Y�Y����<�<r8c��ddlm}t||j�j	|j
j��S)Nr)�CreateTable)�sqlalchemy.schemar�r�r��compiler�r�)r�r�s  r6�
sql_schemazSQLTable.sql_schema�s,��1��;�t�z�z�*�2�2�4�;�;�?�?�C�D�Dr8c�*�|jj|jj�|_|jj	�5|jj|jj��ddd�y#1swYyxYw)N��bind)r��to_metadatar��meta�run_transaction�creater�r�s r6�_execute_createzSQLTable._execute_create�s[���Z�Z�+�+�D�K�K�,<�,<�=��
�
�[�[�
(�
(�
*��J�J���4�;�;�?�?��3�+�
*�
*�s�1B	�	Bc��|j�r�|jdk(rtd|j�d���|jdk(rA|jj|j|j�|j�y|jdk(rytd|j�d���|j�y)Nr��Table '�' already exists.r�ror�r�)r�r�rMr�r��
drop_tabler�r�r�s r6r�zSQLTable.create�s����;�;�=��~�~��'� �7�4�9�9�+�5F�!G�H�H��~�~��*����&�&�t�y�y�$�+�+�>��$�$�&����8�+�� �1�T�^�^�$4�4P�!Q�R�R�� � �"r8c	��|D�cgc]}tt||����}}|j|jj	�|�}|j
Scc}w)a<
        Execute SQL statement inserting data

        Parameters
        ----------
        conn : sqlalchemy.engine.Engine or sqlalchemy.engine.Connection
        keys : list of str
           Column names
        data_iter : generator of list
           Each item contains a list of values to be inserted
        )rJrpr�r��insert�rowcount)r��connr��	data_iter�rowrs�results       r6�_execute_insertzSQLTable._execute_insert�sO��1:�:�	���S��s�^�$�	��:����d�j�j�/�/�1�4�8�������;s�Ac	���ddlm}|D�cgc]}tt||����}}||j�j|�}|j
|�}|jScc}w)a

        Alternative to _execute_insert for DBs support multi-value INSERT.

        Note: multi-value insert is usually faster for analytics DBs
        and tables containing a few columns
        but performance degrades quickly with increase of columns.

        r)r�)r�r�rJrpr��valuesr�r�)	r�r�r�r�r�r�rs�stmtr�s	         r6�_execute_insert_multizSQLTable._execute_insert_multi�s\��	&�09�:�	���S��s�^�$�	��:��d�j�j�!�(�(��.�����d�#�������;s�A'c���|j�I|jj�}|j|j_	|j	d��n|j}t
tt|j��}t|�}dg|z}t|j��D�]\}\}}|jjdk(r�t|j t"�r�ddl}	|	j&j)|jj*�r"|j j-t.��}
�n%t1j2�5t1j4dt6��t9j:|j<j?�t.��}
ddd�n�|j j?�}
n�|jjd	k(rf|j }t|t"�r%|j-t9jd
���}|jAd�jCt.�}
n|j jCt.�}
t
t8jD�sJtG|
���|jHrtK|
�}d|
|<|
||<��||fS#t
$r}td|���|�d}~wwxYw#1swY�{xYw)NT��inplacez!duplicate name in index/columns: �Mr)rOr;)�categoryr@zm8[ns]�i8)&r�r��copy�names�reset_indexrMrl�mapr�rjrrrYrZrO�kindrI�_valuesr"rg�types�is_date�
pyarrow_dtype�to_numpy�objectr��catch_warnings�filterwarningsr�rQ�asarray�dt�
to_pydatetime�viewr~�ndarrayrP�_can_hold_nar)
r��temp�err�column_names�ncols�	data_listr^�_�serrvr>�vals�masks
             r6�insert_datazSQLTable.insert_datas-���:�:�!��:�:�?�?�$�D�#�z�z�D�J�J��
U�� � �� �.��:�:�D��C��T�\�\�2�3���L�!��(,�f�u�n�	�$�T�Z�Z�\�2�K�A�x��3��y�y�~�~��$��c�k�k�+>�?�(��x�x�'�'��	�	�(?�(?�@��K�K�0�0�v�0�>��%�4�4�6�$�3�3�H�}�U� "�
�
�3�6�6�+?�+?�+A�� P�A�7�6�
���1�1�3�A������3�&��{�{���d�$7�8��=�=�r�x�x��/A�=�B�D��I�I�d�O�*�*�6�2���K�K�&�&�v�.���a����,�5�d�1�g�5�,�����A�w����$���I�a�L�?3�B�Y�&�&��Y�
U� �#D�S�E�!J�K�QT�T��
U��(7�6�s%�J8�AK�8	K�K�K�K!	c�@�
��|�
|j}n8|dk(r
|j}n&t|�r
t||�}nt	d|����|j�\}}t
|j�}|dk(ry|�|}n|dk(rt	d��||zdz}d}|jj�5}	t|�D]I}
|
|z�t|
dz|z|��
��
k\rn+t�
�fd�|D��}||	||�}|��@|�|}�E||z
}�Kddd�|S#1swY|SxYw)N�multizInvalid parameter `method`: rz%chunksize argument should be non-zero�c3�(�K�|]	}|�����y�wr�r�)�.0rx�end_i�start_is  ��r6�	<genexpr>z"SQLTable.insert.<locals>.<genexpr>^s�����"K��#�3�w�u�#5��s�)
r�r��callablerrMrrrr�r�r�rq�minrp)r�r�r��exec_insertr�r�nrows�chunks�total_insertedr�r^�
chunk_iter�num_insertedr%r&s             @@r6r�zSQLTable.insert:sG����>��.�.�K�
�w�
��4�4�K�
�f�
�!�&�$�/�K��;�F�8�D�E�E��*�*�,���i��D�J�J����A�:�����I�
�!�^��D�E�E��9�$��)����
�[�[�
(�
(�
*�d��6�]���i�-���Q��U�i�/��7���e�#�� �"K��"K�L�
�*�4��z�B���+�%�-�)5��&�,�6��#�+���+���s�1AD�=D�Dc#�vK�d}|5	|j|�}	|	s|stjg||����njd}t|	|||�|_|j||��|j�'|jj|jd��|j����	ddd�y#1swYyxYw�w)z,Return generator through chunked result set.FT�rjre�r5rfNr�)�	fetchmanyr �from_recordsr{r��_harmonize_columnsr�r)
r�r��
exit_stackr�rjrer5rf�
has_read_datarss
          r6�_query_iteratorzSQLTable._query_iteratorhs������
�
���'�'�	�2���(�'�4�4���l���� $�
�9��'�<����
��'�'� +�=�(���:�:�)��J�J�(�(����T�(�B��j�j� �+���Z�Z�s�B9�BB-�$	B9�-B6�2B9c	��ddlm}|��t|�dkDrx|D�cgc]}|jj|��}	}|j
�@|j
ddd�D]+}
|	j
d|jj|
��-||	�}n||j�}|jj|�}|j�}
|�|j||||
|||��S|j�}t||
||�|_
|j||��|j
�'|jj|j
d��|jScc}w)Nr)�select���)rer5rfr2Tr�)r�r:rrr��cr�r�r�r�r�r8�fetchallr{r�r5r)r�r6rer5rjr�rfr:�n�cols�idx�
sql_selectr�rrss               r6�readz
SQLTable.read�sQ��	&���3�w�<�!�#3�-4�5�W��D�J�J�L�L��O�W�D�5��z�z�%��:�:�d��d�+�C��K�K��4�:�:�<�<��#4�5�,����J���
�
�+�J����$�$�Z�0���{�{�}��� ��'�'�����)�'�+�(��
��?�?�$�D�5��l�L�-��D�J�
�#�#�'�}�
$�
��z�z�%��
�
�$�$�T�Z�Z��$�>��:�:���C6s� Ec���|dur�|jjj}|�1t|t�s|g}t|�|k7rt
d|����|S|dk(r;d|jjvr#|jjj�dgStj|jjj�St|t�r|gSt|t�r|Sy)NTz@Length of 'index_label' should match number of levels, which is r"r�)
r�r��nlevelsrIrlrrrMrjr��com�fill_missing_namesrr�)r�r�r�rDs    r6r�zSQLTable._index_name�s����D�=��j�j�&�&�.�.�G��&�!�+�t�4�#.�-�K��{�#�w�.�$�,�,3�9�6���#�"��1���4�:�:�#5�#5�5��J�J�$�$�)�)�1��y� ��-�-�d�j�j�.>�.>�.D�.D�E�E���s�
#��7�N�
��t�
$��L�r8c
���g}|j�et|j�D]M\}}||jjj|��}|j	t|�|df��O|t
t|jj��D�cgc]H}t|jj|�||jjdd�|f�df��Jc}z
}|Scc}w)NTF)
r�rYr��_get_level_valuesror�rqrrrj�iloc)r��dtype_mapper�column_names_and_typesr^�	idx_label�idx_types      r6�_get_column_names_and_typesz$SQLTable._get_column_names_and_types�s���!#���:�:�!� )�$�*�*� 5���9�'��
�
�(8�(8�(J�(J�1�(M�N��&�-�-�s�9�~�x��.N�O�!6�	��3�t�z�z�1�1�2�3�#
�3������#�#�A�&�
'��d�j�j�o�o�a��d�6K�)L�e�T�3�#
�	
��
&�%��#
s�A
C3c
��ddlm}m}m}ddlm}|j
|j�}|D���cgc]\}}}||||����}	}}}|j�Ut|j�s|jg}
n|j}
||
d|jdzi�}|	j|�|jxs |jjj}|�}
||j|
g|	��d|i�Scc}}}w)Nr)�Column�PrimaryKeyConstraintr)��MetaData)r�r��_pkr�)r�rPrQr)r�rSrN�_sqlalchemy_typer�rr�ror�r�r�)r�rPrQr)rSrKr��typ�is_indexrjr��pkcr�r�s              r6r�zSQLTable._create_table_setup�s���	
�	
�
	/�!%�!A�!A�$�BW�BW�!X��(>�
�'=�#��c�8�
�4��H�-�'=�	�
�
�9�9� ���	�	�*��	�	�{���y�y��&��E�4�9�9�u�3D�E�C��N�N�3�����7���� 0� 0� 7� 7���z���T�Y�Y��>�w�>�v�>�>��%
s�C9c���t|�}|jjD�](}|j}	|j|}||vr!	||}t
||��|j|<�E|j|j�}|tus|tus|tur#|tu}t
||��|j|<n�|dk(r)|tur!|j|d��|j|<n`|dk(r[t|�|j�k(r?|t!j"d�us|t$ur |j|d��|j|<��+y#t
$rd}Y��wxYw#t&$rY��KwxYw)a
        Make the DataFrame's column types align with the SQL table
        column types.
        Need to work around limited NA value support. Floats are always
        fine, ints must always be floats if there are Null values.
        Booleans are hard because converting bool column with None replaces
        all Nones with false. Therefore only convert bool if there are no
        NA values.
        Datetimes should already be converted to np.datetime64 if supported,
        but here we also force conversion if required.
        NrXrGrcF)r�int64)r7r�rjr�r�rLrV�
_get_dtyperPr	rr�floatr~rr�countrQrO�boolr[)	r�r5rf�sql_colr_r`ra�col_typerFs	         r6r5zSQLTable._harmonize_columnssa�� 4�K�@���z�z�)�)�G��|�|�H�!
����H�-���{�*�#�)�(�3��,?�v�c�+R�D�J�J�x�(�� �?�?�7�<�<�8����(��4�'��?�2�#�o�5�C�+>�v�3�+O�D�J�J�x�(�"�g�-�(�e�2C�+1�=�=���=�+N�D�J�J�x�(�"�g�-�#�f�+�����2O��2�8�8�G�#4�4��D�8H�/5�}�}�X�E�}�/R��
�
�8�,��C*��%�#�"��#��0�
��
�s<�E!�E�E!�'C$E!�E�E!�E�E!�!	E.�-E.c��|jxsi}t|�r-tt|�}|j|vr||jStj|d��}ddlm}m	}m
}m}m}m
}	m}
m}m}m}
|dvr#	|j$j&�	|d��S	|S|dk(r&t-j.d	t0t3��
�|S|dk(r!|jdk(r	|	d
��S|	d��S|dk(r�|jjj5�dvr|S|jjj5�dvr|
S|jjj5�dk(rt7d��|S|dk(r|S|dk(r|S|dk(r|
S|dk(rt7d��|S#t($rt+|dd��|d��cYSY|SwxYw)NT��skipnar)
�	TIMESTAMP�
BigInteger�Boolean�Date�DateTime�Float�Integer�SmallInteger�Text�Time)�
datetime64r	)�timezone�tz�timedelta64�lthe 'timedelta' type is not supported, and will be written as integer values (ns frequency) to the database.r�rR�float32�)�	precision�5rS)�int8�uint8�int16)�uint16�int32�uint64z1Unsigned 64 bit integer datatype is not supported�booleanrr
�complex�Complex datatypes not supported)rOrrrJr�r�infer_dtype�sqlalchemy.typesrdrerfrgrhrirjrkrlrmrrp�AttributeError�getattrr�r�r�r�lowerrM)r�rTrOr`rdrerfrgrhrirjrkrlrms              r6rUzSQLTable._sqlalchemy_type>s����*�*�*��������u�%�E��x�x�5� ��S�X�X��&��?�?�3�t�4��	
�	
�	
��1�1�
4��6�6�9�9�(�$�d�3�3�)��O��}�$��M�M�L��+�-�	
���
��
#��y�y�I�%��r�*�*��r�*�*�
��
"��y�y�~�~�#�#�%�)C�C�#�#������%�%�'�+>�>��������%�%�'�8�3� �!T�U�U�!�!�
��
"��N�
��
��K�
��
��K�
��
"��>�?�?����M"�
4��3��d�+�7�$�d�3�3�8��O�
4�s�=F � G�Gc�H�ddlm}m}m}m}m}m}t||�rtSt||�rtjd�St||�r|jstStSt||�rtSt||�rtSt||�rtSt S)Nr)rdrfrgrhrirjrZ)r�rdrfrgrhrirjrIr\rQrOror	rrr^r
)r��sqltyperdrfrgrhrirjs        r6r[zSQLTable._get_dtype�s���	
�	
��g�u�%��L�
���
)��8�8�G�$�$�
���
+��#�#���"�"�
���
*��O�
���
&��K�
���
)��K��
r8)NTr��pandasNNNN)r�r�r��bool | str | list[str] | Noner��$Literal['fail', 'replace', 'append']r�r�rO�DtypeArg | None�return�None�r�r��r�r�)r��	list[str]r��int)r�z"tuple[list[str], list[np.ndarray]])NN)r��
int | Noner��"Literal['multi'] | Callable | Noner�r�)TNrc)r6rr�r�rer^rf�DtypeBackend | Literal['numpy'])TNNNrc)
r6rrer^r�r�rfr�r��DataFrame | Iterator[DataFrame])Nrc)rfr�r�r�)rTzIndex | Series)�__name__�
__module__�__qualname__�__doc__r�r�r�r�r�r�r�rr�r8rBr�rNr�r5rUr[r�r8r6r�r��so����/3�:@����
�!%�";��";�
-�";�8�
";��";��";�
�";�H=�E�
4�#�� �"2'�l!%�59�,��,�3�,�
�	,�h"��9@�"!��"!��	"!��
"!�7�"!�N"��� $�9@�-��-��-��
-�7�-�
)�-�^�@&�?�@�9@�5�7�5�
�	5�nE�Nr8r�c�(�eZdZdZdd�Zdd�Z							d
													dd�Ze							d
													dd��Ze								d															dd��Z	eddd��Z
eddd	��Ze			d											dd
��Zy)r�z9
    Subclasses Should define read_query and to_sql.
    c��|Sr�r�r�s r6�	__enter__zPandasSQL.__enter__�s���r8c��yr�r��r��argss  r6�__exit__zPandasSQL.__exit__�s��r8Nc	��t�r��r�)	r�r�r�rer5rjr�r�rfs	         r6r�zPandasSQL.read_table�s
��"�!r8c	��yr�r�)	r�r�r�rer5r�r�rOrfs	         r6r�zPandasSQL.read_query�s��	
r8c��yr�r�)r�r�r�r�r�r�r�r�rOr�r�r�s            r6r�zPandasSQL.to_sql�s��	
r8c��yr�r�)r�r�r�s   r6r�zPandasSQL.execute����r8c��yr�r�)r�r�r�s   r6r�zPandasSQL.has_table�r�r8c��yr�r��r�r�r�r�rOr�s      r6�_create_sql_schemazPandasSQL._create_sql_schema�s��	
r8)r�r0r��NTNNNNrc�r�r�r��str | list[str] | Nonerer^r��
str | Noner�r�rfr�r�r��r�r�r�r�rer^r�r�rOr�rfr�r�r��r�TNNNNN�auto)r�r�r�r�r�r^r�r�rOr�r�r�r�r�r�r�r��r�zstr | Select | TextClause�r�r�r�r�r�r^�NNN�r�r r�r�r��list[str] | NonerOr�r�r�r�r�)
r�r�r�r�r�r�r�rr�r�r�r�r�r�r8r6r�r��s�����
�-1�!���!� $�9@�"��"�*�"��	"��"��"�7�"�
)�"��-1�!��� $�!%�9@�
�
�
�*�
��	
��
��
�7�
�
)�
��
��
;A���� $�!%�59��
��
�8�	
�
�
��
��
�3�
��
�
�
��
� �
��
��
��
��
"&�!%�!�

��
��
��	
�
�
��

�

�
��
r8c�0�eZdZ				d									dd�Zy)�
BaseEngineNc	��t|��)z:
        Inserts data into already-prepared table
        )r)
r�r�r�r�r�r�r�r�r�r�s
          r6�insert_recordszBaseEngine.insert_records�s��"�$�'�'r8�TNNN�
r�r�r�r�r�r�r�r�r�r�)r�r�r�r�r�r8r6r�r��sE��04�� $��(��(�
�(�-�
(��(�
�(r8r�c�8�eZdZdd�Z				d									dd�Zy)�SQLAlchemyEnginec��tdd��y)Nr�z'sqlalchemy is required for SQL support.)�extrarr�s r6r�zSQLAlchemyEngine.__init__s��"�� I�	
r8Nc	���ddlm}
	|j||��S#|
j$r@}d}t	|j
�}
t
j||
�rtd�|�|�d}~wwxYw)Nr)�exc)r�r�zg(\(1054, "Unknown column 'inf(e0)?' in 'field list'"\))(?#
            )|inf can not be used with MySQLzinf cannot be used with MySQL)	r�r�r��StatementErrorr��orig�re�searchrM)r�r�r�r�r�r�r�r�r�r�r�r�msg�err_texts              r6r�zSQLAlchemyEngine.insert_recordssj��	#�
	��<�<�)�F�<�C�C���!�!�	�0�C��3�8�8�}�H��y�y��h�'� �!@�A�s�J��I��	�s��A*�;A%�%A*r�r�r�)r�r�r�r�r�r�r8r6r�r�sJ��
�04�� $�����
��-�
���
�r8r�c��|dk(rtd�}|dk(r'tg}d}|D]}	|�cStd|����|dk(r
t�St	d��#t$r}|dt|�zz
}Yd}~�Ud}~wwxYw)	zreturn our implementationr�z
io.sql.engine�z
 - Nz�Unable to find a usable engine; tried using: 'sqlalchemy'.
A suitable version of sqlalchemy is required for sql I/O support.
Trying to import the above resulted in these errors:r�z*engine must be one of 'auto', 'sqlalchemy')rr�r�r�rM)r��engine_classes�
error_msgs�engine_classrs     r6�
get_enginer�"s���
����O�,��
���*�+���
�*�L�
1�#�~�%�+��
C��l�

�
�	
�����!�!�
�A�
B�B��!�
1��g��C��0�0�
��
1�s�A�	A;� A6�6A;c��eZdZdZ	d					dd�Zdd�Zed��Zddd�Z							d													dd�Z	e
					d									dd��Z							d													dd	�ZeZ
					d									dd
�Z						dd�Z								d																	d d�Zed
��Zdd!d�Zdd"d�Zdd#d�Z			d$											d%d�Zy)&r�aa
    This class enables conversion between DataFrame and SQL databases
    using SQLAlchemy to handle DataBase abstraction.

    Parameters
    ----------
    con : SQLAlchemy Connectable or URI string.
        Connectable to connect with the database. Using SQLAlchemy makes it
        possible to use any DB supported by that library.
    schema : string, default None
        Name of SQL schema in database to write to (if database flavor
        supports this). If None, use default schema (default).
    need_transaction : bool, default False
        If True, SQLDatabase will create a transaction.

    Nc���ddlm}ddlm}ddlm}t
�|_t|t�r-||�}|jj|j�t||�r)|jj|j��}|r9|j�s)|jj|j��||_||��|_d|_y)Nr)�
create_engine)r�rRr�F)r�r��sqlalchemy.enginer�r�rSrr6rIr��callback�dispose�
enter_context�connect�in_transaction�beginr�r��returns_generator)r�r�r�r�r�r�rSs       r6r�zSQLDatabase.__init__Ts���	-�,�.�$�+����c�3����$�C��O�O�$�$�S�[�[�1��c�6�"��/�/�/�/����
�>�C��C�$6�$6�$8��O�O�)�)�#�)�)�+�6�����F�+��	�!&��r8c�R�|js|jj�yyr�)r�r6�closer�s  r6r�zSQLDatabase.__exit__ks ���%�%��O�O�!�!�#�&r8c#��K�|jj�s2|jj�5|j��ddd�y|j��y#1swYyxYw�wr�)r�r�r�r�s r6r�zSQLDatabase.run_transactionosH�����x�x�&�&�(������!��h�h��"�!��(�(�N�"�!�s�5A*�A�A*�A'�#A*c��|�gn|g}t|t�r|jj|g|���S|jj|g|���S)z,Simple passthrough to SQLAlchemy connectable)rIr�r��exec_driver_sqlr�)r�r�r�r�s    r6r�zSQLDatabase.executewsQ���^�r�&����c�3��+�4�8�8�+�+�C�7�$�7�7��t�x�x����+�d�+�+r8c	���|jj|j|gd��t||||��}	|�d|_|	j|j|||||��S)ap
        Read SQL database table into a DataFrame.

        Parameters
        ----------
        table_name : str
            Name of SQL table in database.
        index_col : string, optional, default: None
            Column to set as index.
        coerce_float : bool, default True
            Attempts to convert values of non-string, non-numeric objects
            (like decimal.Decimal) to floating point. This can result in
            loss of precision.
        parse_dates : list or dict, default: None
            - List of column names to parse as dates.
            - Dict of ``{column_name: format string}`` where format string is
              strftime compatible in case of parsing string times, or is one of
              (D, s, ns, ms, us) in case of parsing integer timestamps.
            - Dict of ``{column_name: arg}``, where the arg corresponds
              to the keyword arguments of :func:`pandas.to_datetime`.
              Especially useful with databases without native Datetime support,
              such as SQLite.
        columns : list, default: None
            List of column names to select from SQL table.
        schema : string, default None
            Name of SQL schema in database to query (if database flavor
            supports this).  If specified, this overwrites the default
            schema of the SQL database object.
        chunksize : int, default None
            If specified, return an iterator where `chunksize` is the number
            of rows to include in each chunk.
        dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
            Back-end data type applied to the resultant :class:`DataFrame`
            (still experimental). Behaviour is as follows:

            * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
              (default).
            * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
              DataFrame.

            .. versionadded:: 2.0

        Returns
        -------
        DataFrame

        See Also
        --------
        pandas.read_sql_table
        SQLDatabase.read_query

        T)r��only�views)r�r�)rer5rjr�rf)r��reflectr�r�r�rBr6)
r�r�r�rer5rjr�r�rfr�s
          r6r�zSQLDatabase.read_table~sn��~	
�	�	���t�x�x�z�l�$��G���T��6�J��� �%)�D�"��z�z��O�O�%�#���'�
�
�	
r8c	
#��K�d}	|5	|j|�}
|
s|	stg||||||����nd}	t|
||||||�����A	ddd�y#1swYyxYw�w)�+Return generator through chunked result setFT�r�rer5rOrfN)r3r�)r�r6r�rjr�rer5rOrfr7rss           r6r8zSQLDatabase._query_iterator�s������
�
���'�'�	�2���(�*��#�&/�)5�(3�"'�*7���� $�
�"���'�!-� +��"/���!���Z�Z�s�A �AA�	A �A�A c	���|j||�}	|	j�}
|�+d|_|j|	|j||
|||||��	S|	j�}t
||
|||||��}|S)a�
        Read SQL query into a DataFrame.

        Parameters
        ----------
        sql : str
            SQL query to be executed.
        index_col : string, optional, default: None
            Column name to use as index for the returned DataFrame object.
        coerce_float : bool, default True
            Attempt to convert values of non-string, non-numeric objects (like
            decimal.Decimal) to floating point, useful for SQL result sets.
        params : list, tuple or dict, optional, default: None
            List of parameters to pass to execute method.  The syntax used
            to pass parameters is database driver dependent. Check your
            database driver documentation for which of the five syntax styles,
            described in PEP 249's paramstyle, is supported.
            Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}
        parse_dates : list or dict, default: None
            - List of column names to parse as dates.
            - Dict of ``{column_name: format string}`` where format string is
              strftime compatible in case of parsing string times, or is one of
              (D, s, ns, ms, us) in case of parsing integer timestamps.
            - Dict of ``{column_name: arg dict}``, where the arg dict
              corresponds to the keyword arguments of
              :func:`pandas.to_datetime` Especially useful with databases
              without native Datetime support, such as SQLite.
        chunksize : int, default None
            If specified, return an iterator where `chunksize` is the number
            of rows to include in each chunk.
        dtype : Type name or dict of columns
            Data type for data or columns. E.g. np.float64 or
            {'a': np.float64, 'b': np.int32, 'c': 'Int64'}

            .. versionadded:: 1.3.0

        Returns
        -------
        DataFrame

        See Also
        --------
        read_sql_table : Read SQL database table into a DataFrame.
        read_sql

        Tr�)r�r�r�r8r6r=r�)
r�r�r�rer5r�r�rOrfr�rjrsr�s
             r6r�zSQLDatabase.read_query�s���r���c�6�*���+�+�-��� �%)�D�"��'�'�������#�)�'��+�(�
�

��?�?�$�D� ���#�)�'��+��E��Lr8c
�^�|r�t|�s|D�cic]}||��}}ntt|�}ddlm}	|j�D]=\}
}t
|t�r
t||	�r�#t
||	�r�0td|
�d���t||||||||��}|j�|Scc}w)z_
        Prepares table in the database for data insertion. Creates it if needed, etc.
        r)�
TypeEnginezThe type of z is not a SQLAlchemy type)r�r�r�r�r�rO)rrrJr�r�rZrIrPrNrMr�r�)
r�r�r�r�r�r�r�rOr_r�rT�my_typer�s
             r6�
prep_tablezSQLDatabase.prep_tableKs������&�:?�?��X��5����?��T�5�)��3� %���
���W��g�t�,��G�Z�1P�����4��$�|�C�5�8Q�%R�S�S�
!.�������#���	
��	�������3@s�
B*c�*�|j�s�|j�srddlm}||j�}|j|xs|jj��}||vr+d|�d�}tj|tt���yyyy)zv
        Checks table name for issues with case-sensitivity.
        Method is called after data is inserted.
        r��inspectr�zThe provided table name 'z�' is not found exactly as such in the database after writing the table, possibly due to case sensitivity issues. Consider using lower case table names.r�N)�isdigit�islowerr�r�r��get_table_namesr�r�r�r�r�r)r�r�r��sqlalchemy_inspect�insp�table_namesr�s       r6�check_case_sensitivez SQLDatabase.check_case_sensitive{s����|�|�~�d�l�l�n�
A�%�d�h�h�/�D��.�.�f�6P��	�	�@P�@P�.�Q�K��;�&�/��v�6(�(���
�
���/�1��'�'5�~r8c��t|
�}|j|||||||��}
|jd|
|j||||||	d�|��}|j	||��|S)a	
        Write records stored in a DataFrame to a SQL database.

        Parameters
        ----------
        frame : DataFrame
        name : string
            Name of SQL table.
        if_exists : {'fail', 'replace', 'append'}, default 'fail'
            - fail: If table exists, do nothing.
            - replace: If table exists, drop it, recreate it, and insert data.
            - append: If table exists, insert data. Create if does not exist.
        index : boolean, default True
            Write DataFrame index as a column.
        index_label : string or sequence, default None
            Column label for index column(s). If None is given (default) and
            `index` is True, then the index names are used.
            A sequence should be given if the DataFrame uses MultiIndex.
        schema : string, default None
            Name of SQL schema in database to write to (if database flavor
            supports this). If specified, this overwrites the default
            schema of the SQLDatabase object.
        chunksize : int, default None
            If not None, then rows will be written in batches of this size at a
            time.  If None, all rows will be written at once.
        dtype : single type or dict of column name to SQL type, default None
            Optional specifying the datatype for columns. The SQL type should
            be a SQLAlchemy type. If all columns are of the same type, one
            single value can be used.
        method : {None', 'multi', callable}, default None
            Controls the SQL insertion clause used:

            * None : Uses standard SQL ``INSERT`` clause (one per row).
            * 'multi': Pass multiple values in a single ``INSERT`` clause.
            * callable with signature ``(pd_table, conn, keys, data_iter)``.

            Details and a sample callable implementation can be found in the
            section :ref:`insert method <io.sql.method>`.
        engine : {'auto', 'sqlalchemy'}, default 'auto'
            SQL engine library to use. If 'auto', then the option
            ``io.sql.engine`` is used. The default ``io.sql.engine``
            behavior is 'sqlalchemy'

            .. versionadded:: 1.3.0

        **engine_kwargs
            Any additional kwargs are passed to the engine.
        )r�r�r�r�r�r�rO)r�r�r�r�r�r�r�r�)r�r�r�)r�r�r�r�r�)r�r�r�r�r�r�r�r�rOr�r�r��
sql_enginer�r-s               r6r�zSQLDatabase.to_sql�s���| ��'�
��������#��� �
��3��2�2�

�����������

��

��	
�!�!�t�F�!�;��r8c�.�|jjSr�)r��tablesr�s r6r�zSQLDatabase.tables�s���y�y���r8c��ddlm}||j�}|j||xs|jj
�S)Nrr�)r�r�r�r�r�r�)r�r�r�r�r�s     r6r�zSQLDatabase.has_table�s3��<�!�$�(�(�+���~�~�d�F�$>�d�i�i�.>�.>�?�?r8c��ddlm}m}|xs|jj}|||j|j
|��}|jD]*}t|j|�s�d|j_	�,|S)Nr)�Numericr))�
autoload_withr�F)
r�r�r)r�r�r�rjrIrP�	asdecimal)r�r�r�r�r)�tbl�columns       r6r�zSQLDatabase.get_table�sd��	
�
�+�4�9�9�+�+���J��	�	����&�Q���k�k�F��&�+�+�w�/�(-����%�"��
r8c��|xs|jj}|j||�r�|jj|j|g|d��|j�5|j
||�j|j��ddd�|jj�yy#1swY�%xYw)NT)r�r�r�r�r�)	r�r�r�r�r�r�r��drop�clear�r�r�r�s   r6r�zSQLDatabase.drop_tables����+�4�9�9�+�+���>�>�*�f�-��I�I����X�X�Z�L��t�
�
��%�%�'����z�6�2�7�7�T�X�X�7�F�(��I�I�O�O��
.�(�'�s�'-B8�8Cc	�X�t|||d|||��}t|j��S�NF)r�r�r�rOr�)r�r�r��r�r�r�r�rOr�r�s       r6r�zSQLDatabase._create_sql_schemas9����������
���5�#�#�%�&�&r8�NF)r�r�r�r^r�r�r�r�r�r�r��NTNNrc)
r6rr�r�rer^rOr�rfr�r�)r�TNNN)
r�r�r�r�r�r�rOr�r�r��r�r�r�r�r�r�r��r�r�r�r�r�r^r�r�r�r�rOr�r�r�r�r�r�r�r�)r�r�r�r�r�r)�r�r�r�r�r�r�r�r�)r�r�r�r�r�r�rr�r�r��staticmethodr8r�r�r�r�r��propertyr�r�r�r�r�r�r8r6r�r�Bs����$HM�'�%�'�@D�'�	
�'�.$�����,�-1�!���!� $�9@�J
��J
�*�J
��	J
��J
��J
�7�J
�
)�J
�X��!��!%�9@�&��&��&��
&��&�7�&��&�V-1�!��� $�!%�9@�T�
�T�*�T��	T��T��T�7�T�
)�T�l�H�;A�/3���!%�.��.�8�	.�
-�.��.�
�.�`�����
�	�B;A���!� $�!%�59��W��W�8�	W�
�W��W��W��W�3�W��W�
�W�r� �� �@���"&�!%�!�
'��'��'��	'�
�'��
'�

�'r8r�c��eZdZdZdd�Zed��Zdd
d�Z							d													dd�Z							d													dd�Z	e	Z
								d																	dd�Zddd	�Z			d											dd
�Z
y)r�z�
    This class enables conversion between DataFrame and SQL databases
    using ADBC to handle DataBase abstraction.

    Parameters
    ----------
    con : adbc_driver_manager.dbapi.Connection
    c��||_yr��r��r�r�s  r6r�zADBCDatabase.__init__3�	����r8c#�K�|jj�5}	|��|jj	�ddd�y#t$r|jj��wxYw#1swYyxYw�wr�)r��cursorr��rollback�commit�r��curs  r6r�zADBCDatabase.run_transaction6sd����
�X�X�_�_�
�#�
��	�
�H�H�O�O��
�
���
����!�!�#��
���
�s1�A:�A.�A�A.�	A:�%A+�+A.�.A7�3A:Nc	�t�t|t�std��|�gn|g}|jj	�}	|j
|g|���|S#t$r[}	|jj�n&#t$r}td|�d|�d��}||�d}~wwxYwtd|�d|���}||�d}~wwxYw�Nz/Query must be a string unless using sqlalchemy.zExecution failed on sql: �
z
unable to rollbackzExecution failed on sql 'z': �	rIr�rLr�rr�r�rr�r�r�r�r�rr��	inner_exc�exs        r6r�zADBCDatabase.execute@�����#�s�#��M�N�N��^�r�&����h�h�o�o���
	��C�K�K��#�d�#��J���
	�
(����!�!�#���
(�"�/��u�B�s�e�;O�P����i�'��	
(���!:�3�%�s�3�%�H�I�B��#���
	��5�A�	B7�A8�7B2�8	B�B�B�B2�2B7c	�,�|durtd��|rtd��|r.|rt|�}	ng}	|	|z}
djd�|
D��}nd}|rd|�d|�d	|��}nd|�d|��}|d
k(rt}
n7|dk(rdd
lm}|�j}
nt�rddlm}|�nd}
|jj�5}|j|�|j�j
��}ddd�t||��S#1swY�xYw)a9
        Read SQL database table into a DataFrame.

        Parameters
        ----------
        table_name : str
            Name of SQL table in database.
        coerce_float : bool, default True
            Raises NotImplementedError
        parse_dates : list or dict, default: None
            - List of column names to parse as dates.
            - Dict of ``{column_name: format string}`` where format string is
              strftime compatible in case of parsing string times, or is one of
              (D, s, ns, ms, us) in case of parsing integer timestamps.
            - Dict of ``{column_name: arg}``, where the arg corresponds
              to the keyword arguments of :func:`pandas.to_datetime`.
              Especially useful with databases without native Datetime support,
              such as SQLite.
        columns : list, default: None
            List of column names to select from SQL table.
        schema : string, default None
            Name of SQL schema in database to query (if database flavor
            supports this).  If specified, this overwrites the default
            schema of the SQL database object.
        chunksize : int, default None
            Raises NotImplementedError
        dtype_backend : {'numpy_nullable', 'pyarrow'}, default 'numpy_nullable'
            Back-end data type applied to the resultant :class:`DataFrame`
            (still experimental). Behaviour is as follows:

            * ``"numpy_nullable"``: returns nullable-dtype-backed :class:`DataFrame`
              (default).
            * ``"pyarrow"``: returns pyarrow-backed nullable :class:`ArrowDtype`
              DataFrame.

            .. versionadded:: 2.0

        Returns
        -------
        DataFrame

        See Also
        --------
        pandas.read_sql_table
        SQLDatabase.read_query

        T�2'coerce_float' is not implemented for ADBC drivers�/'chunksize' is not implemented for ADBC drivers�, c3�(K�|]
}d|�d����y�w)�"Nr�)r$�xs  r6r'z*ADBCDatabase.read_table.<locals>.<genexpr>�s����#@�i��a��s�!�H�i�s��*zSELECT z FROM �.rg�numpy_nullabler��_arrow_dtype_mapping)�arrow_string_types_mapperN��types_mapper)r�r5)r�r$�joinr�pandas.io._utilr,�getrr-r�rr��fetch_arrow_table�	to_pandasr�)r�r�r�rer5rjr�r�rf�index_select�	to_select�select_listr��mappingr,r-rrzs                  r6r�zADBCDatabase.read_tableTs.��t�t�#�%�D��
��%�&W�X�X���.�y�9��!��$�w�.�I��)�)�#@�i�#@�@�K��K���[�M���x�q���E�D��[�M��
�|�<�D��I�%� �G�
�.�
.�<�*�,�0�0�G�
'�
)�A�%�'��G�
�X�X�_�_�
�#��K�K����&�&�(�2�2��2�H�B��!���#�
�	
�	�
�s�2D
�
Dc	��|durtd��|rtd��|rtd��|dk(rt}	n|dk(rddlm}
|
�j}	nd	}	|j
j
�5}|j|�|j�j|	�
�}d	d	d	�t|||��S#1swY�xYw)a�
        Read SQL query into a DataFrame.

        Parameters
        ----------
        sql : str
            SQL query to be executed.
        index_col : string, optional, default: None
            Column name to use as index for the returned DataFrame object.
        coerce_float : bool, default True
            Raises NotImplementedError
        params : list, tuple or dict, optional, default: None
            Raises NotImplementedError
        parse_dates : list or dict, default: None
            - List of column names to parse as dates.
            - Dict of ``{column_name: format string}`` where format string is
              strftime compatible in case of parsing string times, or is one of
              (D, s, ns, ms, us) in case of parsing integer timestamps.
            - Dict of ``{column_name: arg dict}``, where the arg dict
              corresponds to the keyword arguments of
              :func:`pandas.to_datetime` Especially useful with databases
              without native Datetime support, such as SQLite.
        chunksize : int, default None
            Raises NotImplementedError
        dtype : Type name or dict of columns
            Data type for data or columns. E.g. np.float64 or
            {'a': np.float64, 'b': np.int32, 'c': 'Int64'}

            .. versionadded:: 1.3.0

        Returns
        -------
        DataFrame

        See Also
        --------
        read_sql_table : Read SQL database table into a DataFrame.
        read_sql

        Tr"z,'params' is not implemented for ADBC driversr#rgr*rr+Nr.)r�r5rO)r�rr1r,r2r�rr�r3r4r�)
r�r�r�rer5r�r�rOrfr8r,rrzs
             r6r�zADBCDatabase.read_query�s���f�t�#�%�D��
��%�&T�U�U��%�&W�X�X��I�%� �G�
�.�
.�<�*�,�0�0�G��G�
�X�X�_�_�
�#��K�K����&�&�(�2�2��2�H�B��!���#��	
�	
�	�
�s�/2B8�8Cc���|rtd��|rtd��|rtd��|	rtd��|
dk7rtd��|r|�d|��}n|}d}
|j||�rX|d	k(rtd
|�d���|dk(r8|jj	�5}|jd
|���ddd�n|dk(rd}
ddl}	|jj||��}|jj	�5}|j|||
|��}ddd�|jj�S#1swY�xYw#|j$r}td�|�d}~wwxYw#1swY�TxYw)a�
        Write records stored in a DataFrame to a SQL database.

        Parameters
        ----------
        frame : DataFrame
        name : string
            Name of SQL table.
        if_exists : {'fail', 'replace', 'append'}, default 'fail'
            - fail: If table exists, do nothing.
            - replace: If table exists, drop it, recreate it, and insert data.
            - append: If table exists, insert data. Create if does not exist.
        index : boolean, default True
            Write DataFrame index as a column.
        index_label : string or sequence, default None
            Raises NotImplementedError
        schema : string, default None
            Name of SQL schema in database to write to (if database flavor
            supports this). If specified, this overwrites the default
            schema of the SQLDatabase object.
        chunksize : int, default None
            Raises NotImplementedError
        dtype : single type or dict of column name to SQL type, default None
            Raises NotImplementedError
        method : {None', 'multi', callable}, default None
            Raises NotImplementedError
        engine : {'auto', 'sqlalchemy'}, default 'auto'
            Raises NotImplementedError if not set to 'auto'
        z1'index_label' is not implemented for ADBC driversr#z+'dtype' is not implemented for ADBC driversz,'method' is not implemented for ADBC driversr�z1engine != 'auto' not implemented for ADBC driversr)r�r�r�r�r��DROP TABLE Nror)�preserve_indexzdatatypes not supported)r�rs�mode�db_schema_name)r�r�rMr�rr�rgr)rh�ArrowNotImplementedError�adbc_ingestr)r�r�r�r�r�r�r�r�rOr�r�r�r�r=rrvr�r�r-s                   r6r�zADBCDatabase.to_sql	s���V�%�C��
��%�&W�X�X��%�&S�T�T��%�&T�U�U��V��%�C��
��"�8�1�T�F�+�J��J����>�>�$��'��F�"� �7�:�,�6G�!H�I�I��i�'��X�X�_�_�&�#��K�K�+�j�\� :�;�'�&��h�&����	A��(�(�&�&�u�U�&�C�C��X�X�_�_�
�#� �_�_��c��V�-��N��
	
��������%'�&���*�*�	A��6�7�S�@��	A���
�s0�D3�D?�9E"�3D<�?E�E�E�"E+c���|jj||��j�}|dj�D]%}|s�|D]}|s�|dD]}|d|k(s�y��'y)N)�db_schema_filter�table_name_filter�catalog_db_schemas�db_schema_tablesr�TF)r��adbc_get_objects�read_all�	to_pylist)r�r�r�r��catalog_schema�
schema_record�table_records       r6r�zADBCDatabase.has_tablej	s����x�x�(�(�#�t�)�
�
�(�*�	
�#�#7�8�B�B�D�N�!��!/�
�$��$1�2D�$E�L�#�L�1�T�9�#�%F�	"0�E�r8c��td��)Nznot implemented for adbcr�r�s      r6r�zADBCDatabase._create_sql_schema|	s��"�"<�=�=r8r�r�r�r�r�r�r�r	r�r�r�)r�r�r�r�r�rr�r�r�r�r�r�r�r�r�r8r6r�r�)s����������.-1�!���!� $�9@�e
��e
�*�e
��	e
��e
��e
�7�e
�
)�e
�T-1�!��� $�!%�9@�O
�
�O
�*�O
��	O
��O
��O
�7�O
�
)�O
�b�H�;A���!� $�!%�59��Z��Z�8�	Z�
�Z��Z��Z��Z�3�Z��Z�
�Z�x�,"&�!%�!�
>��>��>��	>�
�>��
>�

�>r8r��TEXT�REAL�INTEGERrd�DATE�TIME)rirRrSr	rr
r}c��	t|�jdd�jd�}|S#t$r}t	d|�d��|�d}~wwxYw)Nzutf-8�strictz%Cannot convert identifier to UTF-8: 'r�)r��encode�decode�UnicodeErrorrM)r��unamers   r6�_get_unicode_namerX�	s[��S��D�	� � ��(�3�:�:�7�C���L���S��@���a�H�I�s�R��S�s�*.�	A�A�Ac��t|�}t|�std��|jd�}|dk\rtd��d|j	dd�zdzS)Nz$Empty table or column name specified�rz%SQLite identifier cannot contain NULsr&z"")rXrrrM�findr�)r�rW�	nul_indexs   r6�_get_valid_sqlite_namer]�	s]��
�d�#�E��u�:��?�@�@��
�
�6�"�I��A�~��@�A�A�����s�D�)�)�C�/�/r8c�`��eZdZdZd�fd�Zdd�Zdd�Zdd�Zd
d�Zdd�Z	dd�Z
d	�Zd
�Z�xZ
S)�SQLiteTablezw
    Patch the SQLTable for fallback support.
    Instead of a table variable just use the Create Table statement.
    c�D��t�|�|i|��|j�yr�)�superr��_register_date_adapters)r�r��kwargs�	__class__s   �r6r�zSQLiteTable.__init__�	s!���
���$�)�&�)��$�$�&r8c��ddl}d	d�}d�}d�}|jt|�|jt|�|jt|�d�}d�}|jd|�|jd|�y)
Nrc�t�|jd�d|jd�d|jd�d|jd��S)N�02d�:r)�06d)�hour�minute�second�microsecond)�ts r6�_adapt_timez8SQLiteTable._register_date_adapters.<locals>._adapt_time�	s8���f�f�S�\��1�8�8�C�.��!�(�(�3��q����s�@S�T�Tr8c�"�|j�Sr���	isoformat��vals r6�<lambda>z5SQLiteTable._register_date_adapters.<locals>.<lambda>�	s
��S�]�]�_r8c�$�|jd�S)N� rqrss r6ruz5SQLiteTable._register_date_adapters.<locals>.<lambda>�	s
�����s�);r8c�H�tj|j��Sr�)r�
fromisoformatrUrss r6ruz5SQLiteTable._register_date_adapters.<locals>.<lambda>�	s��4�#5�#5�c�j�j�l�#Cr8c�H�tj|j��Sr�)r	ryrUrss r6ruz5SQLiteTable._register_date_adapters.<locals>.<lambda>�	s���(>�(>�s�z�z�|�(Lr8r�	timestampr�)r��register_adapterr
rr	�register_converter)r�r�ro�adapt_date_iso�adapt_datetime_iso�convert_date�convert_timestamps       r6rbz#SQLiteTable._register_date_adapters�	sw��	�	U�5��;��� � ��{�3�� � ��~�6�� � ��+=�>�C��L���"�"�6�<�8��"�"�;�0A�Br8c�J�tdj|j��S)Nz;
)r�r0r�r�s r6r�zSQLiteTable.sql_schema�	s���5�:�:�d�j�j�)�*�*r8c��|jj�5}|jD]}|j|��	ddd�y#1swYyxYwr�)r�r�r�r�)r�r�r�s   r6r�zSQLiteTable._execute_create�	s:��
�[�[�
(�
(�
*�d��
�
�����T�"�#�+�
*�
*�s�#A�Ac��ttt|jj��}d}t
}|j�)|jddd�D]}|jd|��|D�cgc]
}||���}}dj|�}dj|gt|�z�}	djt|�D�
cgc]}
d|	�d���
c}
�}d||j��d|�d	|��}|Scc}wcc}
w)
N�?r;r�,�(�)zINSERT INTO � (z	) VALUES )rlrr�r�rjr]r�r�r0rrrqr�)
r��num_rowsr�wld�escaper@r��bracketed_names�	col_names�
row_wildcardsr�	wildcards�insert_statements
             r6r�zSQLiteTable.insert_statement�	s����S��d�j�j�0�0�1�2����'���:�:�!��z�z�$�B�$�'�����Q��$�(�9>�>��f�6�&�>���>��H�H�_�-�	����#���U��!3�4�
��H�H�E�(�O�L�O�q��-���2�O�L�M�	��6�$�)�)�,�-�R�	�{�)�I�;�O�	� ���?��Ms�/C8�
C=c�t�t|�}|j|jd��|�|jS)Nr"�r�)rl�executemanyr�r�)r�r�r�r�rs     r6r�zSQLiteTable._execute_insert�	s3����O�	�����.�.��.�:�I�F��}�}�r8c���t|�}|D��cgc]}|D]}|���
}}}|j|jt|���|�|jScc}}w)Nr�)rlr�r�rrr�)r�r�r�r�rr�r'�flattened_datas        r6r�z!SQLiteTable._execute_insert_multi�	sV����O�	�'0�>�y��#�Q�!�#�!�y��>����T�*�*�C�	�N�*�C�^�T��}�}���?s�Ac���|j|j�}t}|D���cgc]\}}}||�dz|z��}}}}|j��t	|j�rvt|j�s|jg}n|j}dj
|D�cgc]
}||���c}�}	|jd|j�d|	�d��|jr|jdz}
nd}
d|
z||j�zd	zd
j
|�zdzg}|D���cgc]\}}}|s�
|��
}
}}}t	|
�r�dj
|
�}d
j
|
D�cgc]
}||���c}�}	|jd|d|jzdz|z�zdz||j�zdz|	zdz�|Scc}}}wcc}wcc}}}wcc}w)z�
        Return a list of SQL statements that creates a table reflecting the
        structure of a DataFrame.  The first entry will be a CREATE TABLE
        statement while the rest will be CREATE INDEX statements.
        rwr$zCONSTRAINT z_pk PRIMARY KEY (r�r)r�z
CREATE TABLE z (
z,
  z
)rr�z
CREATE INDEX �ix_zON r�)
rN�_sql_type_namer]r�rrrr0ror�r�)r�rKr��cname�ctyper�create_tbl_stmtsr�r<�	cnames_br�schema_name�create_stmtsrW�ix_cols�cnamess               r6r�zSQLiteTable._create_table_setup�	s��"&�!A�!A�$�BU�BU�!V��'��@V�
�?U�O�E�5�!�F�5�M�C��%�'�?U�	�
��9�9� �S����^���	�	�*��	�	�{���y�y���	�	�d�";�d��6�!�9�d�";�<�I��#�#��d�i�i�[�(9�)��A�F�
��;�;��+�+��+�K��K���
��T�Y�Y��
 ��
��l�l�+�,�	
-�
�
�
��4J�V�3I�/�U�A�x�X�5�3I��V��w�<��X�X�g�&�F����W�!=�W��&��)�W�!=�>�I����������*�S�0�6�9�:�;�������#�$��	�
���
�
����Q
��#<��"W��">s�G�$G�1G �=G �0G'c�~�|jxsi}t|�r-tt|�}|j|vr||jStj|d��}|dk(r'tjdtt���d}n |dk(rd}n|d	k(rd
}n|dk(rtd��|tvrd
}t|S)
NTrbrqrrr�rSrnr	�emptyrir~r)
rOrrrJr�rr�r�r�r�rrM�
_SQL_TYPES)r�rTrOr`s    r6r�zSQLiteTable._sql_type_name/
s����*�*�*��������u�%�E��x�x�5� ��S�X�X��&��?�?�3�t�4���}�$��M�M�L��+�-�	
�!�H�
��
%�!�H�
��
 ��H�
��
"��>�?�?��:�%��H��(�#�#r8r�r�)r�r�r�r�)r�r�)r�r�r�r�r�rbr�r�r�r�r�r�r��
__classcell__)rds@r6r_r_�	s7����
'�
C�:+�#�
 �&�
�1�f $r8r_c��eZdZdZdd�Zed��Zddd�Ze					d							dd��Z								d									dd�Z
d�Z								d															dd	�Zddd
�Z
ddd�Zddd�Z			d							dd
�Zy)r�z�
    Version of SQLDatabase to support SQLite connections (fallback without
    SQLAlchemy). This should only be used internally.

    Parameters
    ----------
    con : sqlite connection object

    c��||_yr�rrs  r6r�zSQLiteDatabase.__init__]
rr8c#�K�|jj�}	|��|jj�	|j�y#t$r|jj	��wxYw#|j�wxYw�wr�)r�rrr�rr�rs  r6r�zSQLiteDatabase.run_transaction`
sh�����h�h�o�o���	��I��H�H�O�O��

�I�I�K��	�	��H�H�����	��
�I�I�K�s'�B�A�B�%A3�3A6�6B�BNc	�t�t|t�std��|�gn|g}|jj	�}	|j
|g|���|S#t$r[}	|jj�n&#t$r}td|�d|�d��}||�d}~wwxYwtd|�d|���}||�d}~wwxYwrrrs        r6r�zSQLiteDatabase.executel
rr c	#�"K�d}	|j|�}	t|	�tk(rt|	�}	|	sB|j	�|s/tjg||��}
|r|
j|�}
|
��yd}t|	||||||�������w)r�FTr1r�N)	r3rP�tuplerlr�r r4r~r�)rr�rjr�rer5rOrfr7rsr�s           r6r8zSQLiteDatabase._query_iterator�
s������
���#�#�I�.�D��D�z�U�"��D�z�������$�&�3�3��G�,��F��!'���u�!5�� �L�� �M����#�)�'��+��
�!�s�B
Bc	
��|j||�}	|	jD�
cgc]}
|
d��	}}
|�|j|	|||||||��S|j|	�}|	j	�t|||||||��}
|
Scc}
w)Nrr�)r��descriptionr8�_fetchall_as_listr�r�)r�r�r�rer5r�r�rOrfr�col_descrjrsr�s              r6r�zSQLiteDatabase.read_query�
s������c�6�*��/5�/A�/A�B�/A�8�8�A�;�/A��B�� ��'�'����#�)�'��+�(�	�	
��)�)�&�1�D��L�L�N� ���#�)�'��+��E��L��5Cs�A?c�\�|j�}t|t�st|�}|Sr�)r=rIrl)r�rr�s   r6r�z SQLiteDatabase._fetchall_as_list�
s%��������&�$�'��&�\�F��
r8c	�B�|ret|�s|D�cic]}||��}}ntt|�}|j�D]&\}
}t	|t
�r�t
|
�d|�d���t|||||||��}|j�|j||	�Scc}w)a@
        Write records stored in a DataFrame to a SQL database.

        Parameters
        ----------
        frame: DataFrame
        name: string
            Name of SQL table.
        if_exists: {'fail', 'replace', 'append'}, default 'fail'
            fail: If table exists, do nothing.
            replace: If table exists, drop it, recreate it, and insert data.
            append: If table exists, insert data. Create if it does not exist.
        index : bool, default True
            Write DataFrame index as a column
        index_label : string or sequence, default None
            Column label for index column(s). If None is given (default) and
            `index` is True, then the index names are used.
            A sequence should be given if the DataFrame uses MultiIndex.
        schema : string, default None
            Ignored parameter included for compatibility with SQLAlchemy
            version of ``to_sql``.
        chunksize : int, default None
            If not None, then rows will be written in batches of this
            size at a time. If None, all rows will be written at once.
        dtype : single type or dict of column name to SQL type, default None
            Optional specifying the datatype for columns. The SQL type should
            be a string. If all columns are of the same type, one single value
            can be used.
        method : {None, 'multi', callable}, default None
            Controls the SQL insertion clause used:

            * None : Uses standard SQL ``INSERT`` clause (one per row).
            * 'multi': Pass multiple values in a single ``INSERT`` clause.
            * callable with signature ``(pd_table, conn, keys, data_iter)``.

            Details and a sample callable implementation can be found in the
            section :ref:`insert method <io.sql.method>`.
        r�z) not a string)r�r�r�r�rO)
rrrJrZrIr�rMr_r�r�)r�r�r�r�r�r�r�r�rOr�r�r�r_rTr�r�s                r6r�zSQLiteDatabase.to_sql�
s���h���&�:?�?��X��5����?��T�5�)�� %���
���W�!�'�3�/�$��u�B�w�i�~�%F�G�G�!.�������#��
��	�����|�|�I�v�.�.��%@s�
Bc�l�d}d|�d�}t|j||g�j��dkDS)Nr�z�
        SELECT
            name
        FROM
            sqlite_master
        WHERE
            type IN ('table', 'view')
            AND name=z
;
        r)rrr�r=)r�r�r�r��querys     r6r�zSQLiteDatabase.has_table%sG������U�	����4�<�<���v�.�7�7�9�:�Q�>�>r8c��yr�r�rs   r6r�zSQLiteDatabase.get_table3s��r8c�B�dt|���}|j|�y)Nr;)r]r�)r�r�r��drop_sqls    r6r�zSQLiteDatabase.drop_table6s!�� �!7��!=� >�?�����X�r8c	�X�t|||d|||��}t|j��Sr)r_r�r�rs       r6r�z!SQLiteDatabase._create_sql_schema:s9����������
���5�#�#�%�&�&r8r�r�r�r)r�r�rer^rOr�rfr�r�)
rer^r�r�rOr�rfr�r�r�r�)r�r�r�r�r�r^r�r�rOr�r�r�r�r�r�r�r�r
rr�)r�r�rOr�r�r�r�r�)r�r�r�r�r�rr�r�rr8r�r�r�r�r�r�r�r�r8r6r�r�R
s������	��	��(�
�!��!%�9@�$��$�
�$��$�7�$��$�R�!��� $�!%�9@�&��	&��&��&�7�&�
)�&�P� ���� $�!%�59��N/��N/��	N/�
�N/��N/��N/�3�N/��N/�
�N/�`?����!%�!�
'��'�
�'��
'�

�'r8r�c�r�t|��5}|j|||||��cddd�S#1swYyxYw)a]
    Get the SQL db table schema for the given frame.

    Parameters
    ----------
    frame : DataFrame
    name : str
        name of SQL table
    keys : string or sequence, default: None
        columns to use a primary key
    con: ADBC Connection, SQLAlchemy connectable, sqlite3 connection, default: None
        ADBC provides high performance I/O with native type support, where available.
        Using SQLAlchemy makes it possible to use any DB supported by that
        library
        If a DBAPI2 object, only sqlite3 is supported.
    dtype : dict of column name to SQL type, default None
        Optional specifying the datatype for columns. The SQL type should
        be a SQLAlchemy type, or a string for sqlite3 fallback connection.
    schema: str, default: None
        Optional specifying the schema to be used in creating the table.
    r)r�rOr�N)r�r�)r�r�r�r�rOr�r�s       r6�
get_schemar�Ns8��:
�s�	#�z��,�,��4�d�%��-�
�
$�	#�	#�s�-�6)FN)rFr^rHzstr | dict[str, Any] | None)Trc)rer^rfr�r�r r)rer^rOr�rfr�)rzr rOr�rfr�r�r r�).......)r�r�r�r�r5�!list[str] | dict[str, str] | Nonerjr�r�r�rf�DtypeBackend | lib.NoDefaultr�r )r�r�r�r�r5r�rjr�r�r�rfr�r��Iterator[DataFrame])r�r�r�r�r�r�rer^r5r�rjr�r�r�rfr�r�r�)r�r�r��$list[Any] | Mapping[str, Any] | Noner5r�r�r�rOr�rfr�r�r )r�r�r�r�r5r�r�r�rOr�rfr�r�r�)r�r�rer^r�r�r5r�r�r�rOr�rfr�r�r�).......N)r�r�rjr�r�r�rfr�rOr�r�r )r�r�rjr�r�r�rfr�rOr�r�r�)r�r�rer^rjr�r�r�rfr�rOr�r�r�)Nr�TNNNNr�)r�r�r�r�r�r�r�r^r�zIndexLabel | Noner�r�rOr�r�r�r�r�r�r�)r�r�r�r�r�r^r)r�r�r�r^r�r�)r�r�r�r�)r�r
)NNNN)r�r�rOr�r�r�r�r�)kr��
__future__r�abcrr�
contextlibrrr	rr
�	functoolsrr��typingrr
rrrrr�rcrQ�pandas._configr�pandas._libsr�pandas.compat._optionalr�
pandas.errorsrr�pandas.util._exceptionsr�pandas.util._validatorsr�pandas.core.dtypes.commonrr�pandas.core.dtypes.dtypesrr�pandas.core.dtypes.missingrr�r�pandas.core.apir r!�pandas.core.arraysr"�pandas.core.baser#�pandas.core.common�core�commonrEr$�"pandas.core.internals.constructionr%�pandas.core.tools.datetimesr&�collections.abcr'r(r�r)�sqlalchemy.sql.expressionr*r+�pandas._typingr,r-r.r/r0r1r7rVrbr{r�r�r�r�r�r�r�r�r��table_existsr�r�r�r�r�r�r�r�r�rXr]r_r�r�r�r8r6�<module>r�s���
#�����
�	�����5��>��5�7���,���3�)� � �.�C�3���
!��
����CG�M��M�$?�M�D�0�5<�	*��*�3�	*�
�*�J���!�5<���	��
�3��4��!�5<�
���
��3�
���(/�F
��(+��58� #��25����&�	�3�
�����0����
��
��(+��58� #��25����&�	�3�
�����0����
��"�(,��59� $� �25�.�.�c?��c?�
�c?�&�	c?�
�c?�3�
c?��c?��c?�0�c?�%�c?�L
�),��36�58�� �25��&��

1��3�
�����0����
��
�),��36�58�� �25��&��

1��3�
�����0����
��")-��37�59� �!�25�.�.�e
�&�e
��	e
�

1�e
�3�
e
��e
��e
�0�e
�%�e
�P
�),������25�!��&������0������
��
�),������25�!��&������0������
��$)-���� $� �25�.�.�!�m�&�m��	m��m��m�0�m��m�%�m�h�6<��%)� �!�15��l
�

�l
�
�	l
�
4�l
��
l
�#�l
��l
��l
�
/�l
�
�l
��l
�^0�2��
�"�"��"��"��	"�JF�|�F�RH
��c�H
�V(�(�&�z��BC�@a'�)�a'�N[>�9�[>�B��������
��0�$a$�(�a$�Hy'�Y�y'�~
��!��
 
�

� 
�
� 
�
�
 
�	� 
r8

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists