diff options
Diffstat (limited to 'lib/sqlalchemy/dialects')
| -rw-r--r-- | lib/sqlalchemy/dialects/firebird/base.py | 18 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/firebird/kinterbasdb.py | 24 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/mssql/base.py | 128 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/mssql/mxodbc.py | 4 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/mysql/gaerdbms.py | 8 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/mysql/pymysql.py | 16 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/oracle/base.py | 96 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/postgresql/psycopg2.py | 54 | ||||
| -rw-r--r-- | lib/sqlalchemy/dialects/sybase/base.py | 16 |
9 files changed, 182 insertions, 182 deletions
diff --git a/lib/sqlalchemy/dialects/firebird/base.py b/lib/sqlalchemy/dialects/firebird/base.py index a0e48da2c..f3ab73467 100644 --- a/lib/sqlalchemy/dialects/firebird/base.py +++ b/lib/sqlalchemy/dialects/firebird/base.py @@ -135,7 +135,7 @@ class VARCHAR(_StringType, sqltypes.VARCHAR): __visit_name__ = 'VARCHAR' def __init__(self, length = None, **kwargs): - super(VARCHAR, self).__init__(length=length, **kwargs) + super(VARCHAR, self).__init__(length=length, **kwargs) class CHAR(_StringType, sqltypes.CHAR): """Firebird CHAR type""" @@ -164,7 +164,7 @@ ischema_names = { } -# TODO: date conversion types (should be implemented as _FBDateTime, +# TODO: date conversion types (should be implemented as _FBDateTime, # _FBDate, etc. as bind/result functionality is required) class FBTypeCompiler(compiler.GenericTypeCompiler): @@ -339,7 +339,7 @@ class FBExecutionContext(default.DefaultExecutionContext): """Get the next value from the sequence using ``gen_id()``.""" return self._execute_scalar( - "SELECT gen_id(%s, 1) FROM rdb$database" % + "SELECT gen_id(%s, 1) FROM rdb$database" % self.dialect.identifier_preparer.format_sequence(seq), type_ ) @@ -418,7 +418,7 @@ class FBDialect(default.DefaultDialect): return name def has_table(self, connection, table_name, schema=None): - """Return ``True`` if the given table exists, ignoring + """Return ``True`` if the given table exists, ignoring the `schema`.""" tblqry = """ @@ -489,8 +489,8 @@ class FBDialect(default.DefaultDialect): return {'constrained_columns':pkfields, 'name':None} @reflection.cache - def get_column_sequence(self, connection, - table_name, column_name, + def get_column_sequence(self, connection, + table_name, column_name, schema=None, **kw): tablename = self.denormalize_name(table_name) colname = self.denormalize_name(column_name) @@ -528,7 +528,7 @@ class FBDialect(default.DefaultDialect): COALESCE(cs.rdb$bytes_per_character,1) AS flen, f.rdb$field_precision AS fprec, f.rdb$field_scale AS fscale, - COALESCE(r.rdb$default_source, + COALESCE(r.rdb$default_source, f.rdb$default_source) AS fdefault FROM rdb$relation_fields r JOIN rdb$fields f ON r.rdb$field_source=f.rdb$field_name @@ -564,7 +564,7 @@ class FBDialect(default.DefaultDialect): coltype = sqltypes.NULLTYPE elif colspec == 'INT64': coltype = coltype( - precision=row['fprec'], + precision=row['fprec'], scale=row['fscale'] * -1) elif colspec in ('VARYING', 'CSTRING'): coltype = coltype(row['flen']) @@ -583,7 +583,7 @@ class FBDialect(default.DefaultDialect): if row['fdefault'] is not None: # the value comes down as "DEFAULT 'value'": there may be # more than one whitespace around the "DEFAULT" keyword - # and it may also be lower case + # and it may also be lower case # (see also http://tracker.firebirdsql.org/browse/CORE-356) defexpr = row['fdefault'].lstrip() assert defexpr[:8].rstrip().upper() == \ diff --git a/lib/sqlalchemy/dialects/firebird/kinterbasdb.py b/lib/sqlalchemy/dialects/firebird/kinterbasdb.py index d9d749b3c..a5dc821be 100644 --- a/lib/sqlalchemy/dialects/firebird/kinterbasdb.py +++ b/lib/sqlalchemy/dialects/firebird/kinterbasdb.py @@ -17,20 +17,20 @@ Kinterbasedb backend specific keyword arguments are: SQLAlchemy uses 200 with Unicode, datetime and decimal support (see details__). -* concurrency_level - set the backend policy with regards to threading +* concurrency_level - set the backend policy with regards to threading issues: by default SQLAlchemy uses policy 1 (see details__). -* enable_rowcount - True by default, setting this to False disables - the usage of "cursor.rowcount" with the +* enable_rowcount - True by default, setting this to False disables + the usage of "cursor.rowcount" with the Kinterbasdb dialect, which SQLAlchemy ordinarily calls upon automatically - after any UPDATE or DELETE statement. When disabled, SQLAlchemy's - ResultProxy will return -1 for result.rowcount. The rationale here is - that Kinterbasdb requires a second round trip to the database when - .rowcount is called - since SQLA's resultproxy automatically closes - the cursor after a non-result-returning statement, rowcount must be + after any UPDATE or DELETE statement. When disabled, SQLAlchemy's + ResultProxy will return -1 for result.rowcount. The rationale here is + that Kinterbasdb requires a second round trip to the database when + .rowcount is called - since SQLA's resultproxy automatically closes + the cursor after a non-result-returning statement, rowcount must be called, if at all, before the result object is returned. Additionally, cursor.rowcount may not return correct results with older versions - of Firebird, and setting this flag to False will also cause the + of Firebird, and setting this flag to False will also cause the SQLAlchemy ORM to ignore its usage. The behavior can also be controlled on a per-execution basis using the `enable_rowcount` option with :meth:`execution_options()`:: @@ -64,7 +64,7 @@ class _FBNumeric_kinterbasdb(sqltypes.Numeric): class FBExecutionContext_kinterbasdb(FBExecutionContext): @property def rowcount(self): - if self.execution_options.get('enable_rowcount', + if self.execution_options.get('enable_rowcount', self.dialect.enable_rowcount): return self.cursor.rowcount else: @@ -135,7 +135,7 @@ class FBDialect_kinterbasdb(FBDialect): # that for backward compatibility reasons returns a string like # LI-V6.3.3.12981 Firebird 2.0 # where the first version is a fake one resembling the old - # Interbase signature. + # Interbase signature. fbconn = connection.connection version = fbconn.server_version @@ -159,7 +159,7 @@ class FBDialect_kinterbasdb(FBDialect): msg = str(e) return ('Unable to complete network request to host' in msg or 'Invalid connection state' in msg or - 'Invalid cursor state' in msg or + 'Invalid cursor state' in msg or 'connection shutdown' in msg) else: return False diff --git a/lib/sqlalchemy/dialects/mssql/base.py b/lib/sqlalchemy/dialects/mssql/base.py index b893541d3..e38aa8c1e 100644 --- a/lib/sqlalchemy/dialects/mssql/base.py +++ b/lib/sqlalchemy/dialects/mssql/base.py @@ -74,7 +74,7 @@ will yield:: SELECT TOP n If using SQL Server 2005 or above, LIMIT with OFFSET -support is available through the ``ROW_NUMBER OVER`` construct. +support is available through the ``ROW_NUMBER OVER`` construct. For versions below 2005, LIMIT with OFFSET usage will fail. Nullability @@ -119,14 +119,14 @@ Triggers SQLAlchemy by default uses OUTPUT INSERTED to get at newly generated primary key values via IDENTITY columns or other -server side defaults. MS-SQL does not +server side defaults. MS-SQL does not allow the usage of OUTPUT INSERTED on tables that have triggers. To disable the usage of OUTPUT INSERTED on a per-table basis, specify ``implicit_returning=False`` for each :class:`.Table` which has triggers:: - Table('mytable', metadata, - Column('id', Integer, primary_key=True), + Table('mytable', metadata, + Column('id', Integer, primary_key=True), # ..., implicit_returning=False ) @@ -144,11 +144,11 @@ This option can also be specified engine-wide using the Enabling Snapshot Isolation --------------------------- -Not necessarily specific to SQLAlchemy, SQL Server has a default transaction +Not necessarily specific to SQLAlchemy, SQL Server has a default transaction isolation mode that locks entire tables, and causes even mildly concurrent applications to have long held locks and frequent deadlocks. -Enabling snapshot isolation for the database as a whole is recommended -for modern levels of concurrency support. This is accomplished via the +Enabling snapshot isolation for the database as a whole is recommended +for modern levels of concurrency support. This is accomplished via the following ALTER DATABASE commands executed at the SQL prompt:: ALTER DATABASE MyDatabase SET ALLOW_SNAPSHOT_ISOLATION ON @@ -249,7 +249,7 @@ class _MSDate(sqltypes.Date): return value.date() elif isinstance(value, basestring): return datetime.date(*[ - int(x or 0) + int(x or 0) for x in self._reg.match(value).groups() ]) else: @@ -280,7 +280,7 @@ class TIME(sqltypes.TIME): return value.time() elif isinstance(value, basestring): return datetime.time(*[ - int(x or 0) + int(x or 0) for x in self._reg.match(value).groups()]) else: return value @@ -585,7 +585,7 @@ class MSTypeCompiler(compiler.GenericTypeCompiler): return self._extend("TEXT", type_) def visit_VARCHAR(self, type_): - return self._extend("VARCHAR", type_, + return self._extend("VARCHAR", type_, length = type_.length or 'max') def visit_CHAR(self, type_): @@ -595,7 +595,7 @@ class MSTypeCompiler(compiler.GenericTypeCompiler): return self._extend("NCHAR", type_) def visit_NVARCHAR(self, type_): - return self._extend("NVARCHAR", type_, + return self._extend("NVARCHAR", type_, length = type_.length or 'max') def visit_date(self, type_): @@ -618,8 +618,8 @@ class MSTypeCompiler(compiler.GenericTypeCompiler): def visit_VARBINARY(self, type_): return self._extend( - "VARBINARY", - type_, + "VARBINARY", + type_, length=type_.length or 'max') def visit_boolean(self, type_): @@ -666,8 +666,8 @@ class MSExecutionContext(default.DefaultExecutionContext): not self.executemany if self._enable_identity_insert: - self.root_connection._cursor_execute(self.cursor, - "SET IDENTITY_INSERT %s ON" % + self.root_connection._cursor_execute(self.cursor, + "SET IDENTITY_INSERT %s ON" % self.dialect.identifier_preparer.format_table(tbl), ()) @@ -677,10 +677,10 @@ class MSExecutionContext(default.DefaultExecutionContext): conn = self.root_connection if self._select_lastrowid: if self.dialect.use_scope_identity: - conn._cursor_execute(self.cursor, + conn._cursor_execute(self.cursor, "SELECT scope_identity() AS lastrowid", ()) else: - conn._cursor_execute(self.cursor, + conn._cursor_execute(self.cursor, "SELECT @@identity AS lastrowid", ()) # fetchall() ensures the cursor is consumed without closing it row = self.cursor.fetchall()[0] @@ -691,7 +691,7 @@ class MSExecutionContext(default.DefaultExecutionContext): self._result_proxy = base.FullyBufferedResultProxy(self) if self._enable_identity_insert: - conn._cursor_execute(self.cursor, + conn._cursor_execute(self.cursor, "SET IDENTITY_INSERT %s OFF" % self.dialect.identifier_preparer. format_table(self.compiled.statement.table), @@ -705,7 +705,7 @@ class MSExecutionContext(default.DefaultExecutionContext): if self._enable_identity_insert: try: self.cursor.execute( - "SET IDENTITY_INSERT %s OFF" % + "SET IDENTITY_INSERT %s OFF" % self.dialect.identifier_preparer.\ format_table(self.compiled.statement.table) ) @@ -748,12 +748,12 @@ class MSSQLCompiler(compiler.SQLCompiler): def visit_concat_op(self, binary, **kw): return "%s + %s" % \ - (self.process(binary.left, **kw), + (self.process(binary.left, **kw), self.process(binary.right, **kw)) def visit_match_op(self, binary, **kw): return "CONTAINS (%s, %s)" % ( - self.process(binary.left, **kw), + self.process(binary.left, **kw), self.process(binary.right, **kw)) def get_select_precolumns(self, select): @@ -843,7 +843,7 @@ class MSSQLCompiler(compiler.SQLCompiler): return "SAVE TRANSACTION %s" % self.preparer.format_savepoint(savepoint_stmt) def visit_rollback_to_savepoint(self, savepoint_stmt): - return ("ROLLBACK TRANSACTION %s" + return ("ROLLBACK TRANSACTION %s" % self.preparer.format_savepoint(savepoint_stmt)) def visit_column(self, column, result_map=None, **kwargs): @@ -856,18 +856,18 @@ class MSSQLCompiler(compiler.SQLCompiler): t, column) if result_map is not None: - result_map[column.name - if self.dialect.case_sensitive + result_map[column.name + if self.dialect.case_sensitive else column.name.lower()] = \ - (column.name, (column, ), + (column.name, (column, ), column.type) return super(MSSQLCompiler, self).\ - visit_column(converted, + visit_column(converted, result_map=None, **kwargs) - return super(MSSQLCompiler, self).visit_column(column, - result_map=result_map, + return super(MSSQLCompiler, self).visit_column(column, + result_map=result_map, **kwargs) def visit_binary(self, binary, **kwargs): @@ -876,14 +876,14 @@ class MSSQLCompiler(compiler.SQLCompiler): """ if ( - isinstance(binary.left, expression.BindParameter) + isinstance(binary.left, expression.BindParameter) and binary.operator == operator.eq and not isinstance(binary.right, expression.BindParameter) ): return self.process( - expression.BinaryExpression(binary.right, - binary.left, - binary.operator), + expression.BinaryExpression(binary.right, + binary.left, + binary.operator), **kwargs) return super(MSSQLCompiler, self).visit_binary(binary, **kwargs) @@ -904,10 +904,10 @@ class MSSQLCompiler(compiler.SQLCompiler): columns = [ self.process( - col_label(c), - within_columns_clause=True, + col_label(c), + within_columns_clause=True, result_map=self.result_map - ) + ) for c in expression._select_iterables(returning_cols) ] return 'OUTPUT ' + ', '.join(columns) @@ -927,7 +927,7 @@ class MSSQLCompiler(compiler.SQLCompiler): label_select_column(select, column, asfrom) def for_update_clause(self, select): - # "FOR UPDATE" is only allowed on "DECLARE CURSOR" which + # "FOR UPDATE" is only allowed on "DECLARE CURSOR" which # SQLAlchemy doesn't use return '' @@ -945,11 +945,11 @@ class MSSQLCompiler(compiler.SQLCompiler): from_hints, **kw): """Render the UPDATE..FROM clause specific to MSSQL. - + In MSSQL, if the UPDATE statement involves an alias of the table to be updated, then the table itself must be added to the FROM list as well. Otherwise, it is optional. Here, we add it regardless. - + """ return "FROM " + ', '.join( t._compiler_dispatch(self, asfrom=True, @@ -969,14 +969,14 @@ class MSSQLStrictCompiler(MSSQLCompiler): def visit_in_op(self, binary, **kw): kw['literal_binds'] = True return "%s IN %s" % ( - self.process(binary.left, **kw), + self.process(binary.left, **kw), self.process(binary.right, **kw) ) def visit_notin_op(self, binary, **kw): kw['literal_binds'] = True return "%s NOT IN %s" % ( - self.process(binary.left, **kw), + self.process(binary.left, **kw), self.process(binary.right, **kw) ) @@ -1005,7 +1005,7 @@ class MSSQLStrictCompiler(MSSQLCompiler): class MSDDLCompiler(compiler.DDLCompiler): def get_column_specification(self, column, **kwargs): - colspec = (self.preparer.format_column(column) + " " + colspec = (self.preparer.format_column(column) + " " + self.dialect.type_compiler.process(column.type)) if column.nullable is not None: @@ -1016,7 +1016,7 @@ class MSDDLCompiler(compiler.DDLCompiler): if column.table is None: raise exc.CompileError( - "mssql requires Table-bound columns " + "mssql requires Table-bound columns " "in order to generate DDL") seq_col = column.table._autoincrement_column @@ -1051,7 +1051,7 @@ class MSIdentifierPreparer(compiler.IdentifierPreparer): reserved_words = RESERVED_WORDS def __init__(self, dialect): - super(MSIdentifierPreparer, self).__init__(dialect, initial_quote='[', + super(MSIdentifierPreparer, self).__init__(dialect, initial_quote='[', final_quote=']') def _escape_identifier(self, value): @@ -1116,7 +1116,7 @@ class MSDialect(default.DefaultDialect): super(MSDialect, self).initialize(connection) if self.server_version_info[0] not in range(8, 17): # FreeTDS with version 4.2 seems to report here - # a number like "95.10.255". Don't know what + # a number like "95.10.255". Don't know what # that is. So emit warning. util.warn( "Unrecognized server version info '%s'. Version specific " @@ -1217,11 +1217,11 @@ class MSDialect(default.DefaultDialect): "join sys.schemas as sch on sch.schema_id=tab.schema_id " "where tab.name = :tabname " "and sch.name=:schname " - "and ind.is_primary_key=0", + "and ind.is_primary_key=0", bindparams=[ - sql.bindparam('tabname', tablename, + sql.bindparam('tabname', tablename, sqltypes.String(convert_unicode=True)), - sql.bindparam('schname', current_schema, + sql.bindparam('schname', current_schema, sqltypes.String(convert_unicode=True)) ], typemap = { @@ -1248,9 +1248,9 @@ class MSDialect(default.DefaultDialect): "where tab.name=:tabname " "and sch.name=:schname", bindparams=[ - sql.bindparam('tabname', tablename, + sql.bindparam('tabname', tablename, sqltypes.String(convert_unicode=True)), - sql.bindparam('schname', current_schema, + sql.bindparam('schname', current_schema, sqltypes.String(convert_unicode=True)) ], typemap = { @@ -1278,9 +1278,9 @@ class MSDialect(default.DefaultDialect): "views.schema_id=sch.schema_id and " "views.name=:viewname and sch.name=:schname", bindparams=[ - sql.bindparam('viewname', viewname, + sql.bindparam('viewname', viewname, sqltypes.String(convert_unicode=True)), - sql.bindparam('schname', current_schema, + sql.bindparam('schname', current_schema, sqltypes.String(convert_unicode=True)) ] ) @@ -1309,7 +1309,7 @@ class MSDialect(default.DefaultDialect): row = c.fetchone() if row is None: break - (name, type, nullable, charlen, + (name, type, nullable, charlen, numericprec, numericscale, default, collation) = ( row[columns.c.column_name], row[columns.c.data_type], @@ -1323,7 +1323,7 @@ class MSDialect(default.DefaultDialect): coltype = self.ischema_names.get(type, None) kwargs = {} - if coltype in (MSString, MSChar, MSNVarchar, MSNChar, MSText, + if coltype in (MSString, MSChar, MSNVarchar, MSNChar, MSText, MSNText, MSBinary, MSVarBinary, sqltypes.LargeBinary): kwargs['length'] = charlen @@ -1335,7 +1335,7 @@ class MSDialect(default.DefaultDialect): if coltype is None: util.warn( - "Did not recognize type '%s' of column '%s'" % + "Did not recognize type '%s' of column '%s'" % (type, name)) coltype = sqltypes.NULLTYPE else: @@ -1359,7 +1359,7 @@ class MSDialect(default.DefaultDialect): colmap[col['name']] = col # We also run an sp_columns to check for identity columns: cursor = connection.execute("sp_columns @table_name = '%s', " - "@table_owner = '%s'" + "@table_owner = '%s'" % (tablename, current_schema)) ic = None while True: @@ -1378,7 +1378,7 @@ class MSDialect(default.DefaultDialect): if ic is not None and self.server_version_info >= MS_2005_VERSION: table_fullname = "%s.%s" % (current_schema, tablename) cursor = connection.execute( - "select ident_seed('%s'), ident_incr('%s')" + "select ident_seed('%s'), ident_incr('%s')" % (table_fullname, table_fullname) ) @@ -1398,12 +1398,12 @@ class MSDialect(default.DefaultDialect): RR = ischema.ref_constraints # information_schema.table_constraints TC = ischema.constraints - # information_schema.constraint_column_usage: + # information_schema.constraint_column_usage: # the constrained column - C = ischema.key_constraints.alias('C') - # information_schema.constraint_column_usage: + C = ischema.key_constraints.alias('C') + # information_schema.constraint_column_usage: # the referenced column - R = ischema.key_constraints.alias('R') + R = ischema.key_constraints.alias('R') # Primary key constraints s = sql.select([C.c.column_name, TC.c.constraint_type], @@ -1425,12 +1425,12 @@ class MSDialect(default.DefaultDialect): RR = ischema.ref_constraints # information_schema.table_constraints TC = ischema.constraints - # information_schema.constraint_column_usage: + # information_schema.constraint_column_usage: # the constrained column - C = ischema.key_constraints.alias('C') - # information_schema.constraint_column_usage: + C = ischema.key_constraints.alias('C') + # information_schema.constraint_column_usage: # the referenced column - R = ischema.key_constraints.alias('R') + R = ischema.key_constraints.alias('R') # Foreign key constraints s = sql.select([C.c.column_name, diff --git a/lib/sqlalchemy/dialects/mssql/mxodbc.py b/lib/sqlalchemy/dialects/mssql/mxodbc.py index 94f0a2cbb..15ebad1f8 100644 --- a/lib/sqlalchemy/dialects/mssql/mxodbc.py +++ b/lib/sqlalchemy/dialects/mssql/mxodbc.py @@ -41,7 +41,7 @@ simplistic statements. For this reason, the mxODBC dialect uses the "native" mode by default only for INSERT, UPDATE, and DELETE statements, and uses the escaped string mode for -all other statements. +all other statements. This behavior can be controlled via :meth:`~sqlalchemy.sql.expression.Executable.execution_options` using the @@ -55,7 +55,7 @@ of ``False`` will unconditionally use string-escaped parameters. from sqlalchemy import types as sqltypes from sqlalchemy.connectors.mxodbc import MxODBCConnector from sqlalchemy.dialects.mssql.pyodbc import MSExecutionContext_pyodbc -from sqlalchemy.dialects.mssql.base import (MSDialect, +from sqlalchemy.dialects.mssql.base import (MSDialect, MSSQLStrictCompiler, _MSDateTime, _MSDate, TIME) diff --git a/lib/sqlalchemy/dialects/mysql/gaerdbms.py b/lib/sqlalchemy/dialects/mysql/gaerdbms.py index f84a5d2dd..0fe5d635a 100644 --- a/lib/sqlalchemy/dialects/mysql/gaerdbms.py +++ b/lib/sqlalchemy/dialects/mysql/gaerdbms.py @@ -27,7 +27,7 @@ Pooling Google App Engine connections appear to be randomly recycled, so the dialect does not pool connections. The :class:`.NullPool` -implementation is installed within the :class:`.Engine` by +implementation is installed within the :class:`.Engine` by default. """ @@ -37,10 +37,10 @@ from sqlalchemy.pool import NullPool import re -class MySQLDialect_gaerdbms(MySQLDialect_mysqldb): +class MySQLDialect_gaerdbms(MySQLDialect_mysqldb): - @classmethod - def dbapi(cls): + @classmethod + def dbapi(cls): from google.appengine.api import rdbms return rdbms diff --git a/lib/sqlalchemy/dialects/mysql/pymysql.py b/lib/sqlalchemy/dialects/mysql/pymysql.py index e05d50d30..8387dfecb 100644 --- a/lib/sqlalchemy/dialects/mysql/pymysql.py +++ b/lib/sqlalchemy/dialects/mysql/pymysql.py @@ -20,20 +20,20 @@ Connect string:: MySQL-Python Compatibility -------------------------- -The pymysql DBAPI is a pure Python port of the MySQL-python (MySQLdb) driver, -and targets 100% compatibility. Most behavioral notes for MySQL-python apply to +The pymysql DBAPI is a pure Python port of the MySQL-python (MySQLdb) driver, +and targets 100% compatibility. Most behavioral notes for MySQL-python apply to the pymysql driver as well. """ -from sqlalchemy.dialects.mysql.mysqldb import MySQLDialect_mysqldb +from sqlalchemy.dialects.mysql.mysqldb import MySQLDialect_mysqldb -class MySQLDialect_pymysql(MySQLDialect_mysqldb): +class MySQLDialect_pymysql(MySQLDialect_mysqldb): driver = 'pymysql' description_encoding = None - @classmethod - def dbapi(cls): - return __import__('pymysql') + @classmethod + def dbapi(cls): + return __import__('pymysql') -dialect = MySQLDialect_pymysql
\ No newline at end of file +dialect = MySQLDialect_pymysql
\ No newline at end of file diff --git a/lib/sqlalchemy/dialects/oracle/base.py b/lib/sqlalchemy/dialects/oracle/base.py index 439568dd7..cbeac7791 100644 --- a/lib/sqlalchemy/dialects/oracle/base.py +++ b/lib/sqlalchemy/dialects/oracle/base.py @@ -14,7 +14,7 @@ for that driver. Connect Arguments ----------------- -The dialect supports several :func:`~sqlalchemy.create_engine()` arguments which +The dialect supports several :func:`~sqlalchemy.create_engine()` arguments which affect the behavior of the dialect regardless of driver in use. * *use_ansi* - Use ANSI JOIN constructs (see the section on Oracle 8). Defaults @@ -29,32 +29,32 @@ Auto Increment Behavior SQLAlchemy Table objects which include integer primary keys are usually assumed to have "autoincrementing" behavior, meaning they can generate their own primary key values upon -INSERT. Since Oracle has no "autoincrement" feature, SQLAlchemy relies upon sequences +INSERT. Since Oracle has no "autoincrement" feature, SQLAlchemy relies upon sequences to produce these values. With the Oracle dialect, *a sequence must always be explicitly -specified to enable autoincrement*. This is divergent with the majority of documentation +specified to enable autoincrement*. This is divergent with the majority of documentation examples which assume the usage of an autoincrement-capable database. To specify sequences, use the sqlalchemy.schema.Sequence object which is passed to a Column construct:: - t = Table('mytable', metadata, + t = Table('mytable', metadata, Column('id', Integer, Sequence('id_seq'), primary_key=True), Column(...), ... ) This step is also required when using table reflection, i.e. autoload=True:: - t = Table('mytable', metadata, + t = Table('mytable', metadata, Column('id', Integer, Sequence('id_seq'), primary_key=True), autoload=True - ) + ) Identifier Casing ----------------- -In Oracle, the data dictionary represents all case insensitive identifier names +In Oracle, the data dictionary represents all case insensitive identifier names using UPPERCASE text. SQLAlchemy on the other hand considers an all-lower case identifier name to be case insensitive. The Oracle dialect converts all case insensitive identifiers to and from those two formats during schema level communication, such as reflection of -tables and indexes. Using an UPPERCASE name on the SQLAlchemy side indicates a +tables and indexes. Using an UPPERCASE name on the SQLAlchemy side indicates a case sensitive identifier, and SQLAlchemy will quote the name - this will cause mismatches against data dictionary data received from Oracle, so unless identifier names have been truly created as case sensitive (i.e. using quoted names), all lowercase names should be @@ -72,16 +72,16 @@ Unicode Also note that Oracle supports unicode data through the NVARCHAR and NCLOB data types. When using the SQLAlchemy Unicode and UnicodeText types, these DDL types will be used -within CREATE TABLE statements. Usage of VARCHAR2 and CLOB with unicode text still +within CREATE TABLE statements. Usage of VARCHAR2 and CLOB with unicode text still requires NLS_LANG to be set. LIMIT/OFFSET Support -------------------- -Oracle has no support for the LIMIT or OFFSET keywords. SQLAlchemy uses -a wrapped subquery approach in conjunction with ROWNUM. The exact methodology +Oracle has no support for the LIMIT or OFFSET keywords. SQLAlchemy uses +a wrapped subquery approach in conjunction with ROWNUM. The exact methodology is taken from -http://www.oracle.com/technology/oramag/oracle/06-sep/o56asktom.html . +http://www.oracle.com/technology/oramag/oracle/06-sep/o56asktom.html . There are two options which affect its behavior: @@ -89,13 +89,13 @@ There are two options which affect its behavior: optimization directive, specify ``optimize_limits=True`` to :func:`.create_engine`. * the values passed for the limit/offset are sent as bound parameters. Some users have observed that Oracle produces a poor query plan when the values are sent as binds and not - rendered literally. To render the limit/offset values literally within the SQL + rendered literally. To render the limit/offset values literally within the SQL statement, specify ``use_binds_for_limits=False`` to :func:`.create_engine`. -Some users have reported better performance when the entirely different approach of a -window query is used, i.e. ROW_NUMBER() OVER (ORDER BY), to provide LIMIT/OFFSET (note -that the majority of users don't observe this). To suit this case the -method used for LIMIT/OFFSET can be replaced entirely. See the recipe at +Some users have reported better performance when the entirely different approach of a +window query is used, i.e. ROW_NUMBER() OVER (ORDER BY), to provide LIMIT/OFFSET (note +that the majority of users don't observe this). To suit this case the +method used for LIMIT/OFFSET can be replaced entirely. See the recipe at http://www.sqlalchemy.org/trac/wiki/UsageRecipes/WindowFunctionsByDefault which installs a select compiler that overrides the generation of limit/offset with a window function. @@ -103,11 +103,11 @@ a window function. ON UPDATE CASCADE ----------------- -Oracle doesn't have native ON UPDATE CASCADE functionality. A trigger based solution +Oracle doesn't have native ON UPDATE CASCADE functionality. A trigger based solution is available at http://asktom.oracle.com/tkyte/update_cascade/index.html . When using the SQLAlchemy ORM, the ORM has limited ability to manually issue -cascading updates - specify ForeignKey objects using the +cascading updates - specify ForeignKey objects using the "deferrable=True, initially='deferred'" keyword arguments, and specify "passive_updates=False" on each relationship(). @@ -121,21 +121,21 @@ behaviors: JOIN phrases into the WHERE clause, and in the case of LEFT OUTER JOIN makes use of Oracle's (+) operator. -* the NVARCHAR2 and NCLOB datatypes are no longer generated as DDL when - the :class:`~sqlalchemy.types.Unicode` is used - VARCHAR2 and CLOB are issued +* the NVARCHAR2 and NCLOB datatypes are no longer generated as DDL when + the :class:`~sqlalchemy.types.Unicode` is used - VARCHAR2 and CLOB are issued instead. This because these types don't seem to work correctly on Oracle 8 - even though they are available. The :class:`~sqlalchemy.types.NVARCHAR` + even though they are available. The :class:`~sqlalchemy.types.NVARCHAR` and :class:`~sqlalchemy.dialects.oracle.NCLOB` types will always generate NVARCHAR2 and NCLOB. -* the "native unicode" mode is disabled when using cx_oracle, i.e. SQLAlchemy +* the "native unicode" mode is disabled when using cx_oracle, i.e. SQLAlchemy encodes all Python unicode objects to "string" before passing in as bind parameters. Synonym/DBLINK Reflection ------------------------- When using reflection with Table objects, the dialect can optionally search for tables -indicated by synonyms that reference DBLINK-ed tables by passing the flag -oracle_resolve_synonyms=True as a keyword argument to the Table construct. If DBLINK +indicated by synonyms that reference DBLINK-ed tables by passing the flag +oracle_resolve_synonyms=True as a keyword argument to the Table construct. If DBLINK is not in use this flag should be left off. """ @@ -217,8 +217,8 @@ class LONG(sqltypes.Text): class INTERVAL(sqltypes.TypeEngine): __visit_name__ = 'INTERVAL' - def __init__(self, - day_precision=None, + def __init__(self, + day_precision=None, second_precision=None): """Construct an INTERVAL. @@ -303,10 +303,10 @@ class OracleTypeCompiler(compiler.GenericTypeCompiler): def visit_INTERVAL(self, type_): return "INTERVAL DAY%s TO SECOND%s" % ( - type_.day_precision is not None and + type_.day_precision is not None and "(%d)" % type_.day_precision or "", - type_.second_precision is not None and + type_.second_precision is not None and "(%d)" % type_.second_precision or "", ) @@ -340,7 +340,7 @@ class OracleTypeCompiler(compiler.GenericTypeCompiler): else: return "%(name)s(%(precision)s, %(scale)s)" % {'name':name,'precision': precision, 'scale' : scale} - def visit_string(self, type_): + def visit_string(self, type_): return self.visit_VARCHAR2(type_) def visit_VARCHAR2(self, type_): @@ -356,10 +356,10 @@ class OracleTypeCompiler(compiler.GenericTypeCompiler): def _visit_varchar(self, type_, n, num): if not n and self.dialect._supports_char_length: return "VARCHAR%(two)s(%(length)s CHAR)" % { - 'length' : type_.length, + 'length' : type_.length, 'two':num} else: - return "%(n)sVARCHAR%(two)s(%(length)s)" % {'length' : type_.length, + return "%(n)sVARCHAR%(two)s(%(length)s)" % {'length' : type_.length, 'two':num, 'n':n} def visit_text(self, type_): @@ -431,7 +431,7 @@ class OracleCompiler(compiler.SQLCompiler): return "" def default_from(self): - """Called when a ``SELECT`` statement has no froms, + """Called when a ``SELECT`` statement has no froms, and no ``FROM`` clause is to be appended. The Oracle compiler tacks a "FROM DUAL" to the statement. @@ -613,7 +613,7 @@ class OracleDDLCompiler(compiler.DDLCompiler): if constraint.ondelete is not None: text += " ON DELETE %s" % constraint.ondelete - # oracle has no ON UPDATE CASCADE - + # oracle has no ON UPDATE CASCADE - # its only available via triggers http://asktom.oracle.com/tkyte/update_cascade/index.html if constraint.onupdate is not None: util.warn( @@ -643,8 +643,8 @@ class OracleIdentifierPreparer(compiler.IdentifierPreparer): class OracleExecutionContext(default.DefaultExecutionContext): def fire_sequence(self, seq, type_): - return self._execute_scalar("SELECT " + - self.dialect.identifier_preparer.format_sequence(seq) + + return self._execute_scalar("SELECT " + + self.dialect.identifier_preparer.format_sequence(seq) + ".nextval FROM DUAL", type_) class OracleDialect(default.DefaultDialect): @@ -676,9 +676,9 @@ class OracleDialect(default.DefaultDialect): reflection_options = ('oracle_resolve_synonyms', ) - def __init__(self, - use_ansi=True, - optimize_limits=False, + def __init__(self, + use_ansi=True, + optimize_limits=False, use_binds_for_limits=True, **kwargs): default.DefaultDialect.__init__(self, **kwargs) @@ -808,8 +808,8 @@ class OracleDialect(default.DefaultDialect): if resolve_synonyms: actual_name, owner, dblink, synonym = self._resolve_synonym( - connection, - desired_owner=self.denormalize_name(schema), + connection, + desired_owner=self.denormalize_name(schema), desired_synonym=self.denormalize_name(table_name) ) else: @@ -876,11 +876,11 @@ class OracleDialect(default.DefaultDialect): char_length_col = 'char_length' else: char_length_col = 'data_length' - + c = connection.execute(sql.text( "SELECT column_name, data_type, %(char_length_col)s, data_precision, data_scale, " "nullable, data_default FROM ALL_TAB_COLUMNS%(dblink)s " - "WHERE table_name = :table_name AND owner = :owner " + "WHERE table_name = :table_name AND owner = :owner " "ORDER BY column_id" % {'dblink': dblink, 'char_length_col':char_length_col}), table_name=table_name, owner=schema) @@ -892,7 +892,7 @@ class OracleDialect(default.DefaultDialect): coltype = NUMBER(precision, scale) elif coltype in ('VARCHAR2', 'NVARCHAR2', 'CHAR'): coltype = self.ischema_names.get(coltype)(length) - elif 'WITH TIME ZONE' in coltype: + elif 'WITH TIME ZONE' in coltype: coltype = TIMESTAMP(timezone=True) else: coltype = re.sub(r'\(\d+\)', '', coltype) @@ -929,8 +929,8 @@ class OracleDialect(default.DefaultDialect): indexes = [] q = sql.text(""" SELECT a.index_name, a.column_name, b.uniqueness - FROM ALL_IND_COLUMNS%(dblink)s a, - ALL_INDEXES%(dblink)s b + FROM ALL_IND_COLUMNS%(dblink)s a, + ALL_INDEXES%(dblink)s b WHERE a.index_name = b.index_name AND a.table_owner = b.table_owner @@ -1091,8 +1091,8 @@ class OracleDialect(default.DefaultDialect): if resolve_synonyms: ref_remote_name, ref_remote_owner, ref_dblink, ref_synonym = \ self._resolve_synonym( - connection, - desired_owner=self.denormalize_name(remote_owner), + connection, + desired_owner=self.denormalize_name(remote_owner), desired_table=self.denormalize_name(remote_table) ) if ref_synonym: diff --git a/lib/sqlalchemy/dialects/postgresql/psycopg2.py b/lib/sqlalchemy/dialects/postgresql/psycopg2.py index 44ed7fc91..8976ca990 100644 --- a/lib/sqlalchemy/dialects/postgresql/psycopg2.py +++ b/lib/sqlalchemy/dialects/postgresql/psycopg2.py @@ -10,7 +10,7 @@ Driver ------ The psycopg2 driver is available at http://pypi.python.org/pypi/psycopg2/ . -The dialect has several behaviors which are specifically tailored towards compatibility +The dialect has several behaviors which are specifically tailored towards compatibility with this module. Note that psycopg1 is **not** supported. @@ -48,7 +48,7 @@ which specifies Unix-domain communication rather than TCP/IP communication:: create_engine("postgresql+psycopg2://user:password@/dbname") By default, the socket file used is to connect to a Unix-domain socket -in ``/tmp``, or whatever socket directory was specified when PostgreSQL +in ``/tmp``, or whatever socket directory was specified when PostgreSQL was built. This value can be overridden by passing a pathname to psycopg2, using ``host`` as an additional keyword argument:: @@ -61,11 +61,11 @@ See also: Per-Statement/Connection Execution Options ------------------------------------------- -The following DBAPI-specific options are respected when used with +The following DBAPI-specific options are respected when used with :meth:`.Connection.execution_options`, :meth:`.Executable.execution_options`, :meth:`.Query.execution_options`, in addition to those not specific to DBAPIs: -* isolation_level - Set the transaction isolation level for the lifespan of a +* isolation_level - Set the transaction isolation level for the lifespan of a :class:`.Connection` (can only be set on a connection, not a statement or query). This includes the options ``SERIALIZABLE``, ``READ COMMITTED``, ``READ UNCOMMITTED`` and ``REPEATABLE READ``. @@ -79,8 +79,8 @@ By default, the psycopg2 driver uses the ``psycopg2.extensions.UNICODE`` extension, such that the DBAPI receives and returns all strings as Python Unicode objects directly - SQLAlchemy passes these values through without change. Psycopg2 here will encode/decode string values based on the -current "client encoding" setting; by default this is the value in -the ``postgresql.conf`` file, which often defaults to ``SQL_ASCII``. +current "client encoding" setting; by default this is the value in +the ``postgresql.conf`` file, which often defaults to ``SQL_ASCII``. Typically, this can be changed to ``utf-8``, as a more useful default:: #client_encoding = sql_ascii # actually, defaults to database @@ -90,7 +90,7 @@ Typically, this can be changed to ``utf-8``, as a more useful default:: A second way to affect the client encoding is to set it within Psycopg2 locally. SQLAlchemy will call psycopg2's ``set_client_encoding()`` method (see: http://initd.org/psycopg/docs/connection.html#connection.set_client_encoding) -on all new connections based on the value passed to +on all new connections based on the value passed to :func:`.create_engine` using the ``client_encoding`` parameter:: engine = create_engine("postgresql://user:pass@host/dbname", client_encoding='utf8') @@ -102,15 +102,15 @@ This overrides the encoding specified in the Postgresql client configuration. SQLAlchemy can also be instructed to skip the usage of the psycopg2 ``UNICODE`` extension and to instead utilize it's own unicode encode/decode -services, which are normally reserved only for those DBAPIs that don't -fully support unicode directly. Passing ``use_native_unicode=False`` +services, which are normally reserved only for those DBAPIs that don't +fully support unicode directly. Passing ``use_native_unicode=False`` to :func:`.create_engine` will disable usage of ``psycopg2.extensions.UNICODE``. -SQLAlchemy will instead encode data itself into Python bytestrings on the way +SQLAlchemy will instead encode data itself into Python bytestrings on the way in and coerce from bytes on the way back, -using the value of the :func:`.create_engine` ``encoding`` parameter, which +using the value of the :func:`.create_engine` ``encoding`` parameter, which defaults to ``utf-8``. SQLAlchemy's own unicode encode/decode functionality is steadily becoming -obsolete as more DBAPIs support unicode fully along with the approach of +obsolete as more DBAPIs support unicode fully along with the approach of Python 3; in modern usage psycopg2 should be relied upon to handle unicode. Transactions @@ -132,7 +132,7 @@ at the API level what level should be used. NOTICE logging --------------- -The psycopg2 dialect will log Postgresql NOTICE messages via the +The psycopg2 dialect will log Postgresql NOTICE messages via the ``sqlalchemy.dialects.postgresql`` logger:: import logging @@ -220,8 +220,8 @@ class PGExecutionContext_psycopg2(PGExecutionContext): (self.compiled and isinstance(self.compiled.statement, expression.Selectable) \ or \ ( - (not self.compiled or - isinstance(self.compiled.statement, expression.TextClause)) + (not self.compiled or + isinstance(self.compiled.statement, expression.TextClause)) and self.statement and SERVER_SIDE_CURSOR_RE.match(self.statement)) ) ) @@ -249,7 +249,7 @@ class PGExecutionContext_psycopg2(PGExecutionContext): def _log_notices(self, cursor): for notice in cursor.connection.notices: - # NOTICE messages have a + # NOTICE messages have a # newline character at the end logger.info(notice.rstrip()) @@ -291,7 +291,7 @@ class PGDialect_psycopg2(PGDialect): } ) - def __init__(self, server_side_cursors=False, use_native_unicode=True, + def __init__(self, server_side_cursors=False, use_native_unicode=True, client_encoding=None, **kwargs): PGDialect.__init__(self, **kwargs) self.server_side_cursors = server_side_cursors @@ -299,12 +299,12 @@ class PGDialect_psycopg2(PGDialect): self.supports_unicode_binds = use_native_unicode self.client_encoding = client_encoding if self.dbapi and hasattr(self.dbapi, '__version__'): - m = re.match(r'(\d+)\.(\d+)(?:\.(\d+))?', + m = re.match(r'(\d+)\.(\d+)(?:\.(\d+))?', self.dbapi.__version__) if m: self.psycopg2_version = tuple( - int(x) - for x in m.group(1, 2, 3) + int(x) + for x in m.group(1, 2, 3) if x is not None) @classmethod @@ -316,8 +316,8 @@ class PGDialect_psycopg2(PGDialect): def _isolation_lookup(self): extensions = __import__('psycopg2.extensions').extensions return { - 'READ COMMITTED':extensions.ISOLATION_LEVEL_READ_COMMITTED, - 'READ UNCOMMITTED':extensions.ISOLATION_LEVEL_READ_UNCOMMITTED, + 'READ COMMITTED':extensions.ISOLATION_LEVEL_READ_COMMITTED, + 'READ UNCOMMITTED':extensions.ISOLATION_LEVEL_READ_UNCOMMITTED, 'REPEATABLE READ':extensions.ISOLATION_LEVEL_REPEATABLE_READ, 'SERIALIZABLE':extensions.ISOLATION_LEVEL_SERIALIZABLE } @@ -328,9 +328,9 @@ class PGDialect_psycopg2(PGDialect): except KeyError: raise exc.ArgumentError( "Invalid value '%s' for isolation_level. " - "Valid isolation levels for %s are %s" % + "Valid isolation levels for %s are %s" % (level, self.name, ", ".join(self._isolation_lookup)) - ) + ) connection.set_isolation_level(level) @@ -370,8 +370,8 @@ class PGDialect_psycopg2(PGDialect): def is_disconnect(self, e, connection, cursor): if isinstance(e, self.dbapi.OperationalError): # these error messages from libpq: interfaces/libpq/fe-misc.c. - # TODO: these are sent through gettext in libpq and we can't - # check within other locales - consider using connection.closed + # TODO: these are sent through gettext in libpq and we can't + # check within other locales - consider using connection.closed return 'closed the connection' in str(e) or \ 'connection not open' in str(e) or \ 'could not receive data from server' in str(e) @@ -380,7 +380,7 @@ class PGDialect_psycopg2(PGDialect): return 'connection already closed' in str(e) or \ 'cursor already closed' in str(e) elif isinstance(e, self.dbapi.ProgrammingError): - # not sure where this path is originally from, it may + # not sure where this path is originally from, it may # be obsolete. It really says "losed", not "closed". return "losed the connection unexpectedly" in str(e) else: diff --git a/lib/sqlalchemy/dialects/sybase/base.py b/lib/sqlalchemy/dialects/sybase/base.py index affef974c..f551bff99 100644 --- a/lib/sqlalchemy/dialects/sybase/base.py +++ b/lib/sqlalchemy/dialects/sybase/base.py @@ -1,8 +1,8 @@ # sybase/base.py # Copyright (C) 2010-2011 the SQLAlchemy authors and contributors <see AUTHORS file> # get_select_precolumns(), limit_clause() implementation -# copyright (C) 2007 Fisch Asset Management -# AG http://www.fam.ch, with coding by Alexander Houben +# copyright (C) 2007 Fisch Asset Management +# AG http://www.fam.ch, with coding by Alexander Houben # alexander.houben@thor-solutions.ch # # This module is part of SQLAlchemy and is released under @@ -13,7 +13,7 @@ .. note:: The Sybase dialect functions on current SQLAlchemy versions - but is not regularly tested, and may have many issues and + but is not regularly tested, and may have many issues and caveats not currently handled. In particular, the table and database reflection features are not implemented. @@ -130,7 +130,7 @@ class UNIQUEIDENTIFIER(sqltypes.TypeEngine): class IMAGE(sqltypes.LargeBinary): __visit_name__ = 'IMAGE' - + class SybaseTypeCompiler(compiler.GenericTypeCompiler): def visit_large_binary(self, type_): @@ -224,12 +224,12 @@ class SybaseExecutionContext(default.DefaultExecutionContext): self._enable_identity_insert = False if self._enable_identity_insert: - self.cursor.execute("SET IDENTITY_INSERT %s ON" % + self.cursor.execute("SET IDENTITY_INSERT %s ON" % self.dialect.identifier_preparer.format_table(tbl)) if self.isddl: # TODO: to enhance this, we can detect "ddl in tran" on the - # database settings. this error message should be improved to + # database settings. this error message should be improved to # include a note about that. if not self.should_autocommit: raise exc.InvalidRequestError( @@ -240,7 +240,7 @@ class SybaseExecutionContext(default.DefaultExecutionContext): "AUTOCOMMIT (Assuming no Sybase 'ddl in tran')") self.set_ddl_autocommit( - self.root_connection.connection.connection, + self.root_connection.connection.connection, True) @@ -304,7 +304,7 @@ class SybaseSQLCompiler(compiler.SQLCompiler): field, self.process(extract.expr, **kw)) def for_update_clause(self, select): - # "FOR UPDATE" is only allowed on "DECLARE CURSOR" + # "FOR UPDATE" is only allowed on "DECLARE CURSOR" # which SQLAlchemy doesn't use return '' |