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

« back to all changes in this revision

Viewing changes to doc/dialects/postgresql.html

  • Committer: Package Import Robot
  • Author(s): Piotr Ożarowski
  • Date: 2013-10-28 22:29:40 UTC
  • mfrom: (1.4.24)
  • Revision ID: package-import@ubuntu.com-20131028222940-wvyqffl4g617caun
Tags: 0.8.3-1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
    <script type="text/javascript">
21
21
      var DOCUMENTATION_OPTIONS = {
22
22
          URL_ROOT:    '../',
23
 
          VERSION:     '0.8.2',
 
23
          VERSION:     '0.8.3',
24
24
          COLLAPSE_MODINDEX: false,
25
25
          FILE_SUFFIX: '.html'
26
26
      };
67
67
    </div>
68
68
 
69
69
    <div id="docs-version-header">
70
 
        Release: <span class="version-num">0.8.2</span> | Release Date: July 3, 2013
 
70
        Release: <span class="version-num">0.8.3</span> | Release Date: October 26, 2013
71
71
 
72
72
 
73
73
    </div>
210
210
integer-based primary key columns, which generates a sequence and server side
211
211
default corresponding to the column.</p>
212
212
<p>To specify a specific named sequence to be used for primary key generation,
213
 
use the <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><tt class="xref py py-func docutils literal"><span class="pre">Sequence()</span></tt></a> construct:</p>
 
