~ubuntu-branches/debian/jessie/sqlalchemy/jessie

          URL_ROOT:    './',

          VERSION:     '0.8.3',

        Release: <span class="version-num">0.8.3</span> | Release Date: October 26, 2013

<dt id="term-acid"><span id="term-acid-model"></span>ACID<br />ACID model</dt>

<dd><p class="first">An acronym for &#8220;Atomicity, Consistency, Isolation,

Durability&#8221;; a set of properties that guarantee that

database transactions are processed reliably.

(via Wikipedia)</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p><a class="reference internal" href="#term-atomicity"><em class="xref std std-term">atomicity</em></a></p>

<p><a class="reference internal" href="#term-consistency"><em class="xref std std-term">consistency</em></a></p>

<p><a class="reference internal" href="#term-isolation"><em class="xref std std-term">isolation</em></a></p>

<p><a class="reference internal" href="#term-durability"><em class="xref std std-term">durability</em></a></p>

<p class="last"><a class="reference external" href="http://en.wikipedia.org/wiki/ACID_Model">http://en.wikipedia.org/wiki/ACID_Model</a></p>

</div>

</dd>

additional information along with <a class="reference internal" href="core/sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><tt class="xref py py-class docutils literal"><span class="pre">ClauseElement</span></tt></a> objects.  A Python

<p class="last">The annotation system differs from the public dictionary <a class="reference internal" href="core/metadata.html#sqlalchemy.schema.Column.info" title="sqlalchemy.schema.Column.info"><tt class="xref py py-attr docutils literal"><span class="pre">Column.info</span></tt></a>

in that the above annotation operation creates a <em>copy</em> of the new <a class="reference internal" href="core/metadata.html#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><tt class="xref py py-class docutils literal"><span class="pre">Column</span></tt></a>,

<dt id="term-atomicity">atomicity</dt>

<dd><p class="first">Atomicity is one of the components of the <a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a> model,

and requires that each transaction is &#8220;all or nothing&#8221;:

if one part of the transaction fails, the entire transaction

fails, and the database state is left unchanged. An atomic

system must guarantee atomicity in each and every situation,

including power failures, errors, and crashes.

(via Wikipedia)</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p><a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a></p>

<p class="last"><a class="reference external" href="http://en.wikipedia.org/wiki/Atomicity_(database_systems">http://en.wikipedia.org/wiki/Atomicity_(database_systems</a>)</p>

</div>

</dd>

<dt id="term-consistency">consistency</dt>

<dd><p class="first">Consistency is one of the compoments of the <a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a> model,

and ensures that any transaction will

bring the database from one valid state to another. Any data

written to the database must be valid according to all defined

rules, including but not limited to <em class="xref std std-term">constraints</em>, cascades,

triggers, and any combination thereof.

(via Wikipedia)</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p><a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a></p>

<p class="last"><a class="reference external" href="http://en.wikipedia.org/wiki/Consistency_(database_systems">http://en.wikipedia.org/wiki/Consistency_(database_systems</a>)</p>

</div>

</dd>

<div class="last admonition seealso">

starting out as <a class="reference internal" href="core/metadata.html#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><tt class="xref py py-class docutils literal"><span class="pre">Column</span></tt></a> objects, will be replaced

<div class="last admonition seealso">

<dt id="term-durability">durability</dt>

<dd><p class="first">Durability is a property of the <a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a> model

which means that once a transaction has been committed,

it will remain so, even in the event of power loss, crashes,

or errors. In a relational database, for instance, once a

group of SQL statements execute, the results need to be stored

permanently (even if the database crashes immediately

thereafter).

(via Wikipedia)</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p><a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a></p>

<p class="last"><a class="reference external" href="http://en.wikipedia.org/wiki/Durability_(database_systems">http://en.wikipedia.org/wiki/Durability_(database_systems</a>)</p>

</div>

</dd>

<dt id="term-identity-map">identity map</dt>

<dd><p class="first">A mapping between Python objects and their database identities.

The identity map is a collection that&#8217;s associated with an

ORM <a class="reference internal" href="#term-session"><em class="xref std std-term">session</em></a> object, and maintains a single instance

of every database object keyed to its identity.   The advantage

to this pattern is that all operations which occur for a particular

database identity are transparently coordinated onto a single

object instance.  When using an identity map in conjunction with

an <a class="reference internal" href="#term-isolated"><em class="xref std std-term">isolated</em></a> transaction, having a reference

to an object that&#8217;s known to have a particular primary key can

be considered from a practical standpoint to be a

proxy to the actual database row.</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p class="last">Martin Fowler - Identity Map - <a class="reference external" href="http://martinfowler.com/eaaCatalog/identityMap.html">http://martinfowler.com/eaaCatalog/identityMap.html</a></p>

</div>

</dd>

<dt id="term-isolation"><span id="term-isolated"></span>isolation<br />isolated</dt>

<dd><p class="first">The isolation property of the <a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a> model

ensures that the concurrent execution

