[3] | 1 | # engine/default.py |
---|
| 2 | # Copyright (C) 2005, 2006, 2007, 2008, 2009 Michael Bayer mike_mp@zzzcomputing.com |
---|
| 3 | # |
---|
| 4 | # This module is part of SQLAlchemy and is released under |
---|
| 5 | # the MIT License: http://www.opensource.org/licenses/mit-license.php |
---|
| 6 | |
---|
| 7 | """Default implementations of per-dialect sqlalchemy.engine classes. |
---|
| 8 | |
---|
| 9 | These are semi-private implementation classes which are only of importance |
---|
| 10 | to database dialect authors; dialects will usually use the classes here |
---|
| 11 | as the base class for their own corresponding classes. |
---|
| 12 | |
---|
| 13 | """ |
---|
| 14 | |
---|
| 15 | import re, random |
---|
| 16 | from sqlalchemy.engine import base |
---|
| 17 | from sqlalchemy.sql import compiler, expression |
---|
| 18 | from sqlalchemy import exc |
---|
| 19 | |
---|
| 20 | AUTOCOMMIT_REGEXP = re.compile(r'\s*(?:UPDATE|INSERT|CREATE|DELETE|DROP|ALTER)', |
---|
| 21 | re.I | re.UNICODE) |
---|
| 22 | |
---|
| 23 | class DefaultDialect(base.Dialect): |
---|
| 24 | """Default implementation of Dialect""" |
---|
| 25 | |
---|
| 26 | name = 'default' |
---|
| 27 | schemagenerator = compiler.SchemaGenerator |
---|
| 28 | schemadropper = compiler.SchemaDropper |
---|
| 29 | statement_compiler = compiler.DefaultCompiler |
---|
| 30 | preparer = compiler.IdentifierPreparer |
---|
| 31 | defaultrunner = base.DefaultRunner |
---|
| 32 | supports_alter = True |
---|
| 33 | supports_unicode_statements = False |
---|
| 34 | max_identifier_length = 9999 |
---|
| 35 | supports_sane_rowcount = True |
---|
| 36 | supports_sane_multi_rowcount = True |
---|
| 37 | preexecute_pk_sequences = False |
---|
| 38 | supports_pk_autoincrement = True |
---|
| 39 | dbapi_type_map = {} |
---|
| 40 | default_paramstyle = 'named' |
---|
| 41 | supports_default_values = False |
---|
| 42 | supports_empty_insert = True |
---|
| 43 | |
---|
| 44 | def __init__(self, convert_unicode=False, assert_unicode=False, |
---|
| 45 | encoding='utf-8', paramstyle=None, dbapi=None, |
---|
| 46 | label_length=None, **kwargs): |
---|
| 47 | self.convert_unicode = convert_unicode |
---|
| 48 | self.assert_unicode = assert_unicode |
---|
| 49 | self.encoding = encoding |
---|
| 50 | self.positional = False |
---|
| 51 | self._ischema = None |
---|
| 52 | self.dbapi = dbapi |
---|
| 53 | if paramstyle is not None: |
---|
| 54 | self.paramstyle = paramstyle |
---|
| 55 | elif self.dbapi is not None: |
---|
| 56 | self.paramstyle = self.dbapi.paramstyle |
---|
| 57 | else: |
---|
| 58 | self.paramstyle = self.default_paramstyle |
---|
| 59 | self.positional = self.paramstyle in ('qmark', 'format', 'numeric') |
---|
| 60 | self.identifier_preparer = self.preparer(self) |
---|
| 61 | if label_length and label_length > self.max_identifier_length: |
---|
| 62 | raise exc.ArgumentError("Label length of %d is greater than this dialect's maximum identifier length of %d" % (label_length, self.max_identifier_length)) |
---|
| 63 | self.label_length = label_length |
---|
| 64 | self.description_encoding = getattr(self, 'description_encoding', encoding) |
---|
| 65 | |
---|
| 66 | def type_descriptor(self, typeobj): |
---|
| 67 | """Provide a database-specific ``TypeEngine`` object, given |
---|
| 68 | the generic object which comes from the types module. |
---|
| 69 | |
---|
| 70 | Subclasses will usually use the ``adapt_type()`` method in the |
---|
| 71 | types module to make this job easy.""" |
---|
| 72 | |
---|
| 73 | if type(typeobj) is type: |
---|
| 74 | typeobj = typeobj() |
---|
| 75 | return typeobj |
---|
| 76 | |
---|
| 77 | def validate_identifier(self, ident): |
---|
| 78 | if len(ident) > self.max_identifier_length: |
---|
| 79 | raise exc.IdentifierError("Identifier '%s' exceeds maximum length of %d characters" % (ident, self.max_identifier_length)) |
---|
| 80 | |
---|
| 81 | def do_begin(self, connection): |
---|
| 82 | """Implementations might want to put logic here for turning |
---|
| 83 | autocommit on/off, etc. |
---|
| 84 | """ |
---|
| 85 | |
---|
| 86 | pass |
---|
| 87 | |
---|
| 88 | def do_rollback(self, connection): |
---|
| 89 | """Implementations might want to put logic here for turning |
---|
| 90 | autocommit on/off, etc. |
---|
| 91 | """ |
---|
| 92 | |
---|
| 93 | connection.rollback() |
---|
| 94 | |
---|
| 95 | def do_commit(self, connection): |
---|
| 96 | """Implementations might want to put logic here for turning |
---|
| 97 | autocommit on/off, etc. |
---|
| 98 | """ |
---|
| 99 | |
---|
| 100 | connection.commit() |
---|
| 101 | |
---|
| 102 | def create_xid(self): |
---|
| 103 | """Create a random two-phase transaction ID. |
---|
| 104 | |
---|
| 105 | This id will be passed to do_begin_twophase(), do_rollback_twophase(), |
---|
| 106 | do_commit_twophase(). Its format is unspecified.""" |
---|
| 107 | |
---|
| 108 | return "_sa_%032x" % random.randint(0, 2 ** 128) |
---|
| 109 | |
---|
| 110 | def do_savepoint(self, connection, name): |
---|
| 111 | connection.execute(expression.SavepointClause(name)) |
---|
| 112 | |
---|
| 113 | def do_rollback_to_savepoint(self, connection, name): |
---|
| 114 | connection.execute(expression.RollbackToSavepointClause(name)) |
---|
| 115 | |
---|
| 116 | def do_release_savepoint(self, connection, name): |
---|
| 117 | connection.execute(expression.ReleaseSavepointClause(name)) |
---|
| 118 | |
---|
| 119 | def do_executemany(self, cursor, statement, parameters, context=None): |
---|
| 120 | cursor.executemany(statement, parameters) |
---|
| 121 | |
---|
| 122 | def do_execute(self, cursor, statement, parameters, context=None): |
---|
| 123 | cursor.execute(statement, parameters) |
---|
| 124 | |
---|
| 125 | def is_disconnect(self, e): |
---|
| 126 | return False |
---|
| 127 | |
---|
| 128 | |
---|
| 129 | class DefaultExecutionContext(base.ExecutionContext): |
---|
| 130 | def __init__(self, dialect, connection, compiled=None, statement=None, parameters=None): |
---|
| 131 | self.dialect = dialect |
---|
| 132 | self._connection = self.root_connection = connection |
---|
| 133 | self.compiled = compiled |
---|
| 134 | self.engine = connection.engine |
---|
| 135 | |
---|
| 136 | if compiled is not None: |
---|
| 137 | # compiled clauseelement. process bind params, process table defaults, |
---|
| 138 | # track collections used by ResultProxy to target and process results |
---|
| 139 | |
---|
| 140 | if not compiled.can_execute: |
---|
| 141 | raise exc.ArgumentError("Not an executable clause: %s" % compiled) |
---|
| 142 | |
---|
| 143 | self.processors = dict( |
---|
| 144 | (key, value) for key, value in |
---|
| 145 | ( (compiled.bind_names[bindparam], |
---|
| 146 | bindparam.bind_processor(self.dialect)) |
---|
| 147 | for bindparam in compiled.bind_names ) |
---|
| 148 | if value is not None) |
---|
| 149 | |
---|
| 150 | self.result_map = compiled.result_map |
---|
| 151 | |
---|
| 152 | if not dialect.supports_unicode_statements: |
---|
| 153 | self.statement = unicode(compiled).encode(self.dialect.encoding) |
---|
| 154 | else: |
---|
| 155 | self.statement = unicode(compiled) |
---|
| 156 | |
---|
| 157 | self.isinsert = compiled.isinsert |
---|
| 158 | self.isupdate = compiled.isupdate |
---|
| 159 | self.should_autocommit = compiled.statement._autocommit |
---|
| 160 | if isinstance(compiled.statement, expression._TextClause): |
---|
| 161 | self.should_autocommit = self.should_autocommit or self.should_autocommit_text(self.statement) |
---|
| 162 | |
---|
| 163 | if not parameters: |
---|
| 164 | self.compiled_parameters = [compiled.construct_params()] |
---|
| 165 | self.executemany = False |
---|
| 166 | else: |
---|
| 167 | self.compiled_parameters = [compiled.construct_params(m) for m in parameters] |
---|
| 168 | self.executemany = len(parameters) > 1 |
---|
| 169 | |
---|
| 170 | self.cursor = self.create_cursor() |
---|
| 171 | if self.isinsert or self.isupdate: |
---|
| 172 | self.__process_defaults() |
---|
| 173 | self.parameters = self.__convert_compiled_params(self.compiled_parameters) |
---|
| 174 | |
---|
| 175 | elif statement is not None: |
---|
| 176 | # plain text statement. |
---|
| 177 | self.result_map = None |
---|
| 178 | self.parameters = self.__encode_param_keys(parameters) |
---|
| 179 | self.executemany = len(parameters) > 1 |
---|
| 180 | if isinstance(statement, unicode) and not dialect.supports_unicode_statements: |
---|
| 181 | self.statement = statement.encode(self.dialect.encoding) |
---|
| 182 | else: |
---|
| 183 | self.statement = statement |
---|
| 184 | self.isinsert = self.isupdate = False |
---|
| 185 | self.cursor = self.create_cursor() |
---|
| 186 | self.should_autocommit = self.should_autocommit_text(statement) |
---|
| 187 | else: |
---|
| 188 | # no statement. used for standalone ColumnDefault execution. |
---|
| 189 | self.statement = None |
---|
| 190 | self.isinsert = self.isupdate = self.executemany = self.should_autocommit = False |
---|
| 191 | self.cursor = self.create_cursor() |
---|
| 192 | |
---|
| 193 | @property |
---|
| 194 | def connection(self): |
---|
| 195 | return self._connection._branch() |
---|
| 196 | |
---|
| 197 | def __encode_param_keys(self, params): |
---|
| 198 | """apply string encoding to the keys of dictionary-based bind parameters. |
---|
| 199 | |
---|
| 200 | This is only used executing textual, non-compiled SQL expressions.""" |
---|
| 201 | |
---|
| 202 | if self.dialect.positional or self.dialect.supports_unicode_statements: |
---|
| 203 | if params: |
---|
| 204 | return params |
---|
| 205 | elif self.dialect.positional: |
---|
| 206 | return [()] |
---|
| 207 | else: |
---|
| 208 | return [{}] |
---|
| 209 | else: |
---|
| 210 | def proc(d): |
---|
| 211 | # sigh, sometimes we get positional arguments with a dialect |
---|
| 212 | # that doesnt specify positional (because of execute_text()) |
---|
| 213 | if not isinstance(d, dict): |
---|
| 214 | return d |
---|
| 215 | return dict((k.encode(self.dialect.encoding), d[k]) for k in d) |
---|
| 216 | return [proc(d) for d in params] or [{}] |
---|
| 217 | |
---|
| 218 | def __convert_compiled_params(self, compiled_parameters): |
---|
| 219 | """convert the dictionary of bind parameter values into a dict or list |
---|
| 220 | to be sent to the DBAPI's execute() or executemany() method. |
---|
| 221 | """ |
---|
| 222 | |
---|
| 223 | processors = self.processors |
---|
| 224 | parameters = [] |
---|
| 225 | if self.dialect.positional: |
---|
| 226 | for compiled_params in compiled_parameters: |
---|
| 227 | param = [] |
---|
| 228 | for key in self.compiled.positiontup: |
---|
| 229 | if key in processors: |
---|
| 230 | param.append(processors[key](compiled_params[key])) |
---|
| 231 | else: |
---|
| 232 | param.append(compiled_params[key]) |
---|
| 233 | parameters.append(param) |
---|
| 234 | else: |
---|
| 235 | encode = not self.dialect.supports_unicode_statements |
---|
| 236 | for compiled_params in compiled_parameters: |
---|
| 237 | param = {} |
---|
| 238 | if encode: |
---|
| 239 | encoding = self.dialect.encoding |
---|
| 240 | for key in compiled_params: |
---|
| 241 | if key in processors: |
---|
| 242 | param[key.encode(encoding)] = processors[key](compiled_params[key]) |
---|
| 243 | else: |
---|
| 244 | param[key.encode(encoding)] = compiled_params[key] |
---|
| 245 | else: |
---|
| 246 | for key in compiled_params: |
---|
| 247 | if key in processors: |
---|
| 248 | param[key] = processors[key](compiled_params[key]) |
---|
| 249 | else: |
---|
| 250 | param[key] = compiled_params[key] |
---|
| 251 | parameters.append(param) |
---|
| 252 | return parameters |
---|
| 253 | |
---|
| 254 | def should_autocommit_text(self, statement): |
---|
| 255 | return AUTOCOMMIT_REGEXP.match(statement) |
---|
| 256 | |
---|
| 257 | def create_cursor(self): |
---|
| 258 | return self._connection.connection.cursor() |
---|
| 259 | |
---|
| 260 | def pre_exec(self): |
---|
| 261 | pass |
---|
| 262 | |
---|
| 263 | def post_exec(self): |
---|
| 264 | pass |
---|
| 265 | |
---|
| 266 | def handle_dbapi_exception(self, e): |
---|
| 267 | pass |
---|
| 268 | |
---|
| 269 | def get_result_proxy(self): |
---|
| 270 | return base.ResultProxy(self) |
---|
| 271 | |
---|
| 272 | def get_rowcount(self): |
---|
| 273 | if hasattr(self, '_rowcount'): |
---|
| 274 | return self._rowcount |
---|
| 275 | else: |
---|
| 276 | return self.cursor.rowcount |
---|
| 277 | |
---|
| 278 | def supports_sane_rowcount(self): |
---|
| 279 | return self.dialect.supports_sane_rowcount |
---|
| 280 | |
---|
| 281 | def supports_sane_multi_rowcount(self): |
---|
| 282 | return self.dialect.supports_sane_multi_rowcount |
---|
| 283 | |
---|
| 284 | def last_inserted_ids(self): |
---|
| 285 | return self._last_inserted_ids |
---|
| 286 | |
---|
| 287 | def last_inserted_params(self): |
---|
| 288 | return self._last_inserted_params |
---|
| 289 | |
---|
| 290 | def last_updated_params(self): |
---|
| 291 | return self._last_updated_params |
---|
| 292 | |
---|
| 293 | def lastrow_has_defaults(self): |
---|
| 294 | return hasattr(self, 'postfetch_cols') and len(self.postfetch_cols) |
---|
| 295 | |
---|
| 296 | def set_input_sizes(self): |
---|
| 297 | """Given a cursor and ClauseParameters, call the appropriate |
---|
| 298 | style of ``setinputsizes()`` on the cursor, using DB-API types |
---|
| 299 | from the bind parameter's ``TypeEngine`` objects. |
---|
| 300 | """ |
---|
| 301 | |
---|
| 302 | types = dict( |
---|
| 303 | (self.compiled.bind_names[bindparam], bindparam.type) |
---|
| 304 | for bindparam in self.compiled.bind_names) |
---|
| 305 | |
---|
| 306 | if self.dialect.positional: |
---|
| 307 | inputsizes = [] |
---|
| 308 | for key in self.compiled.positiontup: |
---|
| 309 | typeengine = types[key] |
---|
| 310 | dbtype = typeengine.dialect_impl(self.dialect).get_dbapi_type(self.dialect.dbapi) |
---|
| 311 | if dbtype is not None: |
---|
| 312 | inputsizes.append(dbtype) |
---|
| 313 | try: |
---|
| 314 | self.cursor.setinputsizes(*inputsizes) |
---|
| 315 | except Exception, e: |
---|
| 316 | self._connection._handle_dbapi_exception(e, None, None, None, self) |
---|
| 317 | raise |
---|
| 318 | else: |
---|
| 319 | inputsizes = {} |
---|
| 320 | for key in self.compiled.bind_names.values(): |
---|
| 321 | typeengine = types[key] |
---|
| 322 | dbtype = typeengine.dialect_impl(self.dialect).get_dbapi_type(self.dialect.dbapi) |
---|
| 323 | if dbtype is not None: |
---|
| 324 | inputsizes[key.encode(self.dialect.encoding)] = dbtype |
---|
| 325 | try: |
---|
| 326 | self.cursor.setinputsizes(**inputsizes) |
---|
| 327 | except Exception, e: |
---|
| 328 | self._connection._handle_dbapi_exception(e, None, None, None, self) |
---|
| 329 | raise |
---|
| 330 | |
---|
| 331 | def __process_defaults(self): |
---|
| 332 | """generate default values for compiled insert/update statements, |
---|
| 333 | and generate last_inserted_ids() collection.""" |
---|
| 334 | |
---|
| 335 | if self.executemany: |
---|
| 336 | if len(self.compiled.prefetch): |
---|
| 337 | drunner = self.dialect.defaultrunner(self) |
---|
| 338 | params = self.compiled_parameters |
---|
| 339 | for param in params: |
---|
| 340 | # assign each dict of params to self.compiled_parameters; |
---|
| 341 | # this allows user-defined default generators to access the full |
---|
| 342 | # set of bind params for the row |
---|
| 343 | self.compiled_parameters = param |
---|
| 344 | for c in self.compiled.prefetch: |
---|
| 345 | if self.isinsert: |
---|
| 346 | val = drunner.get_column_default(c) |
---|
| 347 | else: |
---|
| 348 | val = drunner.get_column_onupdate(c) |
---|
| 349 | if val is not None: |
---|
| 350 | param[c.key] = val |
---|
| 351 | self.compiled_parameters = params |
---|
| 352 | |
---|
| 353 | else: |
---|
| 354 | compiled_parameters = self.compiled_parameters[0] |
---|
| 355 | drunner = self.dialect.defaultrunner(self) |
---|
| 356 | |
---|
| 357 | for c in self.compiled.prefetch: |
---|
| 358 | if self.isinsert: |
---|
| 359 | val = drunner.get_column_default(c) |
---|
| 360 | else: |
---|
| 361 | val = drunner.get_column_onupdate(c) |
---|
| 362 | |
---|
| 363 | if val is not None: |
---|
| 364 | compiled_parameters[c.key] = val |
---|
| 365 | |
---|
| 366 | if self.isinsert: |
---|
| 367 | self._last_inserted_ids = [compiled_parameters.get(c.key, None) for c in self.compiled.statement.table.primary_key] |
---|
| 368 | self._last_inserted_params = compiled_parameters |
---|
| 369 | else: |
---|
| 370 | self._last_updated_params = compiled_parameters |
---|
| 371 | |
---|
| 372 | self.postfetch_cols = self.compiled.postfetch |
---|
| 373 | self.prefetch_cols = self.compiled.prefetch |
---|
| 374 | |
---|
| 375 | DefaultDialect.execution_ctx_cls = DefaultExecutionContext |
---|