Home-AssistantConfig/deps/sqlalchemy/dialects/sqlite/__pycache__/pysqlite.cpython-34.pyc

<EFBFBD>
}<7D><>W<EFBFBD>:<00>@s<>dZd
dl
mZmZmZ
d
dlmZmZ
d
dlmZ	
d
dlm
Z

d
dlZGdd<00>de<00>ZGd	d
<00>d
e<00>Z
Gdd<00>de<00>ZeZdS)
a<>+
.. dialect:: sqlite+pysqlite
    :name: pysqlite
    :dbapi: sqlite3
    :connectstring: sqlite+pysqlite:///file_path
    :url: http://docs.python.org/library/sqlite3.html

    Note that ``pysqlite`` is the same driver as the ``sqlite3``
    module included with the Python distribution.

Driver
------

When using Python 2.5 and above, the built in ``sqlite3`` driver is
already installed and no additional installation is needed.  Otherwise,
the ``pysqlite2`` driver needs to be present.  This is the same driver as
``sqlite3``, just with a different name.

The ``pysqlite2`` driver will be loaded first, and if not found, ``sqlite3``
is loaded.  This allows an explicitly installed pysqlite driver to take
precedence over the built in one.   As with all dialects, a specific
DBAPI module may be provided to :func:`~sqlalchemy.create_engine()` to control
this explicitly::

    from sqlite3 import dbapi2 as sqlite
    e = create_engine('sqlite+pysqlite:///file.db', module=sqlite)


Connect Strings
---------------

The file specification for the SQLite database is taken as the "database"
portion of the URL.  Note that the format of a SQLAlchemy url is::

    driver://user:pass@host/database

This means that the actual filename to be used starts with the characters to
the **right** of the third slash.   So connecting to a relative filepath
looks like::

    # relative path
    e = create_engine('sqlite:///path/to/database.db')

An absolute path, which is denoted by starting with a slash, means you
need **four** slashes::

    # absolute path
    e = create_engine('sqlite:////path/to/database.db')

To use a Windows path, regular drive specifications and backslashes can be
used. Double backslashes are probably needed::

    # absolute path on Windows
    e = create_engine('sqlite:///C:\\path\\to\\database.db')

The sqlite ``:memory:`` identifier is the default if no filepath is
present.  Specify ``sqlite://`` and nothing else::

    # in-memory database
    e = create_engine('sqlite://')

Compatibility with sqlite3 "native" date and datetime types
-----------------------------------------------------------

The pysqlite driver includes the sqlite3.PARSE_DECLTYPES and
sqlite3.PARSE_COLNAMES options, which have the effect of any column
or expression explicitly cast as "date" or "timestamp" will be converted
to a Python date or datetime object.  The date and datetime types provided
with the pysqlite dialect are not currently compatible with these options,
since they render the ISO date/datetime including microseconds, which
pysqlite's driver does not.   Additionally, SQLAlchemy does not at
this time automatically render the "cast" syntax required for the
freestanding functions "current_timestamp" and "current_date" to return
datetime/date types natively.   Unfortunately, pysqlite
does not provide the standard DBAPI types in ``cursor.description``,
leaving SQLAlchemy with no way to detect these types on the fly
without expensive per-row type checks.

Keeping in mind that pysqlite's parsing option is not recommended,
nor should be necessary, for use with SQLAlchemy, usage of PARSE_DECLTYPES
can be forced if one configures "native_datetime=True" on create_engine()::

    engine = create_engine('sqlite://',
        connect_args={'detect_types':
            sqlite3.PARSE_DECLTYPES|sqlite3.PARSE_COLNAMES},
        native_datetime=True
    )

With this flag enabled, the DATE and TIMESTAMP types (but note - not the
DATETIME or TIME types...confused yet ?) will not perform any bind parameter
or result processing. Execution of "func.current_date()" will return a string.
"func.current_timestamp()" is registered as returning a DATETIME type in
SQLAlchemy, so this function still receives SQLAlchemy-level result
processing.

