:tickets:
Column with no name (as in declarative) won't raise a
- NoneType error when it's string output is requsted
+ NoneType error when its string output is requested
(such as in a stack trace).
.. change::
The Column.references() method now returns True
if it has a foreign key referencing the
- given column exactly, not just it's parent
+ given column exactly, not just its parent
table.
.. change::
* **SessionExtension.** - This is an easy to use extension
class for session events. In particular, it provides
``before_flush()``, ``after_flush()`` and
- ``after_flush_postexec()`` methods. It's usage is
+ ``after_flush_postexec()`` methods. This usage is
recommended over ``MapperExtension.before_XXX`` in many
cases since within ``before_flush()`` you can modify the
flush plan of the session freely, something which cannot
* **get()/load() cleanup**
- The ``load()`` method has been removed. It's
+ The ``load()`` method has been removed. Its
functionality was kind of arbitrary and basically copied
from Hibernate, where it's also not a particularly
meaningful method.
really drives what kinds of operations are present, it's the
*type* of the expression. The implementation details are
minimal - only a few extra methods are added to the core
-:class:`.ColumnElement` type so that it consults it's
+:class:`.ColumnElement` type so that it consults its
:class:`.TypeEngine` object for an optional set of operators.
New or revised operations can be associated with any type,
either via subclassing of an existing type, by using
cursor.execute("select foo")
The purpose of the transparent proxy is to intercept the ``close()`` call,
-such that instead of the DBAPI connection being closed, it's returned to the
+such that instead of the DBAPI connection being closed, it is returned to the
pool::
# "close" the connection. Returns
At the expense of some extra SQL emitted for each connection checked out from the pool,
a "ping" operation established by a checkout event handler
-can detect an invalid connection before it's used::
+can detect an invalid connection before it is used::
from sqlalchemy import exc
from sqlalchemy import event
The custom criteria we use in a :paramref:`~.relationship.primaryjoin`
is generally only significant when SQLAlchemy is rendering SQL in
-order to load or represent this relationship. That is, it's used in
+order to load or represent this relationship. That is, it's used in
the SQL statement that's emitted in order to perform a per-attribute
lazy load, or when a join is constructed at query time, such as via
:meth:`.Query.join`, or via the eager "joined" or "subquery" styles of
copies of itself that are local to individual :class:`~.Session`
objects.
- In the caching use case, it's common that the ``load=False`` flag
- is used to remove the overhead of reconciling the object's state
+ In the caching use case, it's common to use the ``load=False``
+ flag to remove the overhead of reconciling the object's state
with the database. There's also a "bulk" version of
:meth:`~.Session.merge` called :meth:`~.Query.merge_result`
that was designed to work with cache-extended :class:`.Query`
A subtransaction indicates usage of the :meth:`.Session.begin` method in conjunction with
the ``subtransactions=True`` flag. This produces a non-transactional, delimiting construct that
allows nesting of calls to :meth:`~.Session.begin` and :meth:`~.Session.commit`.
-It's purpose is to allow the construction of code that can function within a transaction
+Its purpose is to allow the construction of code that can function within a transaction
both independently of any external code that starts a transaction,
as well as within a block that has already demarcated a transaction.
self.process(binary.right, **kw))
def get_select_precolumns(self, select):
- """ MS-SQL puts TOP, it's version of LIMIT here """
+ """ MS-SQL puts TOP, its version of LIMIT, here """
if select._distinct or select._limit is not None:
s = select._distinct and "DISTINCT " or ""
if dbtype is None:
raise exc.InvalidRequestError(
"Cannot create out parameter for parameter "
- "%r - it's type %r is not supported by"
+ "%r - its type %r is not supported by"
" cx_oracle" %
(bindparam.key, bindparam.type)
)
a. The string name should be matched to the most specific type possible within
sqlalchemy.types, unless there is no matching type within sqlalchemy.types in which
- case it points to a dialect type. *It doesn't matter* if the dialect has it's
+ case it points to a dialect type. *It doesn't matter* if the dialect has its
own subclass of that type with special bind/result behavior - reflect to the types.py
UPPERCASE type as much as possible. With very few exceptions, all types
should reflect to an UPPERCASE type.
The engine package defines the basic components used to interface
DB-API modules with higher-level statement construction,
connection-management, execution and result contexts. The primary
-"entry point" class into this package is the Engine and it's public
+"entry point" class into this package is the Engine and its public
constructor ``create_engine()``.
This package includes:
execution options which will take effect for a call to
:meth:`execute`. As the new :class:`.Connection` references the same
underlying resource, it's usually a good idea to ensure that the copies
- would be discarded immediately, which is implicit if used as in::
+ will be discarded immediately, which is implicit if used as in::
result = connection.execution_options(stream_results=True).\\
execute(stmt)
-------------------
The "GREATEST" function is given any number of arguments and returns the one
-that is of the highest value - it's equivalent to Python's ``max``
+that is of the highest value - its equivalent to Python's ``max``
function. A SQL standard version versus a CASE based version which only
accommodates two arguments::
The converter method will receive the object being assigned and should
return an iterable of values suitable for use by the ``appender``
method. A converter must not assign values or mutate the collection,
- it's sole job is to adapt the value the user provides into an iterable
+ its sole job is to adapt the value the user provides into an iterable
of values for the ORM's use.
The default converter implementation will use duck-typing to do the
return EXT_CONTINUE
def init_instance(self, mapper, class_, oldinit, instance, args, kwargs):
- """Receive an instance when it's constructor is called.
+ """Receive an instance when its constructor is called.
This method is only called during a userland construction of
an object. It is not called when an object is loaded from the
return EXT_CONTINUE
def init_failed(self, mapper, class_, oldinit, instance, args, kwargs):
- """Receive an instance when it's constructor has been called,
+ """Receive an instance when its constructor has been called,
and raised an exception.
This method is only called during a userland construction of
"""
def init(self, target, args, kwargs):
- """Receive an instance when it's constructor is called.
+ """Receive an instance when its constructor is called.
This method is only called during a userland construction of
an object. It is not called when an object is loaded from the
"""
def init_failure(self, target, args, kwargs):
- """Receive an instance when it's constructor has been called,
+ """Receive an instance when its constructor has been called,
and raised an exception.
This method is only called during a userland construction of
"""
def unpickle(self, target, state_dict):
- """Receive an object instance after it's associated state has
+ """Receive an object instance after its associated state has
been unpickled.
:param target: the mapped instance. If
class next_value(GenericFunction):
"""Represent the 'next value', given a :class:`.Sequence`
- as it's single argument.
+ as its single argument.
Compiles into the appropriate function on each backend,
or will raise NotImplementedError if used on a backend
i = [1]
# the times here is cranked way up so that we can see
- # pysqlite clearing out it's internal buffer and allow
+ # pysqlite clearing out its internal buffer and allow
# the test to pass
@testing.emits_warning()
@profile_memory()
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