213
use the <a class="reference internal" href="../core/defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><tt class="xref py py-func docutils literal"><span class="pre">Sequence()</span></tt></a> construct:</p>
214
214
<div class="highlight-python"><div class="highlight"><pre><span class="n">Table</span><span class="p">(</span><span class="s">&#39;sometable&#39;</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span>
215
215
        <span class="n">Column</span><span class="p">(</span><span class="s">&#39;id&#39;</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">Sequence</span><span class="p">(</span><span class="s">&#39;some_id_seq&#39;</span><span class="p">),</span> <span class="n">primary_key</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
216
216
    <span class="p">)</span></pre></div>
223
223
sequence, whether specified explicitly or implicitly via <tt class="docutils literal"><span class="pre">SERIAL</span></tt>, is
224
224
executed independently beforehand, the returned value to be used in the
225
225
subsequent insert. Note that when an
226
 
<a class="reference internal" href="../core/expression_api.html#sqlalchemy.sql.expression.insert" title="sqlalchemy.sql.expression.insert"><tt class="xref py py-func docutils literal"><span class="pre">insert()</span></tt></a> construct is executed using
 
226
<a class="reference internal" href="../core/dml.html#sqlalchemy.sql.expression.insert" title="sqlalchemy.sql.expression.insert"><tt class="xref py py-func docutils literal"><span class="pre">insert()</span></tt></a> construct is executed using
227
227
&#8220;executemany&#8221; semantics, the &#8220;last inserted identifier&#8221; functionality does not
228
228
apply; no RETURNING clause is emitted nor is the sequence pre-executed in this
229
229
case.</p>
263
263
<h2>Remote / Cross-Schema Table Introspection<a class="headerlink" href="#remote-cross-schema-table-introspection" title="Permalink to this headline">¶</a></h2>
264
264
<p>Tables can be introspected from any accessible schema, including
265
265
inter-schema foreign key relationships.   However, care must be taken
266
 
when specifying the &#8220;schema&#8221; argument for a given <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>, when
 
266
when specifying the &#8220;schema&#8221; argument for a given <a class="reference internal" href="../core/metadata.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>, when
267
267
the given schema is also present in PostgreSQL&#8217;s <tt class="docutils literal"><span class="pre">search_path</span></tt> variable
268
268
for the current connection.</p>
269
269
<p>If a FOREIGN KEY constraint reports that the remote table&#8217;s schema is within
270
270
the current <tt class="docutils literal"><span class="pre">search_path</span></tt>, the &#8220;schema&#8221; attribute of the resulting
271
 
<a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a> will be set to <tt class="docutils literal"><span class="pre">None</span></tt>, unless the actual schema of the
 
271
<a class="reference internal" href="../core/metadata.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a> will be set to <tt class="docutils literal"><span class="pre">None</span></tt>, unless the actual schema of the
272
272
remote table matches that of the referencing table, and the &#8220;schema&#8221; argument
273
273
was explicitly stated on the referencing table.</p>
274
274
<p>The best practice here is to not use the <tt class="docutils literal"><span class="pre">schema</span></tt> argument
275
 
on <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a> for any schemas that are present in <tt class="docutils literal"><span class="pre">search_path</span></tt>.
 
275
on <a class="reference internal" href="../core/metadata.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a> for any schemas that are present in <tt class="docutils literal"><span class="pre">search_path</span></tt>.
276
276
<tt class="docutils literal"><span class="pre">search_path</span></tt> defaults to &#8220;public&#8221;, but care should be taken
277
277
to inspect the actual value using:</p>
278
278
<div class="highlight-python"><pre>SHOW search_path;</pre>
279
279
</div>
280
 
<p class="versionchanged">
281
 
<span class="versionmodified">Changed in version 0.7.3: </span>Prior to this version, cross-schema foreign keys when the schemas
 
280
<div class="versionchanged">
 
281
<p><span>Changed in version 0.7.3: </span>Prior to this version, cross-schema foreign keys when the schemas
282
282
were also in the <tt class="docutils literal"><span class="pre">search_path</span></tt> could make an incorrect assumption
283
 
if the schemas were explicitly stated on each <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>.</p>
 
283
if the schemas were explicitly stated on each <a class="reference internal" href="../core/metadata.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>.</p>
 
284
</div>
284
285
<p>Background on PG&#8217;s <tt class="docutils literal"><span class="pre">search_path</span></tt> is at:
285
286
<a class="reference external" href="http://www.postgresql.org/docs/9.0/static/ddl-schemas.html#DDL-SCHEMAS-PATH">http://www.postgresql.org/docs/9.0/static/ddl-schemas.html#DDL-SCHEMAS-PATH</a></p>
286
287
</div>
327
328
</div>
328
329
<div class="section" id="postgresql-specific-index-options">
329
330
<span id="postgresql-indexes"></span><h2>Postgresql-Specific Index Options<a class="headerlink" href="#postgresql-specific-index-options" title="Permalink to this headline">¶</a></h2>
330
 
<p>Several extensions to the <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> construct are available, specific
 
331
<p>Several extensions to the <a class="reference internal" href="../core/constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> construct are available, specific
331
332
to the PostgreSQL dialect.</p>
332
333
<div class="section" id="partial-indexes">
333
334
<h3>Partial Indexes<a class="headerlink" href="#partial-indexes" title="Permalink to this headline">¶</a></h3>
334
335
<p>Partial indexes add criterion to the index definition so that the index is
335
 
applied to a subset of rows.   These can be specified on <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a>
 
336
applied to a subset of rows.   These can be specified on <a class="reference internal" href="../core/constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a>
336
337
using the <tt class="docutils literal"><span class="pre">postgresql_where</span></tt> keyword argument:</p>
337
338
<div class="highlight-python"><div class="highlight"><pre><span class="n">Index</span><span class="p">(</span><span class="s">&#39;my_index&#39;</span><span class="p">,</span> <span class="n">my_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span><span class="p">,</span> <span class="n">postgresql_where</span><span class="o">=</span><span class="n">tbl</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">value</span> <span class="o">&gt;</span> <span class="mi">10</span><span class="p">)</span></pre></div>
338
339
</div>
342
343
<p>PostgreSQL allows the specification of an <em>operator class</em> for each column of
343
344
an index (see
344
345
<a class="reference external" href="http://www.postgresql.org/docs/8.3/interactive/indexes-opclass.html">http://www.postgresql.org/docs/8.3/interactive/indexes-opclass.html</a>).
345
 
The <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> construct allows these to be specified via the
 
346
The <a class="reference internal" href="../core/constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> construct allows these to be specified via the
346
347
<tt class="docutils literal"><span class="pre">postgresql_ops</span></tt> keyword argument:</p>
347
348
<div class="highlight-python"><div class="highlight"><pre><span class="n">Index</span><span class="p">(</span><span class="s">&#39;my_index&#39;</span><span class="p">,</span> <span class="n">my_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span><span class="p">,</span> <span class="n">my_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">data</span><span class="p">,</span>
348
349
                        <span class="n">postgresql_ops</span><span class="o">=</span><span class="p">{</span>
350
351
                            <span class="s">&#39;id&#39;</span><span class="p">:</span> <span class="s">&#39;int4_ops&#39;</span>
351
352
                        <span class="p">})</span></pre></div>
352
353
</div>
353
 
<p class="versionadded">
354
 
<span class="versionmodified">New in version 0.7.2: </span><tt class="docutils literal"><span class="pre">postgresql_ops</span></tt> keyword argument to <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> construct.</p>
 
354
<div class="versionadded">
 
355
<p><span>New in version 0.7.2: </span><tt class="docutils literal"><span class="pre">postgresql_ops</span></tt> keyword argument to <a class="reference internal" href="../core/constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> construct.</p>
 
356
</div>
355
357
<p>Note that the keys in the <tt class="docutils literal"><span class="pre">postgresql_ops</span></tt> dictionary are the &#8220;key&#8221; name of
356
 
the <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><tt class="xref py py-class docutils literal"><span class="pre">Column</span></tt></a>, i.e. the name used to access it from the <tt class="docutils literal"><span class="pre">.c</span></tt>
357
 
collection of <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>, which can be configured to be different than
 
358
the <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>, i.e. the name used to access it from the <tt class="docutils literal"><span class="pre">.c</span></tt>
 
359
collection of <a class="reference internal" href="../core/metadata.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>, which can be configured to be different than
358
360
the actual name of the column as expressed in the database.</p>
359
361
</div>
360
362
<div class="section" id="index-types">
362
364
<p>PostgreSQL provides several index types: B-Tree, Hash, GiST, and GIN, as well
363
365
as the ability for users to create their own (see
364
366
<a class="reference external" href="http://www.postgresql.org/docs/8.3/static/indexes-types.html">http://www.postgresql.org/docs/8.3/static/indexes-types.html</a>). These can be
365
 
specified on <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> using the <tt class="docutils literal"><span class="pre">postgresql_using</span></tt> keyword argument:</p>
 
367
specified on <a class="reference internal" href="../core/constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><tt class="xref py py-class docutils literal"><span class="pre">Index</span></tt></a> using the <tt class="docutils literal"><span class="pre">postgresql_using</span></tt> keyword argument:</p>
366
368
<div class="highlight-python"><div class="highlight"><pre><span class="n">Index</span><span class="p">(</span><span class="s">&#39;my_index&#39;</span><span class="p">,</span> <span class="n">my_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">data</span><span class="p">,</span> <span class="n">postgresql_using</span><span class="o">=</span><span class="s">&#39;gin&#39;</span><span class="p">)</span></pre></div>
367
369
</div>
368
370
<p>The value passed to the keyword argument will be simply passed through to the
387
389
<dl class="class">
388
390
<dt id="sqlalchemy.dialects.postgresql.array">
389
391
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">array</tt><big>(</big><em>clauses</em>, <em>**kw</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.array" title="Permalink to this definition">¶</a></dt>
390
 
<dd><p>A Postgresql ARRAY literal.</p>
 
392
<dd><p>Bases: <tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.sql.expression.Tuple</span></tt></p>
 
393
<p>A Postgresql ARRAY literal.</p>
391
394
<p>This is used to produce ARRAY literals in SQL expressions, e.g.:</p>
392
395
<div class="highlight-python"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">sqlalchemy.dialects.postgresql</span> <span class="kn">import</span> <span class="n">array</span>
393
396
<span class="kn">from</span> <span class="nn">sqlalchemy.dialects</span> <span class="kn">import</span> <span class="n">postgresql</span>
408
411
the values present, unless the <tt class="docutils literal"><span class="pre">type_</span></tt> keyword argument is passed:</p>
409
412
<div class="highlight-python"><div class="highlight"><pre><span class="n">array</span><span class="p">([</span><span class="s">&#39;foo&#39;</span><span class="p">,</span> <span class="s">&#39;bar&#39;</span><span class="p">],</span> <span class="n">type_</span><span class="o">=</span><span class="n">CHAR</span><span class="p">)</span></pre></div>
410
413
</div>
411
 
<p class="versionadded">
412
 
<span class="versionmodified">New in version 0.8: </span>Added the <a class="reference internal" href="#sqlalchemy.dialects.postgresql.array" title="sqlalchemy.dialects.postgresql.array"><tt class="xref py py-class docutils literal"><span class="pre">array</span></tt></a> literal type.</p>
 
414
<div class="versionadded">
 
415
<p><span>New in version 0.8: </span>Added the <a class="reference internal" href="#sqlalchemy.dialects.postgresql.array" title="sqlalchemy.dialects.postgresql.array"><tt class="xref py py-class docutils literal"><span class="pre">array</span></tt></a> literal type.</p>
 
416
</div>
413
417
<p>See also:</p>
414
418
<p><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY" title="sqlalchemy.dialects.postgresql.ARRAY"><tt class="xref py py-class docutils literal"><span class="pre">postgresql.ARRAY</span></tt></a></p>
415
419
</dd></dl>
442
446
    <span class="p">)</span></pre></div>
443
447
</div>
444
448
<p>This has the effect of the <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY" title="sqlalchemy.dialects.postgresql.ARRAY"><tt class="xref py py-class docutils literal"><span class="pre">ARRAY</span></tt></a> type
445
 
specifying that number of bracketed blocks when a <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>
 
449
specifying that number of bracketed blocks when a <a class="reference internal" href="../core/metadata.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a>
446
450
is used in a CREATE TABLE statement, or when the type is used
447
 
within a <a class="reference internal" href="../core/expression_api.html#sqlalchemy.sql.expression.cast" title="sqlalchemy.sql.expression.cast"><tt class="xref py py-func docutils literal"><span class="pre">expression.cast()</span></tt></a> construct; it also causes
 
451
within a <a class="reference internal" href="../core/sqlelement.html#sqlalchemy.sql.expression.cast" title="sqlalchemy.sql.expression.cast"><tt class="xref py py-func docutils literal"><span class="pre">expression.cast()</span></tt></a> construct; it also causes
448
452
the bind parameter and result set processing of the type
449
453
to optimize itself to expect exactly that number of dimensions.
450
454
Note that Postgresql itself still allows N dimensions with such a type.</p>
456
460
SELECT statements:</p>
457
461
<div class="highlight-python"><div class="highlight"><pre><span class="n">select</span><span class="p">([</span><span class="n">mytable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">5</span><span class="p">],</span> <span class="n">mytable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">2</span><span class="p">:</span><span class="mi">7</span><span class="p">]])</span></pre></div>
458
462
</div>
459
 
<p>as well as UPDATE statements when the <a class="reference internal" href="../core/expression_api.html#sqlalchemy.sql.expression.Update.values" title="sqlalchemy.sql.expression.Update.values"><tt class="xref py py-meth docutils literal"><span class="pre">Update.values()</span></tt></a> method
 
463
<p>as well as UPDATE statements when the <a class="reference internal" href="../core/dml.html#sqlalchemy.sql.expression.Update.values" title="sqlalchemy.sql.expression.Update.values"><tt class="xref py py-meth docutils literal"><span class="pre">Update.values()</span></tt></a> method
460
464
is used:</p>
461
465
<div class="highlight-python"><div class="highlight"><pre><span class="n">mytable</span><span class="o">.</span><span class="n">update</span><span class="p">()</span><span class="o">.</span><span class="n">values</span><span class="p">({</span>
462
466
    <span class="n">mytable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">data</span><span class="p">[</span><span class="mi">5</span><span class="p">]:</span> <span class="mi">7</span><span class="p">,</span>
468
472
<div class="highlight-python"><div class="highlight"><pre><span class="n">mytable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">data</span><span class="o">.</span><span class="n">contains</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">])</span></pre></div>
469
473
</div>
470
474
<p>For a full list of special methods see <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY.Comparator" title="sqlalchemy.dialects.postgresql.ARRAY.Comparator"><tt class="xref py py-class docutils literal"><span class="pre">ARRAY.Comparator</span></tt></a>.</p>
471
 
<p class="versionadded">
472
 
<span class="versionmodified">New in version 0.8: </span>Added support for index and slice operations
 
475
<div class="versionadded">
 
476
<p><span>New in version 0.8: </span>Added support for index and slice operations
473
477
to the <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY" title="sqlalchemy.dialects.postgresql.ARRAY"><tt class="xref py py-class docutils literal"><span class="pre">ARRAY</span></tt></a> type, including support for UPDATE
474
478
statements, and special array containment operations.</p>
 
479
</div>
475
480
<p>The <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY" title="sqlalchemy.dialects.postgresql.ARRAY"><tt class="xref py py-class docutils literal"><span class="pre">ARRAY</span></tt></a> type may not be supported on all DBAPIs.
476
481
It is known to work on psycopg2 and not pg8000.</p>
477
482
<p>See also:</p>
478
483
<p><a class="reference internal" href="#sqlalchemy.dialects.postgresql.array" title="sqlalchemy.dialects.postgresql.array"><tt class="xref py py-class docutils literal"><span class="pre">postgresql.array</span></tt></a> - produce a literal array value.</p>
479
 
<dl class="method">
480
 
<dt id="sqlalchemy.dialects.postgresql.ARRAY.__init__">
481
 
<tt class="descname">__init__</tt><big>(</big><em>item_type</em>, <em>as_tuple=False</em>, <em>dimensions=None</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.ARRAY.__init__" title="Permalink to this definition">¶</a></dt>
482
 
<dd><p>Construct an ARRAY.</p>
483
 
<p>E.g.:</p>
484
 
<div class="highlight-python"><div class="highlight"><pre><span class="n">Column</span><span class="p">(</span><span class="s">&#39;myarray&#39;</span><span class="p">,</span> <span class="n">ARRAY</span><span class="p">(</span><span class="n">Integer</span><span class="p">))</span></pre></div>
485
 
</div>
486
 
<p>Arguments are:</p>
487
 
<table class="docutils field-list" frame="void" rules="none">
488
 
<col class="field-name" />
489
 
<col class="field-body" />
490
 
<tbody valign="top">
491
 
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
492
 
<li><strong>item_type</strong> &#8211; The data type of items of this array. Note that
493
 
dimensionality is irrelevant here, so multi-dimensional arrays like
494
 
<tt class="docutils literal"><span class="pre">INTEGER[][]</span></tt>, are constructed as <tt class="docutils literal"><span class="pre">ARRAY(Integer)</span></tt>, not as
495
 
<tt class="docutils literal"><span class="pre">ARRAY(ARRAY(Integer))</span></tt> or such.</li>
496
 
<li><strong>as_tuple=False</strong> &#8211; Specify whether return results
497
 
should be converted to tuples from lists. DBAPIs such
498
 
as psycopg2 return lists by default. When tuples are
499
 
returned, the results are hashable.</li>
500
 
<li><strong>dimensions</strong> &#8211; if non-None, the ARRAY will assume a fixed
501
 
number of dimensions.  This will cause the DDL emitted for this
502
 
ARRAY to include the exact number of bracket clauses <tt class="docutils literal"><span class="pre">[]</span></tt>,
503
 
and will also optimize the performance of the type overall.
504
 
Note that PG arrays are always implicitly &#8220;non-dimensioned&#8221;,
505
 
meaning they can store any number of dimensions no matter how
506
 
they were declared.</li>
507
 
</ul>
508
 
</td>
509
 
</tr>
510
 
</tbody>
511
 
</table>
512
 
</dd></dl>
513
 
 
514
484
<dl class="class">
515
485
<dt id="sqlalchemy.dialects.postgresql.ARRAY.Comparator">
516
486
<em class="property">class </em><tt class="descname">Comparator</tt><big>(</big><em>expr</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.ARRAY.Comparator" title="Permalink to this definition">¶</a></dt>
545
515
</tr>
546
516
</tbody>
547
517
</table>
548
 
<div class="admonition-see-also admonition seealso">
 
518
<div class="admonition seealso">
549
519
<p class="first admonition-title">See also</p>
550
520
<p><a class="reference internal" href="#sqlalchemy.dialects.postgresql.All" title="sqlalchemy.dialects.postgresql.All"><tt class="xref py py-class docutils literal"><span class="pre">postgresql.All</span></tt></a></p>
551
521
<p class="last"><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY.Comparator.any" title="sqlalchemy.dialects.postgresql.ARRAY.Comparator.any"><tt class="xref py py-meth docutils literal"><span class="pre">postgresql.ARRAY.Comparator.any()</span></tt></a></p>
581
551
</tr>
582
552
</tbody>
583
553
</table>
584
 
<div class="admonition-see-also admonition seealso">
 
554
<div class="admonition seealso">
585
555
<p class="first admonition-title">See also</p>
586
556
<p><a class="reference internal" href="#sqlalchemy.dialects.postgresql.Any" title="sqlalchemy.dialects.postgresql.Any"><tt class="xref py py-class docutils literal"><span class="pre">postgresql.Any</span></tt></a></p>
587
557
<p class="last"><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY.Comparator.all" title="sqlalchemy.dialects.postgresql.ARRAY.Comparator.all"><tt class="xref py py-meth docutils literal"><span class="pre">postgresql.ARRAY.Comparator.all()</span></tt></a></p>
611
581
 
612
582
</dd></dl>
613
583
 
 
584
<dl class="method">
 
585
<dt id="sqlalchemy.dialects.postgresql.ARRAY.__init__">
 
586
<tt class="descclassname">ARRAY.</tt><tt class="descname">__init__</tt><big>(</big><em>item_type</em>, <em>as_tuple=False</em>, <em>dimensions=None</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.ARRAY.__init__" title="Permalink to this definition">¶</a></dt>
 
587
<dd><p>Construct an ARRAY.</p>
 
588
<p>E.g.:</p>
 
589
<div class="highlight-python"><div class="highlight"><pre><span class="n">Column</span><span class="p">(</span><span class="s">&#39;myarray&#39;</span><span class="p">,</span> <span class="n">ARRAY</span><span class="p">(</span><span class="n">Integer</span><span class="p">))</span></pre></div>
 
590
</div>
 
591
<p>Arguments are:</p>
 
592
<table class="docutils field-list" frame="void" rules="none">
 
593
<col class="field-name" />
 
594
<col class="field-body" />
 
595
<tbody valign="top">
 
596
<tr class="field-odd field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
 
597
<li><strong>item_type</strong> &#8211; The data type of items of this array. Note that
 
598
dimensionality is irrelevant here, so multi-dimensional arrays like
 
599
<tt class="docutils literal"><span class="pre">INTEGER[][]</span></tt>, are constructed as <tt class="docutils literal"><span class="pre">ARRAY(Integer)</span></tt>, not as
 
600
<tt class="docutils literal"><span class="pre">ARRAY(ARRAY(Integer))</span></tt> or such.</li>
 
601
<li><strong>as_tuple=False</strong> &#8211; Specify whether return results
 
602
should be converted to tuples from lists. DBAPIs such
 
603
as psycopg2 return lists by default. When tuples are
 
604
returned, the results are hashable.</li>
 
605
<li><strong>dimensions</strong> &#8211; if non-None, the ARRAY will assume a fixed
 
606
number of dimensions.  This will cause the DDL emitted for this
 
607
ARRAY to include the exact number of bracket clauses <tt class="docutils literal"><span class="pre">[]</span></tt>,
 
608
and will also optimize the performance of the type overall.
 
609
Note that PG arrays are always implicitly &#8220;non-dimensioned&#8221;,
 
610
meaning they can store any number of dimensions no matter how
 
611
they were declared.</li>
 
612
</ul>
 
613
</td>
 
614
</tr>
 
615
</tbody>
 
616
</table>
 
617
</dd></dl>
 
618
 
614
619
</dd></dl>
615
620
 
616
621
<dl class="class">
617
622
<dt id="sqlalchemy.dialects.postgresql.Any">
618
623
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">Any</tt><big>(</big><em>left</em>, <em>right</em>, <em>operator=&lt;built-in function eq&gt;</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.Any" title="Permalink to this definition">¶</a></dt>
619
 
<dd><p>Represent the clause <tt class="docutils literal"><span class="pre">left</span> <span class="pre">operator</span> <span class="pre">ANY</span> <span class="pre">(right)</span></tt>.  <tt class="docutils literal"><span class="pre">right</span></tt> must be
 
624
<dd><p>Bases: <a class="reference internal" href="../core/sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.sql.expression.ColumnElement</span></tt></a></p>
 
625
<p>Represent the clause <tt class="docutils literal"><span class="pre">left</span> <span class="pre">operator</span> <span class="pre">ANY</span> <span class="pre">(right)</span></tt>.  <tt class="docutils literal"><span class="pre">right</span></tt> must be
620
626
an array expression.</p>
621
 
<div class="admonition-see-also admonition seealso">
 
627
<div class="admonition seealso">
622
628
<p class="first admonition-title">See also</p>
623
629
<p><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY" title="sqlalchemy.dialects.postgresql.ARRAY"><tt class="xref py py-class docutils literal"><span class="pre">postgresql.ARRAY</span></tt></a></p>
624
630
<p class="last"><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY.Comparator.any" title="sqlalchemy.dialects.postgresql.ARRAY.Comparator.any"><tt class="xref py py-meth docutils literal"><span class="pre">postgresql.ARRAY.Comparator.any()</span></tt></a> - ARRAY-bound method</p>
628
634
<dl class="class">
629
635
<dt id="sqlalchemy.dialects.postgresql.All">
630
636
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">All</tt><big>(</big><em>left</em>, <em>right</em>, <em>operator=&lt;built-in function eq&gt;</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.All" title="Permalink to this definition">¶</a></dt>
631
 
<dd><p>Represent the clause <tt class="docutils literal"><span class="pre">left</span> <span class="pre">operator</span> <span class="pre">ALL</span> <span class="pre">(right)</span></tt>.  <tt class="docutils literal"><span class="pre">right</span></tt> must be
 
637
<dd><p>Bases: <a class="reference internal" href="../core/sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.sql.expression.ColumnElement</span></tt></a></p>
 
638
<p>Represent the clause <tt class="docutils literal"><span class="pre">left</span> <span class="pre">operator</span> <span class="pre">ALL</span> <span class="pre">(right)</span></tt>.  <tt class="docutils literal"><span class="pre">right</span></tt> must be
632
639
an array expression.</p>
633
 
<div class="admonition-see-also admonition seealso">
 
640
<div class="admonition seealso">
634
641
<p class="first admonition-title">See also</p>
635
642
<p><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY" title="sqlalchemy.dialects.postgresql.ARRAY"><tt class="xref py py-class docutils literal"><span class="pre">postgresql.ARRAY</span></tt></a></p>
636
643
<p class="last"><a class="reference internal" href="#sqlalchemy.dialects.postgresql.ARRAY.Comparator.all" title="sqlalchemy.dialects.postgresql.ARRAY.Comparator.all"><tt class="xref py py-meth docutils literal"><span class="pre">postgresql.ARRAY.Comparator.all()</span></tt></a> - ARRAY-bound method</p>
762
769
the <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ENUM.create" title="sqlalchemy.dialects.postgresql.ENUM.create"><tt class="xref py py-meth docutils literal"><span class="pre">create()</span></tt></a> and
763
770
<a class="reference internal" href="#sqlalchemy.dialects.postgresql.ENUM.drop" title="sqlalchemy.dialects.postgresql.ENUM.drop"><tt class="xref py py-meth docutils literal"><span class="pre">drop()</span></tt></a> methods can
764
771
be used to emit SQL to a target bind.</p>
765
 
<p class="versionadded">
766
 
<span class="versionmodified">New in version 0.7.4.</span></p>
 
772
<div class="versionadded">
 
773
<p><span>New in version 0.7.4.</span></p>
 
774
</div>
767
775
</td>
768
776
</tr>
769
777
</tbody>
861
869
<p>For usage with the SQLAlchemy ORM, it may be desirable to combine
862
870
the usage of <a class="reference internal" href="#sqlalchemy.dialects.postgresql.HSTORE" title="sqlalchemy.dialects.postgresql.HSTORE"><tt class="xref py py-class docutils literal"><span class="pre">HSTORE</span></tt></a> with <a class="reference internal" href="../orm/extensions/mutable.html#sqlalchemy.ext.mutable.MutableDict" title="sqlalchemy.ext.mutable.MutableDict"><tt class="xref py py-class docutils literal"><span class="pre">MutableDict</span></tt></a> dictionary
863
871
now part of the <a class="reference internal" href="../orm/extensions/mutable.html#module-sqlalchemy.ext.mutable" title="sqlalchemy.ext.mutable"><tt class="xref py py-mod docutils literal"><span class="pre">sqlalchemy.ext.mutable</span></tt></a>
864
 
extension.  This extension will allow in-place changes to dictionary
865
 
values to be detected by the unit of work:</p>
 
872
extension.  This extension will allow &#8220;in-place&#8221; changes to the
 
873
dictionary, e.g. addition of new keys or replacement/removal of existing
 
874
keys to/from the current dictionary, to produce events which will be detected
 
875
by the unit of work:</p>
866
876
<div class="highlight-python"><div class="highlight"><pre><span class="kn">from</span> <span class="nn">sqlalchemy.ext.mutable</span> <span class="kn">import</span> <span class="n">MutableDict</span>
867
877
 
868
878
<span class="k">class</span> <span class="nc">MyClass</span><span class="p">(</span><span class="n">Base</span><span class="p">):</span>
879
889
 
880
890
<span class="n">session</span><span class="o">.</span><span class="n">commit</span><span class="p">()</span></pre></div>
881
891
</div>
882
 
<p class="versionadded">
883
 
<span class="versionmodified">New in version 0.8.</span></p>
884
 
<div class="admonition-see-also admonition seealso">
 
892
<p>When the <a class="reference internal" href="../orm/extensions/mutable.html#module-sqlalchemy.ext.mutable" title="sqlalchemy.ext.mutable"><tt class="xref py py-mod docutils literal"><span class="pre">sqlalchemy.ext.mutable</span></tt></a> extension is not used, the ORM
 
893
will not be alerted to any changes to the contents of an existing dictionary,
 
894
unless that dictionary value is re-assigned to the HSTORE-attribute itself,
 
895
thus generating a change event.</p>
 
896
<div class="versionadded">
 
897
<p><span>New in version 0.8.</span></p>
 
898
</div>
 
899
<div class="admonition seealso">
885
900
<p class="first admonition-title">See also</p>
886
901
<p class="last"><a class="reference internal" href="#sqlalchemy.dialects.postgresql.hstore" title="sqlalchemy.dialects.postgresql.hstore"><tt class="xref py py-class docutils literal"><span class="pre">hstore</span></tt></a> - render the Postgresql <tt class="docutils literal"><span class="pre">hstore()</span></tt> function.</p>
887
902
</div>
978
993
<dl class="class">
979
994
<dt id="sqlalchemy.dialects.postgresql.hstore">
980
995
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">hstore</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.hstore" title="Permalink to this definition">¶</a></dt>
981
 
<dd><p>Bases: <a class="reference internal" href="../core/expression_api.html#sqlalchemy.sql.functions.GenericFunction" title="sqlalchemy.sql.functions.GenericFunction"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.sql.functions.GenericFunction</span></tt></a></p>
 
996
<dd><p>Bases: <a class="reference internal" href="../core/functions.html#sqlalchemy.sql.functions.GenericFunction" title="sqlalchemy.sql.functions.GenericFunction"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.sql.functions.GenericFunction</span></tt></a></p>
982
997
<p>Construct an hstore value within a SQL expression using the
983
998
Postgresql <tt class="docutils literal"><span class="pre">hstore()</span></tt> function.</p>
984
999
<p>The <a class="reference internal" href="#sqlalchemy.dialects.postgresql.hstore" title="sqlalchemy.dialects.postgresql.hstore"><tt class="xref py py-class docutils literal"><span class="pre">hstore</span></tt></a> function accepts one or two arguments as described
995
1010
        <span class="p">)</span>
996
1011
    <span class="p">])</span></pre></div>
997
1012
</div>
998
 
<p class="versionadded">
999
 
<span class="versionmodified">New in version 0.8.</span></p>
1000
 
<div class="admonition-see-also admonition seealso">
 
1013
<div class="versionadded">
 
1014
<p><span>New in version 0.8.</span></p>
 
1015
</div>
 
1016
<div class="admonition seealso">
1001
1017
<p class="first admonition-title">See also</p>
1002
1018
<p class="last"><a class="reference internal" href="#sqlalchemy.dialects.postgresql.HSTORE" title="sqlalchemy.dialects.postgresql.HSTORE"><tt class="xref py py-class docutils literal"><span class="pre">HSTORE</span></tt></a> - the Postgresql <tt class="docutils literal"><span class="pre">HSTORE</span></tt> datatype.</p>
1003
1019
</div>
1112
1128
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">INT4RANGE</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.INT4RANGE" title="Permalink to this definition">¶</a></dt>
1113
1129
<dd><p>Bases: <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators" title="sqlalchemy.dialects.postgresql.ranges.RangeOperators"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.dialects.postgresql.ranges.RangeOperators</span></tt></a>, <a class="reference internal" href="../core/types.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.TypeEngine</span></tt></a></p>
1114
1130
<p>Represent the Postgresql INT4RANGE type.</p>
1115
 
<p class="versionadded">
1116
 
<span class="versionmodified">New in version 0.8.2.</span></p>
 
1131
<div class="versionadded">
 
1132
<p><span>New in version 0.8.2.</span></p>
 
1133
</div>
1117
1134
</dd></dl>
1118
1135
 
1119
1136
<dl class="class">
1121
1138
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">INT8RANGE</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.INT8RANGE" title="Permalink to this definition">¶</a></dt>
1122
1139
<dd><p>Bases: <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators" title="sqlalchemy.dialects.postgresql.ranges.RangeOperators"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.dialects.postgresql.ranges.RangeOperators</span></tt></a>, <a class="reference internal" href="../core/types.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.TypeEngine</span></tt></a></p>
1123
1140
<p>Represent the Postgresql INT8RANGE type.</p>
1124
 
<p class="versionadded">
1125
 
<span class="versionmodified">New in version 0.8.2.</span></p>
 
1141
<div class="versionadded">
 
1142
<p><span>New in version 0.8.2.</span></p>
 
1143
</div>
1126
1144
</dd></dl>
1127
1145
 
1128
1146
<dl class="class">
1130
1148
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">NUMRANGE</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.NUMRANGE" title="Permalink to this definition">¶</a></dt>
1131
1149
<dd><p>Bases: <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators" title="sqlalchemy.dialects.postgresql.ranges.RangeOperators"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.dialects.postgresql.ranges.RangeOperators</span></tt></a>, <a class="reference internal" href="../core/types.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.TypeEngine</span></tt></a></p>
1132
1150
<p>Represent the Postgresql NUMRANGE type.</p>
1133
 
<p class="versionadded">
1134
 
<span class="versionmodified">New in version 0.8.2.</span></p>
 
1151
<div class="versionadded">
 
1152
<p><span>New in version 0.8.2.</span></p>
 
1153
</div>
1135
1154
</dd></dl>
1136
1155
 
1137
1156
<dl class="class">
1139
1158
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">DATERANGE</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.DATERANGE" title="Permalink to this definition">¶</a></dt>
1140
1159
<dd><p>Bases: <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators" title="sqlalchemy.dialects.postgresql.ranges.RangeOperators"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.dialects.postgresql.ranges.RangeOperators</span></tt></a>, <a class="reference internal" href="../core/types.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.TypeEngine</span></tt></a></p>
1141
1160
<p>Represent the Postgresql DATERANGE type.</p>
1142
 
<p class="versionadded">
1143
 
<span class="versionmodified">New in version 0.8.2.</span></p>
 
1161
<div class="versionadded">
 
1162
<p><span>New in version 0.8.2.</span></p>
 
1163
</div>
1144
1164
</dd></dl>
1145
1165
 
1146
1166
<dl class="class">
1148
1168
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">TSRANGE</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.TSRANGE" title="Permalink to this definition">¶</a></dt>
1149
1169
<dd><p>Bases: <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators" title="sqlalchemy.dialects.postgresql.ranges.RangeOperators"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.dialects.postgresql.ranges.RangeOperators</span></tt></a>, <a class="reference internal" href="../core/types.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.TypeEngine</span></tt></a></p>
1150
1170
<p>Represent the Postgresql TSRANGE type.</p>
1151
 
<p class="versionadded">
1152
 
<span class="versionmodified">New in version 0.8.2.</span></p>
 
1171
<div class="versionadded">
 
1172
<p><span>New in version 0.8.2.</span></p>
 
1173
</div>
1153
1174
</dd></dl>
1154
1175
 
1155
1176
<dl class="class">
1157
1178
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">TSTZRANGE</tt><big>(</big><em>*args</em>, <em>**kwargs</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.TSTZRANGE" title="Permalink to this definition">¶</a></dt>
1158
1179
<dd><p>Bases: <a class="reference internal" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators" title="sqlalchemy.dialects.postgresql.ranges.RangeOperators"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.dialects.postgresql.ranges.RangeOperators</span></tt></a>, <a class="reference internal" href="../core/types.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.TypeEngine</span></tt></a></p>
1159
1180
<p>Represent the Postgresql TSTZRANGE type.</p>
1160
 
<p class="versionadded">
1161
 
<span class="versionmodified">New in version 0.8.2.</span></p>
 
1181
<div class="versionadded">
 
1182
<p><span>New in version 0.8.2.</span></p>
 
1183
</div>
1162
1184
</dd></dl>
1163
1185
 
1164
1186
<p>The types above get most of their functionality from the following
1173
1195
any range types you create yourself.</p>
1174
1196
<p>No extra support is provided for the Range Functions listed in
1175
1197
Table 9-45 of the postgres documentation. For these, the normal
1176
 
<a class="reference internal" href="../core/expression_api.html#sqlalchemy.sql.expression.func" title="sqlalchemy.sql.expression.func"><tt class="xref py py-func docutils literal"><span class="pre">func()</span></tt></a> object should be used.</p>
1177
 
<p class="versionadded">
1178
 
<span class="versionmodified">New in version 0.8.2: </span>Support for Postgresql RANGE operations.</p>
 
1198
<a class="reference internal" href="../core/sqlelement.html#sqlalchemy.sql.expression.func" title="sqlalchemy.sql.expression.func"><tt class="xref py py-func docutils literal"><span class="pre">func()</span></tt></a> object should be used.</p>
 
1199
<div class="versionadded">
 
1200
<p><span>New in version 0.8.2: </span>Support for Postgresql RANGE operations.</p>
 
1201
</div>
1179
1202
<dl class="class">
1180
1203
<dt id="sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory">
1181
1204
<em class="property">class </em><tt class="descname">comparator_factory</tt><big>(</big><em>expr</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory" title="Permalink to this definition">¶</a></dt>
1182
 
<dd><p>Define comparison operations for range types.</p>
 
1205
<dd><p>Bases: <tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.types.Comparator</span></tt></p>
 
1206
<p>Define comparison operations for range types.</p>
1183
1207
<dl class="method">
1184
1208
<dt id="sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory.__ne__">
1185
1209
<tt class="descname">__ne__</tt><big>(</big><em>other</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.ranges.RangeOperators.comparator_factory.__ne__" title="Permalink to this definition">¶</a></dt>
1263
1287
<dl class="class">
1264
1288
<dt id="sqlalchemy.dialects.postgresql.ExcludeConstraint">
1265
1289
<em class="property">class </em><tt class="descclassname">sqlalchemy.dialects.postgresql.</tt><tt class="descname">ExcludeConstraint</tt><big>(</big><em>*elements</em>, <em>**kw</em><big>)</big><a class="headerlink" href="#sqlalchemy.dialects.postgresql.ExcludeConstraint" title="Permalink to this definition">¶</a></dt>
1266
 
<dd><p>Bases: <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.ColumnCollectionConstraint" title="sqlalchemy.schema.ColumnCollectionConstraint"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.schema.ColumnCollectionConstraint</span></tt></a></p>
 
1290
<dd><p>Bases: <a class="reference internal" href="../core/constraints.html#sqlalchemy.schema.ColumnCollectionConstraint" title="sqlalchemy.schema.ColumnCollectionConstraint"><tt class="xref py py-class docutils literal"><span class="pre">sqlalchemy.schema.ColumnCollectionConstraint</span></tt></a></p>
1267
1291
<p>A table-level EXCLUDE constraint.</p>
1268
1292
<p>Defines an EXCLUDE constraint as described in the <a class="reference external" href="http://www.postgresql.org/docs/9.0/static/sql-createtable.html#SQL-CREATETABLE-EXCLUDE">postgres
1269
1293
documentation</a>.</p>
1365
1389
<div class="section" id="per-statement-connection-execution-options">
1366
1390
<h3>Per-Statement/Connection Execution Options<a class="headerlink" href="#per-statement-connection-execution-options" title="Permalink to this headline">¶</a></h3>
1367
1391
<p>The following DBAPI-specific options are respected when used with
1368
 
<a class="reference internal" href="../core/connections.html#sqlalchemy.engine.Connection.execution_options" title="sqlalchemy.engine.Connection.execution_options"><tt class="xref py py-meth docutils literal"><span class="pre">Connection.execution_options()</span></tt></a>, <a class="reference internal" href="../core/expression_api.html#sqlalchemy.sql.expression.Executable.execution_options" title="sqlalchemy.sql.expression.Executable.execution_options"><tt class="xref py py-meth docutils literal"><span class="pre">Executable.execution_options()</span></tt></a>,
 
1392
<a class="reference internal" href="../core/connections.html#sqlalchemy.engine.Connection.execution_options" title="sqlalchemy.engine.Connection.execution_options"><tt class="xref py py-meth docutils literal"><span class="pre">Connection.execution_options()</span></tt></a>, <a class="reference internal" href="../core/selectable.html#sqlalchemy.sql.expression.Executable.execution_options" title="sqlalchemy.sql.expression.Executable.execution_options"><tt class="xref py py-meth docutils literal"><span class="pre">Executable.execution_options()</span></tt></a>,
1369
1393
<a class="reference internal" href="../orm/query.html#sqlalchemy.orm.query.Query.execution_options" title="sqlalchemy.orm.query.Query.execution_options"><tt class="xref py py-meth docutils literal"><span class="pre">Query.execution_options()</span></tt></a>, in addition to those not specific to DBAPIs:</p>
1370
1394
<ul class="simple">
1371
1395
<li>isolation_level - Set the transaction isolation level for the lifespan of a
1399
1423
<div class="highlight-python"><div class="highlight"><pre><span class="n">engine</span> <span class="o">=</span> <span class="n">create_engine</span><span class="p">(</span><span class="s">&quot;postgresql://user:pass@host/dbname&quot;</span><span class="p">,</span> <span class="n">client_encoding</span><span class="o">=</span><span class="s">&#39;utf8&#39;</span><span class="p">)</span></pre></div>
1400
1424
</div>
1401
1425
<p>This overrides the encoding specified in the Postgresql client configuration.</p>
1402
 
<p class="versionadded">
1403
 
<span class="versionmodified">New in version 0.7.3: </span>The psycopg2-specific <tt class="docutils literal"><span class="pre">client_encoding</span></tt> parameter to
 
1426
<div class="versionadded">
 
1427
<p><span>New in version 0.7.3: </span>The psycopg2-specific <tt class="docutils literal"><span class="pre">client_encoding</span></tt> parameter to
1404
1428
<a class="reference internal" href="../core/engines.html#sqlalchemy.create_engine" title="sqlalchemy.create_engine"><tt class="xref py py-func docutils literal"><span class="pre">create_engine()</span></tt></a>.</p>
 
1429
</div>
1405
1430
<p>SQLAlchemy can also be instructed to skip the usage of the psycopg2
1406
1431
<tt class="docutils literal"><span class="pre">UNICODE</span></tt> extension and to instead utilize it&#8217;s own unicode encode/decode
1407
1432
services, which are normally reserved only for those DBAPIs that don&#8217;t
1437
1462
<li><tt class="docutils literal"><span class="pre">SERIALIZABLE</span></tt></li>
1438
1463
<li><tt class="docutils literal"><span class="pre">AUTOCOMMIT</span></tt></li>
1439
1464
</ul>
1440
 
<p class="versionadded">
1441
 
<span class="versionmodified">New in version 0.8.2: </span>support for AUTOCOMMIT isolation level when using
 
1465
<div class="versionadded">
 
1466
<p><span>New in version 0.8.2: </span>support for AUTOCOMMIT isolation level when using
1442
1467
psycopg2.</p>
1443
1468
</div>
 
1469
</div>
1444
1470
<div class="section" id="notice-logging">
1445
1471
<h3>NOTICE logging<a class="headerlink" href="#notice-logging" title="Permalink to this headline">¶</a></h3>
1446
1472
<p>The psycopg2 dialect will log Postgresql NOTICE messages via the
1528
1554
 
1529
1555
    <div id="docs-copyright">
1530
1556
        &copy; <a href="../copyright.html">Copyright</a> 2007-2013, the SQLAlchemy authors and contributors.
1531
 
        Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.1.3.
 
1557
        Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.2b1.
1532
1558
    </div>
1533
1559
</div>
1534
1560