.. _pysqlite_threading_pooling:

Threading/Pooling Behavior
---------------------------

Pysqlite's default behavior is to prohibit the usage of a single connection
in more than one thread.   This is originally intended to work with older
versions of SQLite that did not support multithreaded operation under
various circumstances.  In particular, older SQLite versions
did not allow a ``:memory:`` database to be used in multiple threads
under any circumstances.

Pysqlite does include a now-undocumented flag known as
``check_same_thread`` which will disable this check, however note that
pysqlite connections are still not safe to use in concurrently in multiple
threads.  In particular, any statement execution calls would need to be
externally mutexed, as Pysqlite does not provide for thread-safe propagation
of error messages among other things.   So while even ``:memory:`` databases
can be shared among threads in modern SQLite, Pysqlite doesn't provide enough
thread-safety to make this usage worth it.

SQLAlchemy sets up pooling to work with Pysqlite's default behavior:

* When a ``:memory:`` SQLite database is specified, the dialect by default
  will use :class:`.SingletonThreadPool`. This pool maintains a single
  connection per thread, so that all access to the engine within the current
  thread use the same ``:memory:`` database - other threads would access a
  different ``:memory:`` database.
* When a file-based database is specified, the dialect will use
  :class:`.NullPool` as the source of connections. This pool closes and
  discards connections which are returned to the pool immediately. SQLite
  file-based connections have extremely low overhead, so pooling is not
  necessary. The scheme also prevents a connection from being used again in
  a different thread and works best with SQLite's coarse-grained file locking.

  .. versionchanged:: 0.7
      Default selection of :class:`.NullPool` for SQLite file-based databases.
      Previous versions select :class:`.SingletonThreadPool` by
      default for all SQLite databases.


Using a Memory Database in Multiple Threads
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

To use a ``:memory:`` database in a multithreaded scenario, the same
connection object must be shared among threads, since the database exists
only within the scope of that connection.   The
:class:`.StaticPool` implementation will maintain a single connection
globally, and the ``check_same_thread`` flag can be passed to Pysqlite
as ``False``::

    from sqlalchemy.pool import StaticPool
    engine = create_engine('sqlite://',
                        connect_args={'check_same_thread':False},
                        poolclass=StaticPool)

Note that using a ``:memory:`` database in multiple threads requires a recent
version of SQLite.

Using Temporary Tables with SQLite
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Due to the way SQLite deals with temporary tables, if you wish to use a
temporary table in a file-based SQLite database across multiple checkouts
from the connection pool, such as when using an ORM :class:`.Session` where
the temporary table should continue to remain after :meth:`.Session.commit` or
:meth:`.Session.rollback` is called, a pool which maintains a single
connection must be used.   Use :class:`.SingletonThreadPool` if the scope is
only needed within the current thread, or :class:`.StaticPool` is scope is
needed within multiple threads for this case::

    # maintain the same connection per thread
    from sqlalchemy.pool import SingletonThreadPool
    engine = create_engine('sqlite:///mydb.db',
                        poolclass=SingletonThreadPool)


    # maintain the same connection across all threads
    from sqlalchemy.pool import StaticPool
    engine = create_engine('sqlite:///mydb.db',
                        poolclass=StaticPool)

Note that :class:`.SingletonThreadPool` should be configured for the number
of threads that are to be used; beyond that number, connections will be
closed out in a non deterministic way.

Unicode
-------

The pysqlite driver only returns Python ``unicode`` objects in result sets,
never plain strings, and accommodates ``unicode`` objects within bound
parameter values in all cases.   Regardless of the SQLAlchemy string type in
use, string-based result values will by Python ``unicode`` in Python 2.
The :class:`.Unicode` type should still be used to indicate those columns that
require unicode, however, so that non-``unicode`` values passed inadvertently
will emit a warning.  Pysqlite will emit an error if a non-``unicode`` string
is passed containing non-ASCII characters.

