Use the 'bind' keyword argument.
- sql
+
+ - the "autocommit" flag on select() and text() as well
+ as select().autocommit() are deprecated - now call
+ .execution_options(autocommit=True) on either of those
+ constructs, also available directly on Connection and orm.Query.
+
- the autoincrement flag on column now indicates the column
which should be linked to cursor.lastrowid, if that method
is used. See the API docs for details.
- transaction isolation level may be specified with
create_engine(... isolation_level="..."); available on
postgresql and sqlite. [ticket:443]
-
+
- Connection has execution_options(), generative method
which accepts keywords that affect how the statement
is executed w.r.t. the DBAPI. Currently supports
"stream_results", causes psycopg2 to use a server
- side cursor for that statement. Can also be set
- upon select() and text() constructs directly as well
- as ORM Query().
+ side cursor for that statement, as well as
+ "autocommit", which is the new location for the "autocommit"
+ option from select() and text(). select() and
+ text() also have .execution_options() as well as
+ ORM Query().
- fixed the import for entrypoint-driven dialects to
not rely upon silly tb_info trick to determine import
self.dialect = dialect
self._connection = self.root_connection = connection
self.engine = connection.engine
- self.execution_options = connection._execution_options
if compiled_ddl is not None:
self.compiled = compiled = compiled_ddl
self.isinsert = compiled.isinsert
self.isupdate = compiled.isupdate
self.isdelete = compiled.isdelete
- if compiled.statement._execution_options:
- self.execution_options =\
- compiled.statement._execution_options.union(self.execution_options)
if not parameters:
self.compiled_parameters = [compiled.construct_params()]
self.cursor = self.create_cursor()
@util.memoized_property
- def should_autocommit(self):
+ def execution_options(self):
if self.compiled:
- autocommit = self.compiled.statement._autocommit
- if autocommit is expression.PARSE_AUTOCOMMIT:
+ return self.compiled.statement._execution_options.union(
+ self._connection._execution_options)
+ else:
+ return self._connection._execution_options
+
+ @util.memoized_property
+ def should_autocommit(self):
+ autocommit = self.execution_options.get('autocommit', expression.PARSE_AUTOCOMMIT)
+ if autocommit is expression.PARSE_AUTOCOMMIT:
+ if self.statement:
return self.should_autocommit_text(self.statement)
else:
- return autocommit
- elif self.statement:
- return self.should_autocommit_text(self.statement)
+ return False
else:
- return False
+ return autocommit
@util.memoized_property
def _is_explicit_returning(self):
class DDLElement(expression._Executable, expression.ClauseElement):
"""Base class for DDL expression constructs."""
- _autocommit = True
+ _execution_options = expression._Executable.\
+ _execution_options.union({'autocommit':True})
target = None
on = None
Additional parameters include:
autocommit
- indicates this SELECT statement modifies the database, and
- should be subject to autocommit behavior if no transaction
- has been started.
+ Deprecated. Use .execution_options(autocommit=<True|False>)
+ to set the autocommit option.
prefixes
a list of strings or :class:`ClauseElement` objects to include
an optional connection or engine to be used for this text query.
autocommit=True
- indicates this SELECT statement modifies the database, and
- should be subject to autocommit behavior if no transaction
- has been started.
+ Deprecated. Use .execution_options(autocommit=<True|False>)
+ to set the autocommit option.
bindparams
a list of :func:`bindparam()` instances which can be used to define
@_generative
def execution_options(self, **kw):
- """ Set non-SQL options for the statement, such as dialect-specific options.
-
- The options available are covered in the respective dialect's section.
+ """ Set non-SQL options for the statement which take effect during execution.
+
+ Current options include:
+
+ * autocommit - when True, a COMMIT will be invoked after execution
+ when executed in 'autocommit' mode, i.e. when an explicit transaction
+ is not begun on the connection. Note that DBAPI connections by
+ default are always in a transaction - SQLAlchemy uses rules applied
+ to different kinds of statements to determine if COMMIT will be invoked
+ in order to provide its "autocommit" feature. Typically, all
+ INSERT/UPDATE/DELETE statements as well as CREATE/DROP statements
+ have autocommit behavior enabled; SELECT constructs do not. Use this
+ option when invokving a SELECT or other specific SQL construct
+ where COMMIT is desired (typically when calling stored procedures
+ and such).
+
+ * stream_results - indicate to the dialect that results should be
+ "streamed" and not pre-buffered, if possible. This is a limitation
+ of many DBAPIs. The flag is currently understood only by the
+ psycopg2 dialect.
"""
self._execution_options = self._execution_options.union(kw)
__visit_name__ = 'textclause'
_bind_params_regex = re.compile(r'(?<![:\w\x5c]):(\w+)(?!:)', re.UNICODE)
-
+ _execution_options = _Executable._execution_options.union({'autocommit':PARSE_AUTOCOMMIT})
+
@property
def _select_iterable(self):
return (self,)
def __init__(self, text = "", bind=None,
bindparams=None, typemap=None,
- autocommit=PARSE_AUTOCOMMIT):
+ autocommit=None):
self._bind = bind
self.bindparams = {}
self.typemap = typemap
- self._autocommit = autocommit
+
+ if autocommit is not None:
+ util.warn_deprecated("autocommit on text() is deprecated. "
+ "Use .execution_options(autocommit=True)")
+ self._execution_options = self._execution_options.union({'autocommit':autocommit})
+
if typemap is not None:
for key in typemap.keys():
typemap[key] = sqltypes.to_instance(typemap[key])
self.original = baseselectable
self.supports_execution = baseselectable.supports_execution
if self.supports_execution:
- self._autocommit = baseselectable._autocommit
self._execution_options = baseselectable._execution_options
self.element = selectable
if alias is None:
order_by=None,
group_by=None,
bind=None,
- autocommit=False):
+ autocommit=None):
self.use_labels = use_labels
self.for_update = for_update
- self._autocommit = autocommit
+ if autocommit is not None:
+ util.warn_deprecated("autocommit on select() is deprecated. "
+ "Use .execution_options(autocommit=True)")
+ self._execution_options = self._execution_options.union({'autocommit':autocommit})
self._limit = limit
self._offset = offset
self._bind = bind
return self.as_scalar().label(name)
@_generative
+ @util.deprecated(message="autocommit() is deprecated. "
+ "Use .execution_options(autocommit=True)")
def autocommit(self):
"""return a new selectable with the 'autocommit' flag set to True."""
-
- self._autocommit = True
+
+ self._execution_options = self._execution_options.union({'autocommit':True})
def _generate(self):
s = self.__class__.__new__(self.__class__)
__visit_name__ = 'update_base'
- _autocommit = True
+ _execution_options = _Executable._execution_options.union({'autocommit':True})
def _generate(self):
s = self.__class__.__new__(self.__class__)
class _IdentifiedClause(_Executable, ClauseElement):
__visit_name__ = 'identified'
- _autocommit = False
+ _execution_options = _Executable._execution_options.union({'autocommit':False})
quote = None
def __init__(self, ident):
users.drop(conn2)
conn2.close()
-foo = None
class ExplicitAutoCommitTest(TestBase):
"""test the 'autocommit' flag on select() and text() objects.
def setup_class(cls):
global metadata, foo
metadata = MetaData(testing.db)
- foo = Table('foo', metadata, Column('id', Integer, primary_key=True), Column('data', String(100)))
+ foo = Table('foo', metadata,
+ Column('id', Integer, primary_key=True),
+ Column('data', String(100))
+ )
metadata.create_all()
- testing.db.execute("create function insert_foo(varchar) returns integer as 'insert into foo(data) values ($1);select 1;' language sql")
+ testing.db.execute("create function insert_foo(varchar) returns integer "
+ "as 'insert into foo(data) values ($1);select 1;' language sql")
def teardown(self):
foo.delete().execute().close()
conn1 = testing.db.connect()
conn2 = testing.db.connect()
+ conn1.execute(select([func.insert_foo('data1')]).execution_options(autocommit=True))
+ assert conn2.execute(select([foo.c.data])).fetchall() == [('data1',)]
+
+ conn1.close()
+ conn2.close()
+
+ def test_explicit_connection(self):
+ conn1 = testing.db.connect()
+ conn2 = testing.db.connect()
+
+ conn1.execution_options(autocommit=True).\
+ execute(select([func.insert_foo('data1')]))
+ eq_(
+ conn2.execute(select([foo.c.data])).fetchall(),
+ [('data1',), ]
+ )
+
+ # connection supercedes statement
+ conn1.execution_options(autocommit=False).\
+ execute(
+ select([func.insert_foo('data2')]).
+ execution_options(autocommit=True)
+ )
+ eq_(
+ conn2.execute(select([foo.c.data])).fetchall(),
+ [('data1',), ]
+ )
+
+ # ditto
+ conn1.execution_options(autocommit=True).\
+ execute(
+ select([func.insert_foo('data3')]).
+ execution_options(autocommit=False)
+ )
+ eq_(
+ conn2.execute(select([foo.c.data])).fetchall(),
+ [('data1',), ('data2', ), ('data3',)]
+ )
+
+ conn1.close()
+ conn2.close()
+
+ def test_explicit_text(self):
+ conn1 = testing.db.connect()
+ conn2 = testing.db.connect()
+
+ conn1.execute(
+ text("select insert_foo('moredata')").
+ execution_options(autocommit=True)
+ )
+ assert conn2.execute(select([foo.c.data])).fetchall() == [('moredata',)]
+
+ conn1.close()
+ conn2.close()
+
+ @testing.uses_deprecated(r'autocommit on select\(\) is deprecated',
+ r'autocommit\(\) is deprecated')
+ def test_explicit_compiled_deprecated(self):
+ conn1 = testing.db.connect()
+ conn2 = testing.db.connect()
+
conn1.execute(select([func.insert_foo('data1')], autocommit=True))
assert conn2.execute(select([foo.c.data])).fetchall() == [('data1',)]
conn1.close()
conn2.close()
- def test_explicit_text(self):
+ @testing.uses_deprecated(r'autocommit on text\(\) is deprecated')
+ def test_explicit_text_deprecated(self):
conn1 = testing.db.connect()
conn2 = testing.db.connect()
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
