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
+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.
+nicely support ordering. There's no reliance on typical "libc" internals for
+these functions so historical dates are fully supported.
Auto Incrementing Behavior
--------------------------
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.
+ 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::
+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),
Transaction Isolation Level
---------------------------
-:func:`.create_engine` accepts an ``isolation_level`` parameter which
-results in the command ``PRAGMA read_uncommitted <level>`` being invoked for
-every new connection. Valid values for this parameter are ``SERIALIZABLE``
-and ``READ UNCOMMITTED`` corresponding to a value of 0 and 1, respectively.
-See the section :ref:`pysqlite_serializable` for an important workaround
-when using serializable isolation with Pysqlite.
+:func:`.create_engine` accepts an ``isolation_level`` parameter which results
+in the command ``PRAGMA read_uncommitted <level>`` being invoked for every new
+connection. Valid values for this parameter are ``SERIALIZABLE`` and ``READ
+UNCOMMITTED`` corresponding to a value of 0 and 1, respectively. See the
+section :ref:`pysqlite_serializable` for an important workaround when using
+serializable isolation with Pysqlite.
Database Locking Behavior / Concurrency
---------------------------------------
-Note that SQLite is not designed for a high level of concurrency. The
-database itself, being a file, is locked completely during write operations
-and within transactions, meaning exactly one connection has exclusive access
-to the database during this period - all other connections will be blocked
-during this time.
+Note that SQLite is not designed for a high level of concurrency. The database
+itself, being a file, is locked completely during write operations and within
+transactions, meaning exactly one connection 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 BEGIN method, only commit and rollback. This
+in a transaction; there is no BEGIN method, only commit and rollback. This
implies that a SQLite DBAPI driver would technically allow only serialized
-access to a particular database file at all times. The pysqlite driver
-attempts to ameliorate this by deferring the actual BEGIN statement until
-the first DML (INSERT, UPDATE, or DELETE) is received within a
-transaction. While this breaks serializable isolation, it at least delays
-the exclusive locking inherent in SQLite's design.
-
-SQLAlchemy's default mode of usage with the ORM is known
-as "autocommit=False", which means the moment the :class:`.Session` begins to
-be used, a transaction is begun. As the :class:`.Session` is used, the
-autoflush feature, also on by default, will flush out pending changes to the
-database before each query. The effect of this is that a :class:`.Session`
-used in its default mode will often emit DML early on, long before the
-transaction is actually committed. This again will have the effect of
-serializing access to the SQLite database. If highly concurrent reads are
-desired against the SQLite database, it is advised that the autoflush feature
-be disabled, and potentially even that autocommit be re-enabled, which has
-the effect of each SQL statement and flush committing changes immediately.
-
-For more information on SQLite's lack of concurrency by design, please
-see `Situations Where Another RDBMS May Work Better - High
-Concurrency <http://www.sqlite.org/whentouse.html>`_ near the bottom of
-the page.
+access to a particular database file at all times. The pysqlite driver attempts
+to ameliorate this by deferring the actual BEGIN statement until the first DML
+(INSERT, UPDATE, or DELETE) is received within a transaction. While this breaks
+serializable isolation, it at least delays the exclusive locking inherent in
+SQLite's design.
+
+SQLAlchemy's default mode of usage with the ORM is known as "autocommit=False",
+which means the moment the :class:`.Session` begins to be used, a transaction
+is begun. As the :class:`.Session` is used, the autoflush feature, also on by
+default, will flush out pending changes to the database before each query. The
+effect of this is that a :class:`.Session` used in its default mode will often
+emit DML early on, long before the transaction is actually committed. This
+again will have the effect of serializing access to the SQLite database. If
+highly concurrent reads are desired against the SQLite database, it is advised
+that the autoflush feature be disabled, and potentially even that autocommit be
+re-enabled, which has the effect of each SQL statement and flush committing
+changes immediately.
+
+For more information on SQLite's lack of concurrency by design, please see
+`Situations Where Another RDBMS May Work Better - High Concurrency
+<http://www.sqlite.org/whentouse.html>`_ near the bottom of the page.
.. _sqlite_foreign_keys:
-------------------
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.
+however by default these constraints have no effect on the operation of the
+table.
Constraint checking on SQLite has three prerequisites:
* 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::
+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
.. seealso::
- `SQLite Foreign Key Support <http://www.sqlite.org/foreignkeys.html>`_ -
- on the SQLite web site.
+ `SQLite Foreign Key Support <http://www.sqlite.org/foreignkeys.html>`_ - on
+ the SQLite web site.
:ref:`event_toplevel` - SQLAlchemy event API.
import datetime
import re
+from ... import processors
from ... import sql, exc
-from ...engine import default, reflection
from ... import types as sqltypes, schema as sa_schema
from ... import util
+from ...engine import default, reflection
from ...sql import compiler
-from ... import processors
-from ...types import BIGINT, BLOB, BOOLEAN, CHAR,\
- DECIMAL, FLOAT, REAL, INTEGER, NUMERIC, SMALLINT, TEXT,\
- TIMESTAMP, VARCHAR
+from ...types import (BLOB, BOOLEAN, CHAR, DATE, DECIMAL, FLOAT, INTEGER, REAL,
+ NUMERIC, SMALLINT, TEXT, TIMESTAMP, VARCHAR)
class _DateTimeMixin(object):
regexp=r"(\d+)/(\d+)/(\d+) (\d+)-(\d+)-(\d+)"
)
- :param storage_format: format string which will be applied to the
- dict with keys year, month, day, hour, minute, second, and microsecond.
+ :param storage_format: format string which will be applied to the dict with
+ keys year, month, day, 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 datetime() constructor
- as keyword arguments. Otherwise, if positional groups are used, the
- the datetime() constructor is called with positional arguments via
+ :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 datetime() constructor as keyword arguments.
+ Otherwise, if positional groups are used, the the datetime() constructor
+ is called with positional arguments via
``*map(int, match_obj.groups(0))``.
"""
"%(hour)02d:%(minute)02d:%(second)02d"
)
-
def bind_processor(self, dialect):
datetime_datetime = datetime.datetime
datetime_date = datetime.date
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 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
- the time() constructor is called with positional arguments via
- ``*map(int, match_obj.groups(0))``.
+ :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 the time() constructor is called with
+ positional arguments via ``*map(int, match_obj.groups(0))``.
"""
_storage_format = "%(hour)02d:%(minute)02d:%(second)02d.%(microsecond)06d"
extract_map = util.update_copy(
compiler.SQLCompiler.extract_map,
{
- 'month': '%m',
- 'day': '%d',
- 'year': '%Y',
- 'second': '%S',
- 'hour': '%H',
- 'doy': '%j',
- 'minute': '%M',
- 'epoch': '%s',
- 'dow': '%w',
- 'week': '%W'
- })
+ 'month': '%m',
+ 'day': '%d',
+ 'year': '%Y',
+ 'second': '%S',
+ 'hour': '%H',
+ 'doy': '%j',
+ 'minute': '%M',
+ 'epoch': '%s',
+ 'dow': '%w',
+ 'week': '%W',
+ })
def visit_now_func(self, fn, **kw):
return "CURRENT_TIMESTAMP"
colspec += " NOT NULL"
if (column.primary_key and
- column.table.dialect_options['sqlite']['autoincrement'] and
- len(column.table.primary_key.columns) == 1 and
- issubclass(column.type._type_affinity, sqltypes.Integer) and
- not column.foreign_keys):
- colspec += " PRIMARY KEY AUTOINCREMENT"
+ column.table.dialect_options['sqlite']['autoincrement'] and
+ len(column.table.primary_key.columns) == 1 and
+ issubclass(column.type._type_affinity, sqltypes.Integer) and
+ not column.foreign_keys):
+ colspec += " PRIMARY KEY AUTOINCREMENT"
return colspec
# with the column itself.
if len(constraint.columns) == 1:
c = list(constraint)[0]
- if c.primary_key and \
- c.table.dialect_options['sqlite']['autoincrement'] and \
- issubclass(c.type._type_affinity, sqltypes.Integer) and \
- not c.foreign_keys:
+ if (c.primary_key and
+ c.table.dialect_options['sqlite']['autoincrement'] and
+ issubclass(c.type._type_affinity, sqltypes.Integer) and
+ not c.foreign_keys):
return None
- return super(SQLiteDDLCompiler, self).\
- visit_primary_key_constraint(constraint)
+ return super(SQLiteDDLCompiler, self).visit_primary_key_constraint(
+ constraint)
def visit_foreign_key_constraint(self, constraint):
if local_table.schema != remote_table.schema:
return None
else:
- return super(SQLiteDDLCompiler, self).visit_foreign_key_constraint(constraint)
+ return super(SQLiteDDLCompiler, self).visit_foreign_key_constraint(
+ constraint)
def define_constraint_remote_table(self, constraint, table, preparer):
"""Format the remote table clause of a CREATE CONSTRAINT clause."""
return preparer.format_table(table, use_schema=False)
def visit_create_index(self, create):
- return super(SQLiteDDLCompiler, self).\
- visit_create_index(create, include_table_schema=False)
+ return super(SQLiteDDLCompiler, self).visit_create_index(
+ create, include_table_schema=False)
class SQLiteTypeCompiler(compiler.GenericTypeCompiler):
name = index.name
result = self.quote(name, index.quote)
if (not self.omit_schema and
- use_schema and
- getattr(index.table, "schema", None)):
- result = self.quote_schema(
- index.table.schema, index.table.quote_schema) + "." + result
+ use_schema and
+ getattr(index.table, "schema", None)):
+ result = self.quote_schema(index.table.schema,
+ index.table.quote_schema) + "." + result
return result
return self.execution_options.get("sqlite_raw_colnames", False)
def _translate_colname(self, colname):
- # adjust for dotted column names. SQLite
- # in the case of UNION may store col names as
- # "tablename.colname"
- # in cursor.description
- if not self._preserve_raw_colnames and "." in colname:
+ # adjust for dotted column names. SQLite in the case of UNION may store
+ # col names as "tablename.colname" in cursor.description
+ if not self._preserve_raw_colnames and "." in colname:
return colname.split(".")[1], colname
else:
return colname, None
default.DefaultDialect.__init__(self, **kwargs)
self.isolation_level = isolation_level
- # this flag used by pysqlite dialect, and perhaps others in the
- # future, to indicate the driver is handling date/timestamp
- # conversions (and perhaps datetime/time as well on some
- # hypothetical driver ?)
+ # this flag used by pysqlite dialect, and perhaps others in the future,
+ # to indicate the driver is handling date/timestamp conversions (and
+ # perhaps datetime/time as well on some hypothetical driver ?)
self.native_datetime = native_datetime
if self.dbapi is not None:
- self.supports_default_values = \
- self.dbapi.sqlite_version_info >= (3, 3, 8)
- self.supports_cast = \
- self.dbapi.sqlite_version_info >= (3, 2, 3)
- self.supports_multivalues_insert = \
- self.dbapi.sqlite_version_info >= (3, 7, 11)
- # http://www.sqlite.org/releaselog/3_7_11.html
-
+ self.supports_default_values = (
+ self.dbapi.sqlite_version_info >= (3, 3, 8))
+ self.supports_cast = (
+ self.dbapi.sqlite_version_info >= (3, 2, 3))
+ self.supports_multivalues_insert = (
+ # http://www.sqlite.org/releaselog/3_7_11.html
+ self.dbapi.sqlite_version_info >= (3, 7, 11))
# see http://www.sqlalchemy.org/trac/ticket/2568
# as well as http://www.sqlite.org/src/info/600482d161
- self._broken_fk_pragma_quotes = \
- self.dbapi.sqlite_version_info < (3, 6, 14)
-
+ self._broken_fk_pragma_quotes = (
+ self.dbapi.sqlite_version_info < (3, 6, 14))
_isolation_lookup = {
'READ UNCOMMITTED': 1,
- 'SERIALIZABLE': 0
+ 'SERIALIZABLE': 0,
}
def set_isolation_level(self, connection, level):
while not cursor.closed and cursor.fetchone() is not None:
pass
- return (row is not None)
+ return row is not None
@reflection.cache
def get_view_names(self, connection, schema=None, **kw):
@reflection.cache
def get_view_definition(self, connection, view_name, schema=None, **kw):
- quote = self.identifier_preparer.quote_identifier
if schema is not None:
qschema = self.identifier_preparer.quote_identifier(schema)
master = '%s.sqlite_master' % qschema
rows = c.fetchall()
columns = []
for row in rows:
- (name, type_, nullable, default, primary_key) = \
- (row[1], row[2].upper(), not row[3],
- row[4], row[5])
+ (name, type_, nullable, default, primary_key) = (
+ row[1], row[2].upper(), not row[3], row[4], row[5])
columns.append(self._get_column_info(name, type_, nullable,
- default, primary_key))
+ default, primary_key))
return columns
- def _get_column_info(self, name, type_, nullable,
- default, primary_key):
-
+ def _get_column_info(self, name, type_, nullable, default, primary_key):
match = re.match(r'(\w+)(\(.*?\))?', type_)
if match:
coltype = match.group(1)
'nullable': nullable,
'default': default,
'autoincrement': default is None,
- 'primary_key': primary_key
+ 'primary_key': primary_key,
}
@reflection.cache
return fkeys
def _parse_fk(self, fks, fkeys, numerical_id, rtbl, lcol, rcol):
- # sqlite won't return rcol if the table
- #
was created with REFERENCES <tablename>, no col
+ # sqlite won't return rcol if the table was created with REFERENCES
+ # <tablename>, no col
if rcol is None:
rcol = lcol
'constrained_columns': [],
'referred_schema': None,
'referred_table': rtbl,
- 'referred_columns': []
+ 'referred_columns': [],
}
fkeys.append(fk)
fks[numerical_id] = fk
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