.. _pysqlite_serializable:

Serializable isolation / Savepoints / Transactional DDL
-------------------------------------------------------

In the section :ref:`sqlite_concurrency`, we refer to the pysqlite
driver's assortment of issues that prevent several features of SQLite
from working correctly.  The pysqlite DBAPI driver has several
long-standing bugs which impact the correctness of its transactional
behavior.   In its default mode of operation, SQLite features such as
SERIALIZABLE isolation, transactional DDL, and SAVEPOINT support are
non-functional, and in order to use these features, workarounds must
be taken.

The issue is essentially that the driver attempts to second-guess the user's
intent, failing to start transactions and sometimes ending them prematurely, in
an effort to minimize the SQLite databases's file locking behavior, even
though SQLite itself uses "shared" locks for read-only activities.

SQLAlchemy chooses to not alter this behavior by default, as it is the
long-expected behavior of the pysqlite driver; if and when the pysqlite
driver attempts to repair these issues, that will be more of a driver towards
defaults for SQLAlchemy.

The good news is that with a few events, we can implement transactional
support fully, by disabling pysqlite's feature entirely and emitting BEGIN
ourselves. This is achieved using two event listeners::

    from sqlalchemy import create_engine, event

    engine = create_engine("sqlite:///myfile.db")

    @event.listens_for(engine, "connect")
    def do_connect(dbapi_connection, connection_record):
        # disable pysqlite's emitting of the BEGIN statement entirely.
        # also stops it from emitting COMMIT before any DDL.
        dbapi_connection.isolation_level = None

    @event.listens_for(engine, "begin")
    def do_begin(conn):
        # emit our own BEGIN
        conn.execute("BEGIN")

Above, we intercept a new pysqlite connection and disable any transactional
integration.   Then, at the point at which SQLAlchemy knows that transaction
scope is to begin, we emit ``"BEGIN"`` ourselves.

When we take control of ``"BEGIN"``, we can also control directly SQLite's
locking modes, introduced at `BEGIN TRANSACTION <http://sqlite.org/lang_transaction.html>`_,
by adding the desired locking mode to our ``"BEGIN"``::

    @event.listens_for(engine, "begin")
    def do_begin(conn):
        conn.execute("BEGIN EXCLUSIVE")

.. seealso::

    `BEGIN TRANSACTION <http://sqlite.org/lang_transaction.html>`_ - on the SQLite site

    `sqlite3 SELECT does not BEGIN a transaction <http://bugs.python.org/issue9924>`_ - on the Python bug tracker

    `sqlite3 module breaks transactions and potentially corrupts data <http://bugs.python.org/issue10740>`_ - on the Python bug tracker


<EFBFBD>)<03>
SQLiteDialect<63>DATETIME<4D>DATE)<02>exc<78>pool)
<01>types)
<01>utilNc@s(eZ
dZd
d<00>Zdd<00>ZdS)<06>_SQLite_pysqliteTimeStampcCs!|
jr
dSt
j||
<00>SdS)
N)<03>native_datetimer<00>bind_processor)<02>self<6C>dialect<63>r<00>I/tmp/pip-build-zkr322cu/sqlalchemy/sqlalchemy/dialects/sqlite/pysqlite.pyr
s
	
z(_SQLite_pysqliteTimeStamp.bind_processorcCs$|
jr
dSt
j||
|<00>SdS)
N)r
r<00>result_processor)rr
<00>coltyperrrr
s
	
z*_SQLite_pysqliteTimeStamp.result_processorN)<05>__name__<5F>
__module__<EFBFBD>__qualname__rrrrrrr	
s
r	c@s(eZ
dZd
d<00>Zdd<00>ZdS)<06>_SQLite_pysqliteDatecCs!|
jr
dSt
j||
<00>SdS)
N)r
rr)rr
rrrr"
s
	
