opts['client_flag'] = client_flag
return [[], opts]
- def create_execution_context(self, *args, **kwargs):
- return MySQLExecutionContext(self, *args, **kwargs)
+ def create_execution_context(self, connection, **kwargs):
+ return MySQLExecutionContext(self, connection, **kwargs)
def type_descriptor(self, typeobj):
return sqltypes.adapt_type(typeobj, colspecs)
def schemadropper(self, *args, **kwargs):
return MySQLSchemaDropper(self, *args, **kwargs)
- def do_executemany(self, cursor, statement, parameters,
- context=None, **kwargs):
+ def do_executemany(self, cursor, statement, parameters, context=None):
rowcount = cursor.executemany(statement, parameters)
if context is not None:
context._rowcount = rowcount
def supports_unicode_statements(self):
return True
- def do_execute(self, cursor, statement, parameters, **kwargs):
+ def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters)
def do_commit(self, connection):
# creation of foreign key constraints fails."
class MySQLSchemaGenerator(compiler.SchemaGenerator):
- def get_column_specification(self, column, override_pk=False,
- first_pk=False):
+ def get_column_specification(self, column, first_pk=False):
"""Builds column DDL."""
colspec = [self.preparer.format_column(column),
warnings.warn(RuntimeWarning(
"Did not recognize type '%s' of column '%s'" %
(type_, name)))
- coltype = sqltypes.NULLTYPE
+ col_type = sqltypes.NULLTYPE
# Column type positional arguments eg. varchar(32)
if args is None or args == '':
if ref_key in table.metadata.tables:
ref_table = table.metadata.tables[ref_key]
else:
- ref_table = schema.Table(ref_name, table.metadata,
- schema=ref_schema,
- autoload=True, autoload_with=connection)
+ ref_table = schema.Table(
+ ref_name, table.metadata, schema=ref_schema,
+ autoload=True, autoload_with=connection)
ref_names = spec['foreign']
if not util.Set(ref_names).issubset(
util.Set([c.name for c in ref_table.c])):
raise exceptions.InvalidRequestError(
- "Foreign key columns (%s) are not present on foreign table" %
+ "Foreign key columns (%s) are not present on "
+ "foreign table %s" %
(', '.join(ref_names), ref_table.fullname()))
ref_columns = [ref_table.c[name] for name in ref_names]
self._pr_options = []
self._re_options_util = {}
- _initial, _final = (self.preparer.initial_quote,
- self.preparer.final_quote)
+ _final = self.preparer.final_quote
quotes = dict(zip(('iq', 'fq', 'esc_fq'),
[re.escape(s) for s in
(self.preparer.initial_quote,
- self.preparer.final_quote,
+ _final,
self.preparer._escape_identifier(_final))]))
self._pr_name = _pr_compile(
def _quote_free_identifiers(self, *ids):
"""Unilaterally identifier-quote any number of strings."""
- return tuple([self.quote_identifier(id) for id in ids if id is not None])
+ return tuple([self.quote_identifier(i) for i in ids if i is not None])
class MySQLIdentifierPreparer(_MySQLIdentifierPreparer):
return "SMALLINT"
class DateTimeMixin(object):
+ __format__ = "%Y-%m-%d %H:%M:%S"
+
def bind_processor(self, dialect):
def process(value):
if isinstance(value, basestring):
(value, microsecond) = value.split('.')
microsecond = int(microsecond)
except ValueError:
- (value, microsecond) = (value, 0)
+ microsecond = 0
return time.strptime(value, self.__format__)[0:6] + (microsecond,)
class SLDateTime(DateTimeMixin,sqltypes.DateTime):
def type_descriptor(self, typeobj):
return sqltypes.adapt_type(typeobj, colspecs)
- def create_execution_context(self, **kwargs):
- return SQLiteExecutionContext(self, **kwargs)
-
- def last_inserted_ids(self):
- return self.context.last_inserted_ids
+ def create_execution_context(self, connection, **kwargs):
+ return SQLiteExecutionContext(self, connection, **kwargs)
def oid_column_name(self, column):
return "oid"
row = c.fetchone()
if row is None:
break
- #print "row! " + repr(row)
+
found_table = True
- (name, type, nullable, has_default, primary_key) = (row[1], row[2].upper(), not row[3], row[4] is not None, row[5])
+ (name, type_, nullable, has_default, primary_key) = (row[1], row[2].upper(), not row[3], row[4] is not None, row[5])
name = re.sub(r'^\"|\"$', '', name)
if include_columns and name not in include_columns:
continue
- match = re.match(r'(\w+)(\(.*?\))?', type)
+ match = re.match(r'(\w+)(\(.*?\))?', type_)
if match:
coltype = match.group(1)
args = match.group(2)
coltype = "VARCHAR"
args = ''
- #print "coltype: " + repr(coltype) + " args: " + repr(args)
try:
coltype = pragma_names[coltype]
except KeyError:
if args is not None:
args = re.findall(r'(\d+)', args)
- #print "args! " +repr(args)
coltype = coltype(*[int(a) for a in args])
colargs= []
if row is None:
break
cols.append(row[2])
- col = table.columns[row[2]]
+
class SQLiteCompiler(compiler.DefaultCompiler):
- def visit_cast(self, cast):
+ def visit_cast(self, cast, **kwargs):
if self.dialect.supports_cast:
return super(SQLiteCompiler, self).visit_cast(cast)
else:
- if self.select_stack:
+ if self.stack and self.stack[-1].get('select'):
# not sure if we want to set the typemap here...
self.typemap.setdefault("CAST", cast.type)
return self.process(cast.clause)
raise NotImplementedError()
- def do_executemany(self, cursor, statement, parameters):
+ def do_executemany(self, cursor, statement, parameters, context=None):
"""Provide an implementation of *cursor.executemany(statement, parameters)*."""
raise NotImplementedError()
- def do_execute(self, cursor, statement, parameters):
+ def do_execute(self, cursor, statement, parameters, context=None):
"""Provide an implementation of *cursor.execute(statement, parameters)*."""
raise NotImplementedError()
return {}
- def create_execution_context(self, **kwargs):
- return DefaultExecutionContext(self, **kwargs)
+ def create_execution_context(self, connection, **kwargs):
+ return DefaultExecutionContext(self, connection, **kwargs)
def type_descriptor(self, typeobj):
"""Provide a database-specific ``TypeEngine`` object, given
def do_release_savepoint(self, connection, name):
connection.execute(expression.ReleaseSavepointClause(name))
- def do_executemany(self, cursor, statement, parameters, **kwargs):
+ def do_executemany(self, cursor, statement, parameters, context=None):
cursor.executemany(statement, parameters)
- def do_execute(self, cursor, statement, parameters, **kwargs):
+ def do_execute(self, cursor, statement, parameters, context=None):
cursor.execute(statement, parameters)
def is_disconnect(self, e):
providing implementations for the hooks you'll be using.
"""
- def connect(dbapi_con, con_record):
+ def connect(self, dbapi_con, con_record):
"""Called once for each new DB-API connection or Pool's ``creator()``.
dbapi_con
"""
- def checkout(dbapi_con, con_record, con_proxy):
+ def checkout(self, dbapi_con, con_record, con_proxy):
"""Called when a connection is retrieved from the Pool.
dbapi_con
using the new connection.
"""
- def checkin(dbapi_con, con_record):
+ def checkin(self, dbapi_con, con_record):
"""Called when a connection returns to the pool.
Note that the connection may be closed, and may be None if the
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
