H`Tc@sdZddlZddlZddlmZddlmZmZddlmZm Z ddlm Z ddl m Z mZdd lmZdd lmZmZmZmZmZmZmZmZmZmZmZmZmZd efd YZd eejfdYZ deej!fdYZdeej"fdYZ#ieej!6e ej6e#ej"6Z$iej%d6ejd6ejd6ejd6ejd6ejd6ej d 6ejd6ejd6ejd6ejd6ejd6ejd6ejd6ejd6ejd 6ej#d6ejd!6ejd"6ej&d#6ej'd$6Z(d%ej)fd&YZ*d'ej+fd(YZ,d)ej-fd*YZ.d+ej/fd,YZ0d-e j1fd.YZ2d/e j3fd0YZ4d1Z5dS(2s( .. dialect:: sqlite :name: SQLite Date and Time Types ------------------- SQLite does not have built-in DATE, TIME, or DATETIME types, and pysqlite does not provide out of the box functionality for translating values between Python `datetime` objects and a SQLite-supported format. SQLAlchemy's own :class:`~sqlalchemy.types.DateTime` and related types provide date formatting and parsing functionality when SQlite is used. The implementation classes are :class:`~.sqlite.DATETIME`, :class:`~.sqlite.DATE` and :class:`~.sqlite.TIME`. These types represent dates and times as ISO formatted strings, which also nicely support ordering. There's no reliance on typical "libc" internals for these functions so historical dates are fully supported. .. _sqlite_autoincrement: SQLite Auto Incrementing Behavior ---------------------------------- Background on SQLite's autoincrement is at: http://sqlite.org/autoinc.html Two things to note: * The AUTOINCREMENT keyword is **not** required for SQLite tables to generate primary key values automatically. AUTOINCREMENT only means that the algorithm used to generate ROWID values should be slightly different. * SQLite does **not** generate primary key (i.e. ROWID) values, even for one column, if the table has a composite (i.e. multi-column) primary key. This is regardless of the AUTOINCREMENT keyword being present or not. To specifically render the AUTOINCREMENT keyword on the primary key column when rendering DDL, add the flag ``sqlite_autoincrement=True`` to the Table construct:: Table('sometable', metadata, Column('id', Integer, primary_key=True), sqlite_autoincrement=True) .. _sqlite_concurrency: Database Locking Behavior / Concurrency --------------------------------------- SQLite is not designed for a high level of write concurrency. The database itself, being a file, is locked completely during write operations within transactions, meaning exactly one "connection" (in reality a file handle) has exclusive access to the database during this period - all other "connections" will be blocked during this time. The Python DBAPI specification also calls for a connection model that is always in a transaction; there is no ``connection.begin()`` method, only ``connection.commit()`` and ``connection.rollback()``, upon which a new transaction is to be begun immediately. This may seem to imply that the SQLite driver would in theory allow only a single filehandle on a particular database file at any time; however, there are several factors both within SQlite itself as well as within the pysqlite driver which loosen this restriction significantly. However, no matter what locking modes are used, SQLite will still always lock the database file once a transaction is started and DML (e.g. INSERT, UPDATE, DELETE) has at least been emitted, and this will block other transactions at least at the point that they also attempt to emit DML. By default, the length of time on this block is very short before it times out with an error. This behavior becomes more critical when used in conjunction with the SQLAlchemy ORM. SQLAlchemy's :class:`.Session` object by default runs within a transaction, and with its autoflush model, may emit DML preceding any SELECT statement. This may lead to a SQLite database that locks more quickly than is expected. The locking mode of SQLite and the pysqlite driver can be manipulated to some degree, however it should be noted that achieving a high degree of write-concurrency with SQLite is a losing battle. For more information on SQLite's lack of write concurrency by design, please see `Situations Where Another RDBMS May Work Better - High Concurrency `_ near the bottom of the page. The following subsections introduce areas that are impacted by SQLite's file-based architecture and additionally will usually require workarounds to work when using the pysqlite driver. Transaction Isolation Level =========================== SQLite supports "transaction isolation" in a non-standard way, along two axes. One is that of the `PRAGMA read_uncommitted `_ instruction. This setting can essentially switch SQLite between its default mode of ``SERIALIZABLE`` isolation, and a "dirty read" isolation mode normally referred to as ``READ UNCOMMITTED``. SQLAlchemy ties into this PRAGMA statement using the :paramref:`.create_engine.isolation_level` parameter of :func:`.create_engine`. Valid values for this parameter when used with SQLite are ``"SERIALIZABLE"`` and ``"READ UNCOMMITTED"`` corresponding to a value of 0 and 1, respectively. SQLite defaults to ``SERIALIZABLE``, however its behavior is impacted by the pysqlite driver's default behavior. The other axis along which SQLite's transactional locking is impacted is via the nature of the ``BEGIN`` statement used. The three varieties are "deferred", "immediate", and "exclusive", as described at `BEGIN TRANSACTION `_. A straight ``BEGIN`` statement uses the "deferred" mode, where the the database file is not locked until the first read or write operation, and read access remains open to other transactions until the first write operation. But again, it is critical to note that the pysqlite driver interferes with this behavior by *not even emitting BEGIN* until the first write operation. .. warning:: SQLite's transactional scope is impacted by unresolved issues in the pysqlite driver, which defers BEGIN statements to a greater degree than is often feasible. See the section :ref:`pysqlite_serializable` for techniques to work around this behavior. SAVEPOINT Support ================= SQLite supports SAVEPOINTs, which only function once a transaction is begun. SQLAlchemy's SAVEPOINT support is available using the :meth:`.Connection.begin_nested` method at the Core level, and :meth:`.Session.begin_nested` at the ORM level. However, SAVEPOINTs won't work at all with pysqlite unless workarounds are taken. .. warning:: SQLite's SAVEPOINT feature is impacted by unresolved issues in the pysqlite driver, which defers BEGIN statements to a greater degree than is often feasible. See the section :ref:`pysqlite_serializable` for techniques to work around this behavior. Transactional DDL ================= The SQLite database supports transactional :term:`DDL` as well. In this case, the pysqlite driver is not only failing to start transactions, it also is ending any existing transction when DDL is detected, so again, workarounds are required. .. warning:: SQLite's transactional DDL is impacted by unresolved issues in the pysqlite driver, which fails to emit BEGIN and additionally forces a COMMIT to cancel any transaction when DDL is encountered. See the section :ref:`pysqlite_serializable` for techniques to work around this behavior. .. _sqlite_foreign_keys: Foreign Key Support ------------------- SQLite supports FOREIGN KEY syntax when emitting CREATE statements for tables, however by default these constraints have no effect on the operation of the table. Constraint checking on SQLite has three prerequisites: * At least version 3.6.19 of SQLite must be in use * The SQLite library must be compiled *without* the SQLITE_OMIT_FOREIGN_KEY or SQLITE_OMIT_TRIGGER symbols enabled. * The ``PRAGMA foreign_keys = ON`` statement must be emitted on all connections before use. SQLAlchemy allows for the ``PRAGMA`` statement to be emitted automatically for new connections through the usage of events:: from sqlalchemy.engine import Engine from sqlalchemy import event @event.listens_for(Engine, "connect") def set_sqlite_pragma(dbapi_connection, connection_record): cursor = dbapi_connection.cursor() cursor.execute("PRAGMA foreign_keys=ON") cursor.close() .. seealso:: `SQLite Foreign Key Support `_ - on the SQLite web site. :ref:`event_toplevel` - SQLAlchemy event API. .. _sqlite_type_reflection: Type Reflection --------------- SQLite types are unlike those of most other database backends, in that the string name of the type usually does not correspond to a "type" in a one-to-one fashion. Instead, SQLite links per-column typing behavior to one of five so-called "type affinities" based on a string matching pattern for the type. SQLAlchemy's reflection process, when inspecting types, uses a simple lookup table to link the keywords returned to provided SQLAlchemy types. This lookup table is present within the SQLite dialect as it is for all other dialects. However, the SQLite dialect has a different "fallback" routine for when a particular type name is not located in the lookup map; it instead implements the SQLite "type affinity" scheme located at http://www.sqlite.org/datatype3.html section 2.1. The provided typemap will make direct associations from an exact string name match for the following types: :class:`~.types.BIGINT`, :class:`~.types.BLOB`, :class:`~.types.BOOLEAN`, :class:`~.types.BOOLEAN`, :class:`~.types.CHAR`, :class:`~.types.DATE`, :class:`~.types.DATETIME`, :class:`~.types.FLOAT`, :class:`~.types.DECIMAL`, :class:`~.types.FLOAT`, :class:`~.types.INTEGER`, :class:`~.types.INTEGER`, :class:`~.types.NUMERIC`, :class:`~.types.REAL`, :class:`~.types.SMALLINT`, :class:`~.types.TEXT`, :class:`~.types.TIME`, :class:`~.types.TIMESTAMP`, :class:`~.types.VARCHAR`, :class:`~.types.NVARCHAR`, :class:`~.types.NCHAR` When a type name does not match one of the above types, the "type affinity" lookup is used instead: * :class:`~.types.INTEGER` is returned if the type name includes the string ``INT`` * :class:`~.types.TEXT` is returned if the type name includes the string ``CHAR``, ``CLOB`` or ``TEXT`` * :class:`~.types.NullType` is returned if the type name includes the string ``BLOB`` * :class:`~.types.REAL` is returned if the type name includes the string ``REAL``, ``FLOA`` or ``DOUB``. * Otherwise, the :class:`~.types.NUMERIC` type is used. .. versionadded:: 0.9.3 Support for SQLite type affinity rules when reflecting columns. iNi(t processors(tsqltexc(ttypestschema(tutil(tdefaultt reflection(tcompiler( tBLOBtBOOLEANtCHARtDATEtDECIMALtFLOATtINTEGERtREALtNUMERICtSMALLINTtTEXTt TIMESTAMPtVARCHARt_DateTimeMixincBs5eZdZdZdddZdZdZRS(cKsStt|j||dk r7tj||_n|dk rO||_ndS(N(tsuperRt__init__tNonetretcompilet_regt_storage_format(tselftstorage_formattregexptkw((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR s   cKs]t|trD|jr(|j|dR?se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR(Ws    cCs*|jrtj|jtjStjSdS(N(RRt!str_to_datetime_processor_factoryR@tstr_to_datetime(RR)tcoltype((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytresult_processorxs (R+R,t__doc__RRR(RE(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR-"s ! !R cBs&eZdZdZdZdZRS(sRepresent a Python date object in SQLite using a string. The default string storage format is:: "%(year)04d-%(month)02d-%(day)02d" e.g.:: 2011-03-15 The storage format can be customized to some degree using the ``storage_format`` and ``regexp`` parameters, such as:: import re from sqlalchemy.dialects.sqlite import DATE d = DATE( storage_format="%(month)02d/%(day)02d/%(year)04d", regexp=re.compile("(?P\d+)/(?P\d+)/(?P\d+)") ) :param storage_format: format string which will be applied to the dict with keys year, month, and day. :param regexp: regular expression which will be applied to incoming result rows. If the regexp contains named groups, the resulting match dict is applied to the Python date() constructor as keyword arguments. Otherwise, if positional groups are used, the date() constructor is called with positional arguments via ``*map(int, match_obj.groups(0))``. s %(year)04d-%(month)02d-%(day)02dcs(tj|jfd}|S(NcsU|dkrdSt|rEi|jd6|jd6|jd6StddS(NR4R5R6s;SQLite Date type only accepts Python date objects as input.(RR;R4R5R6R<(R%(R>R=(se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR's    (R@RAR(RR)R'((R=R>se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR(s   cCs*|jrtj|jtjStjSdS(N(RRRBR@RAt str_to_date(RR)RD((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyREs (R+R,RFRR(RE(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR s tTIMEcBs/eZdZdZdZdZdZRS(s?Represent a Python time object in SQLite using a string. The default string storage format is:: "%(hour)02d:%(minute)02d:%(second)02d.%(microsecond)06d" e.g.:: 12:05:57.10558 The storage format can be customized to some degree using the ``storage_format`` and ``regexp`` parameters, such as:: import re from sqlalchemy.dialects.sqlite import TIME t = TIME( storage_format="%(hour)02d-%(minute)02d-%(second)02d-%(microsecond)06d", regexp=re.compile("(\d+)-(\d+)-(\d+)-(?:-(\d+))?") ) :param storage_format: format string which will be applied to the dict with keys hour, minute, second, and microsecond. :param regexp: regular expression which will be applied to incoming result rows. If the regexp contains named groups, the resulting match dict is applied to the Python time() constructor as keyword arguments. Otherwise, if positional groups are used, the time() constructor is called with positional arguments via ``*map(int, match_obj.groups(0))``. s6%(hour)02d:%(minute)02d:%(second)02d.%(microsecond)06dcOsq|jdt}tt|j|||rmd|ksItdd|ksatdd|_ndS(NR.RsDYou can specify only one of truncate_microseconds or storage_format.R s<You can specify only one of truncate_microseconds or regexp.s$%(hour)02d:%(minute)02d:%(second)02d(R/R0RRHRR1R(RR2R3R.((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRs cs(tj|jfd}|S(Ncs_|dkrdSt|rOi|jd6|jd6|jd6|jd6StddS(NR7R8R9R:s;SQLite Time type only accepts Python time objects as input.(RR;R7R8R9R:R<(R%(R>t datetime_time(se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR's     (R@ttimeR(RR)R'((R>RIse/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyR(s   cCs*|jrtj|jtjStjSdS(N(RRRBR@RJt str_to_time(RR)RD((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyREs (R+R,RFRRR(RE(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRHs  tBIGINTR tBOOLR R tDOUBLER RtINTRRRRRRRtNVARCHARtNCHARtSQLiteCompilercBseZejejji dd6dd6dd6dd6dd 6d d 6d d 6dd6dd6dd6ZdZdZdZ dZ dZ dZ dZ dZdZRS(s%mR5s%dR6s%YR4s%SR9s%HR7s%jtdoys%MR8s%stepochs%wtdows%WtweekcKsdS(NtCURRENT_TIMESTAMP((RtfnR!((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytvisit_now_func3scKsdS(Ns(DATETIME(CURRENT_TIMESTAMP, "localtime")((RtfuncR!((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytvisit_localtimestamp_func6scKsdS(Nt1((RtexprR!((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt visit_true9scKsdS(Nt0((RR]R!((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt visit_false<scKsd|j|S(Nslength%s(tfunction_argspec(RRXR!((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytvisit_char_length_func?scKs<|jjr%tt|j||S|j|j|SdS(N(R)t supports_castRRRt visit_castR'tclause(RtcastR3((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRdBs cKsYy+d|j|j|j|j|fSWn'tk rTtjd|jnXdS(Ns#CAST(STRFTIME('%s', %s) AS INTEGER)s#%s is not a valid extract argument.(t extract_maptfieldR'R]tKeyErrorRt CompileError(RtextractR!((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt visit_extractHs  cCsd}|jdk r;|d|jtj|j7}n|jdk r|jdkr||d|jtjd7}n|d|jtj|j7}n |d|jtjd7}|S(Nts LIMIT is OFFSET i(t_limitRR'Rtliteralt_offset(Rtselectttext((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt limit_clauseRs&#& cCsdS(NRm((RRq((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytfor_update_clause^s(R+R,Rt update_copyRt SQLCompilerRgRYR[R^R`RbRdRlRsRt(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRR#s,         tSQLiteDDLCompilercBs5eZdZdZdZdZdZRS(cKs|jjj|j}|jj|d|}|j|}|dk r^|d|7}n|jst|d7}n|j r|j j ddrt |j j j dkrt|jjtjr|j r|d7}n|S(Nt s DEFAULT s NOT NULLtsqlitet autoincrementis PRIMARY KEY AUTOINCREMENT(R)t type_compilerR'ttypetpreparert format_columntget_column_default_stringRtnullablet primary_keyttabletdialect_optionstlentcolumnsR"t_type_affinitytsqltypestIntegert foreign_keys(RtcolumnR3RDtcolspecR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_column_specificationes      cCst|jdkrkt|d}|jrk|jjddrkt|jjt j rk|j rkdSnt t|j|S(NiiRyRz(RRtlistRRRR"R|RRRRRRRwtvisit_primary_key_constraint(Rt constrainttc((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRxs  cCsnt|jjdjj}t|jjdjj}|j|jkrTdStt |j |SdS(Ni( Rt _elementstvaluestparentRRRRRRwtvisit_foreign_key_constraint(RRt local_tablet remote_table((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRscCs|j|dtS(s=Format the remote table clause of a CREATE CONSTRAINT clause.t use_schema(t format_tableR0(RRRR}((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytdefine_constraint_remote_tablescCstt|j|dtS(Ntinclude_table_schema(RRwtvisit_create_indexR0(Rtcreate((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRs(R+R,RRRRR(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRwcs    tSQLiteTypeCompilercBseZdZRS(cCs |j|S(N(t visit_BLOB(Rttype_((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytvisit_large_binarys(R+R,R(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRstSQLiteIdentifierPreparercuBseZedddddddddd d d d d ddddddddddddddddddd d!d"d#d$d%d&d'd(d)d*d+d,d-d.d/d0d1d2d3d4d5d6d7d8d9d:d;d<d=d>d?d@dAdBdCdDdEdFdGdHdIdJdKdLdMdNdOdPdQdRdSdTdUdVdWdXdYdZd[d\d]d^d_d`dadbdcdddedfdgdhdidjdkdldmdndodpdqdrdsgtZedudtZRS(vtaddtaftertalltaltertanalyzetandtastasctattachRztbeforetbegintbetweentbytcascadetcaseRftchecktcollateRtcommittconflictRRtcrosst current_datet current_timetcurrent_timestamptdatabaseRt deferrabletdeferredtdeletetdesctdetachtdistincttdropteachtelsetendtescapetexceptt exclusivetexplaintfalsetfailtfortforeigntfromtfulltglobtgroupthavingtiftignoret immediatetintindextindexedt initiallytinnertinserttinsteadt intersecttintotistisnulltjointkeytlefttliketlimittmatchtnaturaltnottnotnulltnulltoftoffsettontortordertoutertplantpragmatprimarytquerytraiset referencestreindextrenametreplacetrestricttrighttrollbacktrowRqtsetRttempt temporarytthenttot transactionttriggerttruetuniontuniquetupdatetusingtvacuumRtviewtvirtualtwhentwherecCs|dkr|j}n|j||j}|j r{|r{t|jddr{|j|jj|jjd|}n|S(s'Prepare a quoted index and schema name.Rt.N(Rtnametquotet omit_schematgetattrRt quote_schemaR(RRRRtresult((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt format_indexs   )N(R+R,Rtreserved_wordstTrueRR(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRs( tSQLiteExecutionContextcBs#eZejdZdZRS(cCs|jjdtS(Ntsqlite_raw_colnames(texecution_optionstgetR0(R((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt_preserve_raw_colnamesscCs;|j r-d|kr-|jdd|fS|dfSdS(NR i(RtsplitR(Rtcolname((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt_translate_colnames(R+R,Rtmemoized_propertyRR(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRst SQLiteDialectcBseZdZeZeZeZeZeZ eZ eZ eZ dZ eZeZeZeZeZeZeZdZeZ eZejied6fgZeZdedZ idd6dd6Z!dZ"d Z#d Z$e%j&dd Z'dd Z(e%j&dd Z)e%j&ddZ*e%j&ddZ+dZ,dZ-e%j&ddZ.e%j&ddZ/dZ0e%j&ddZ1e%j&ddZ2RS(RytqmarkRzcKstjj||||_||_|jdk r|jjdk|_|jjd k|_ |jjd k|_ |jjd k|_ ndS( Niiiii ii(iii(iii(iii (iii( RtDefaultDialectRtisolation_leveltnative_datetimetdbapiRtsqlite_version_infotsupports_default_valuesRctsupports_multivalues_insertt_broken_fk_pragma_quotes(RR#R$R3((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRs  isREAD UNCOMMITTEDit SERIALIZABLEcCsy|j|jdd}Wn<tk r[tjd||jdj|jfnX|j}|jd||j dS(Nt_RxsLInvalid value '%s' for isolation_level. Valid isolation levels for %s are %ss, sPRAGMA read_uncommitted = %d( t_isolation_lookupRRiRt ArgumentErrorRRtcursortexecutetclose(Rt connectiontlevelR#R.((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytset_isolation_levels & cCs|j}|jd|j}|r8|d}nd}|j|dkrXdS|dkrhdSts~td|dS(NsPRAGMA read_uncommittediR*isREAD UNCOMMITTEDsUnknown isolation level %s(R.R/tfetchoneR0R0R1(RR1R.tresR%((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_isolation_levels       cs*jdk r"fd}|SdSdS(Ncsj|jdS(N(R3R#(tconn(R(se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytconnect7s(R#R(RR8((Rse/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt on_connect5sc Ks|dk rG|jj|}d|}d|f}|j|}nEyd}|j|}Wn)tjk rd}|j|}nXg|D]}|d^qS(Ns%s.sqlite_masters4SELECT name FROM %s WHERE type='table' ORDER BY names}SELECT name FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type='table' ORDER BY names?SELECT name FROM sqlite_master WHERE type='table' ORDER BY namei(Rtidentifier_preparertquote_identifierR/Rt DBAPIError( RR1RR!tqschematmastertstrsR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_table_names=s   c Cs|jj}|dk r+d||}nd}||}d||f}t|j|}|j} x |j r|jdk rqqW| dk S(Ns PRAGMA %s.sPRAGMA s%stable_info(%s)(R:R;Rt_pragma_cursorR/R4tclosed( RR1t table_nameRRRtqtablet statementR.R((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt has_tableSs    c Ks|dk rG|jj|}d|}d|f}|j|}nEyd}|j|}Wn)tjk rd}|j|}nXg|D]}|d^qS(Ns%s.sqlite_masters3SELECT name FROM %s WHERE type='view' ORDER BY names|SELECT name FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type='view' ORDER BY names>SELECT name FROM sqlite_master WHERE type='view' ORDER BY namei(RR:R;R/RR<( RR1RR!R=R>R?R@R((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_view_nameses   c Ks|dk rJ|jj|}d|}d||f}|j|}nMyd|}|j|}Wn-tjk rd|}|j|}nX|j} | r| djSdS(Ns%s.sqlite_masters3SELECT sql FROM %s WHERE name = '%s'AND type='view's}SELECT sql FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE name = '%s' AND type='view's?SELECT sql FROM sqlite_master WHERE name = '%s' AND type='view'i(RR:R;R/RR<tfetchallR( RR1t view_nameRR!R=R>R?R@R((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_view_definition{s"    cKs|jj}|dk r+d||}nd}||}d||f}t|j|} | j} g} xo| D]g} | d| dj| d | d| df\} }}}}| j|j| ||||q{W| S( Ns PRAGMA %s.sPRAGMA s%stable_info(%s)iiiii( R:R;RRBR/RItuppertappendt_get_column_info(RR1RDRR!RRRERFRtrowsRRRRRRR((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyt get_columnss     ?cCsa|j|}|dk r-tj|}ni|d6|d6|d6|d6|dkd6|d6S(NRR|RRRzR(t_resolve_type_affinityRRt text_type(RRRRRRRD((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRNs  c Cstjd|}|r9|jd}|jd}n d}d}||jkrd|j|}nd|kr|tj}nd|ksd|ksd|krtj}nXd |ks| rtj}n9d |ksd |ksd |krtj}n tj }|dk rtj d |}y)|g|D]}t |^q/}Wqt k r~tjd||f|}qXn |}|S(sZReturn a data type from a reflected column, using affinity tules. SQLite's goal for universal compatibility introduces some complexity during reflection, as a column's defined type might not actually be a type that SQLite understands - or indeed, my not be defined *at all*. Internally, SQLite handles this with a 'data type affinity' for each column definition, mapping to one of 'TEXT', 'NUMERIC', 'INTEGER', 'REAL', or 'NONE' (raw bits). The algorithm that determines this is listed in http://www.sqlite.org/datatype3.html section 2.1. This method allows SQLAlchemy to support that algorithm, while still providing access to smarter reflection utilities by regcognizing column definitions that SQLite only supports through affinity (like DATE and DOUBLE). s([\w ]+)(\(.*?\))?iiRmROR tCLOBRR RtFLOAtDOUBs(\d+)sNCould not instantiate type %s with reflected arguments %s; using no arguments.N(RRRt ischema_namesRRRtNullTypeRRRtfindalltintR<Rtwarn(RRRRDR2ta((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRQs8  $  $   )  cKs_|j||||}g}x,|D]$}|dr%|j|dq%q%Wi|d6dd6S(NRRtconstrained_columns(RPRMR(RR1RDRR!tcolstpkeystcol((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_pk_constraints   cKs|jj}|dk r+d||}nd}||}d||f}t|j|} g} i} xptr| j} | dkrPn| d| d| d| df\} }}}|j| | | |||qqW| S(Ns PRAGMA %s.sPRAGMA s%sforeign_key_list(%s)iiii(R:R;RRBR/RR4t _parse_fk(RR1RDRR!RRRERFRtfkeystfksRt numerical_idtrtbltlcoltrcol((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pytget_foreign_keyss       . cCs|dkr|}n|jr6tjdd|}ny||}WnQtk ridd6gd6dd6|d6gd6}|j||||fscSsgS(N((((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRgs(RCR4RI(R.((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyRBas  (6RFR@RRmRRRRRRRRtengineRRRR R R R R RRRRRRRRtobjectRtDateTimeR-tDatetTimeRHRRLRPRQRVRvRRt DDLCompilerRwtGenericTypeCompilerRtIdentifierPreparerRtDefaultExecutionContextRR"R RB(((se/var/www/send.findwatt.com/datamanager/lib/python2.7/site-packages/sqlalchemy/dialects/sqlite/base.pyts^  X^=G                        @:$