z#_SQLite_pysqliteDate.bind_processorcCs$|
jr
dSt
j||
|<00>SdS)
N)r
rr)rr
rrrrr(
s
	
z%_SQLite_pysqliteDate.result_processorN)rrrrrrrrrr!
s
rc@s<>eZ
dZd
Zejejiee	j
6ee	j6<>Zej
sMdZndZdd<00>Zedd<00><00>
Zedd	<00><00>
Zd
d<00>Zdd
<00>Zdd<00>ZdS)<10>SQLiteDialect_pysqliteZqmarkNZpysqlitec
Kshtj
||
<00>

|jdk	rd|jj}|dkrdtjddjdd<00>|D<>
<00>
<16>

qdndS)	N<><00>
<00>z<>The installed version of pysqlite2 (%s) is out-dated and will cause errors in some cases.  Version 2.1.3 or greater is recommended.<2E>
.c
Ssg|]}
t|
<00>
<00>qSr)
<01>str)<02>.0Zsubverrrr<00>
<listcomp>I
s	z3SQLiteDialect_pysqlite.__init__.<locals>.<listcomp>)rrr)r<00>__init__<5F>dbapi<70>version_infor<00>warn<72>join)r<00>kwargsZ
sqlite_verrrrr?
s




zSQLiteDialect_pysqlite.__init__c
Csoyd
dlm
}

WnTtk
rj
}
z4yd
dlm
}

Wntk
rW


|<00>
Yn
XWYdd}~Xn
X|
S)Nr
)
<01>dbapi2)Z	pysqlite2r$<00>ImportErrorZsqlite3)<03>clsZsqlite<74>
errrrK
s







zSQLiteDialect_pysqlite.dbapicCs*|
jr|
jd
krt
jSt
jSdS)Nz:memory:)<04>databaserZNullPoolZSingletonThreadPool)r&<00>urlrrr<00>get_pool_classV
s
z%SQLiteDialect_pysqlite.get_pool_classc
Cs
|jj
S)
N)rZsqlite_version_info)r<00>
connectionrrr<00>_get_server_version_info]
s
z/SQLiteDialect_pysqlite._get_server_version_infocCs<>|
js$|
j
s$|
js$|
jr=tjd
|
f
<16>
<00>
n|
jpId}|dkrmtjj	|<00>
}n|
j
j<00>}tj
|dt<00>
tj
|dt<00>
tj
|dt<00>
tj
|dt<00>
tj
|dt<00>
|g
|fS)Nz<4E>Invalid SQLite URL: %s
Valid SQLite URL forms are:
 sqlite:///:memory: (or, sqlite://)
 sqlite:///relative/path/to/file.db
 sqlite:////absolute/path/to/file.dbz:memory:<3A>timeoutZisolation_levelZdetect_typesZcheck_same_threadZcached_statements)<12>username<6D>password<72>host<73>portr<00>
ArgumentErrorr(<00>os<6F>path<74>abspath<74>query<72>copyrZcoerce_kw_type<70>floatr<00>int<6E>bool)rr)<00>filename<6D>optsrrr<00>create_connect_args`
s
$









z*SQLiteDialect_pysqlite.create_connect_argscCs%t|
|j
j<00>o$d
t|
<00>
kS)Nz$Cannot operate on a closed database.)<04>
isinstancerZProgrammingErrorr)rr'r+<00>cursorrrr<00>
is_disconnectu
s

z$SQLiteDialect_pysqlite.is_disconnect)rrrZdefault_paramstylerZupdate_copyrZcolspecsr<00>sqltypesZDater	Z	TIMESTAMPZpy2kZdescription_encodingZdriverr<00>classmethodrr*r,r=r@rrrrr/
s





	
	r)<10>__doc__Zsqlalchemy.dialects.sqlite.baserrrZ
sqlalchemyrrrrArr3r	rrr
rrrr<00><module>	
s


J