of transactions results in a system state that would be

obtained if transactions were executed serially, i.e. one

after the other. Each transaction must execute in total

isolation i.e. if T1 and T2 execute concurrently then each

should remain independent of the other.

(via Wikipedia)</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p><a class="reference internal" href="#term-acid"><em class="xref std std-term">ACID</em></a></p>

<p class="last"><a class="reference external" href="http://en.wikipedia.org/wiki/Isolation_(database_systems">http://en.wikipedia.org/wiki/Isolation_(database_systems</a>)</p>

</div>

</dd>

<div class="last admonition seealso">

method chaining are the <a class="reference internal" href="core/selectable.html#sqlalchemy.sql.expression.Select" title="sqlalchemy.sql.expression.Select"><tt class="xref py py-class docutils literal"><span class="pre">Select</span></tt></a>

For example, a <a class="reference internal" href="core/selectable.html#sqlalchemy.sql.expression.Select" title="sqlalchemy.sql.expression.Select"><tt class="xref py py-class docutils literal"><span class="pre">Select</span></tt></a> object can

as an ORDER BY clause by calling upon the <a class="reference internal" href="core/selectable.html#sqlalchemy.sql.expression.Select.where" title="sqlalchemy.sql.expression.Select.where"><tt class="xref py py-meth docutils literal"><span class="pre">where()</span></tt></a>

and <a class="reference internal" href="core/selectable.html#sqlalchemy.sql.expression.Select.order_by" title="sqlalchemy.sql.expression.Select.order_by"><tt class="xref py py-meth docutils literal"><span class="pre">order_by()</span></tt></a> methods:</p>

<a class="reference internal" href="core/selectable.html#sqlalchemy.sql.expression.Select" title="sqlalchemy.sql.expression.Select"><tt class="xref py py-class docutils literal"><span class="pre">Select</span></tt></a> object with additional qualifiers

<div class="last admonition seealso">

<div class="last admonition seealso">

updates, etc. acquires <a class="reference internal" href="#term-isolated"><em class="xref std std-term">isolated</em></a> state upon

<div class="last admonition seealso">

<dt id="term-returning">RETURNING</dt>

<dd><p class="first">This is a non-SQL standard clause provided in various forms by

certain backends, which provides the service of returning a result

set upon execution of an INSERT, UPDATE or DELETE statement.  Any set

of columns from the matched rows can be returned, as though they were

produced from a SELECT statement.</p>

<p>The RETURNING clause provides both a dramatic performance boost to

common update/select scenarios, including retrieval of inline- or

default- generated primary key values and defaults at the moment they

were created, as well as a way to get at server-generated

default values in an atomic way.</p>

<p>An example of RETURNING, idiomatic to Postgresql, looks like:</p>

<div class="highlight-python"><pre>INSERT INTO user_account (name) VALUES ('new name') RETURNING id, timestamp</pre>

</div>

<p>Above, the INSERT statement will provide upon execution a result set

which includes the values of the columns <tt class="docutils literal"><span class="pre">user_account.id</span></tt> and

<tt class="docutils literal"><span class="pre">user_account.timestamp</span></tt>, which above should have been generated as default

values as they are not included otherwise (but note any series of columns

or SQL expressions can be placed into RETURNING, not just default-value columns).</p>

<p>The backends that currently support

RETURNING or a similar construct are Postgresql, SQL Server, Oracle,

and Firebird.    The Postgresql and Firebird implementations are generally

full featured, whereas the implementations of SQL Server and Oracle

have caveats. On SQL Server, the clause is known as &#8220;OUTPUT INSERTED&#8221;

for INSERT and UPDATE statements and &#8220;OUTPUT DELETED&#8221; for DELETE statements;

the key caveat is that triggers are not supported in conjunction with this

keyword.  On Oracle, it is known as &#8220;RETURNING...INTO&#8221;, and requires that the

value be placed into an OUT paramter, meaning not only is the syntax awkward,

but it can also only be used for one row at a time.</p>

<p class="last">SQLAlchemy&#8217;s <a class="reference internal" href="core/dml.html#sqlalchemy.sql.expression.UpdateBase.returning" title="sqlalchemy.sql.expression.UpdateBase.returning"><tt class="xref py py-meth docutils literal"><span class="pre">UpdateBase.returning()</span></tt></a> system provides a layer of abstraction

on top of the RETURNING systems of these backends to provide a consistent

interface for returning columns.  The ORM also includes many optimizations

that make use of RETURNING when available.</p>

</dd>

<dt id="term-session">Session</dt>

<dd><p class="first">The container or scope for ORM database operations. Sessions

load instances from the database, track changes to mapped

instances and persist changes in a single unit of work when

flushed.</p>

<div class="last admonition seealso">

<p class="first admonition-title">See also</p>

<p class="last"><a class="reference internal" href="orm/session.html"><em>Using the Session</em></a></p>

</div>

</dd>

<div class="last admonition seealso">

        Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.2b1.