<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title> Describing Databases with MetaData — SQLAlchemy 1.2 Documentation </title> <!-- begin iterate through site-imported + sphinx environment css_files --> <link rel="stylesheet" href="../_static/pygments.css" type="text/css" /> <link rel="stylesheet" href="../_static/docs.css" type="text/css" /> <link rel="stylesheet" href="../_static/changelog.css" type="text/css" /> <link rel="stylesheet" href="../_static/sphinx_paramlinks.css" type="text/css" /> <!-- end iterate through site-imported + sphinx environment css_files --> <!-- begin layout.mako headers --> <link rel="index" title="Index" href="../genindex.html" /> <link rel="search" title="Search" href="../search.html" /> <link rel="copyright" title="Copyright" href="../copyright.html" /> <link rel="top" title="SQLAlchemy 1.2 Documentation" href="../index.html" /> <link rel="up" title="Schema Definition Language" href="schema.html" /> <link rel="next" title="Reflecting Database Objects" href="reflection.html" /> <link rel="prev" title="Schema Definition Language" href="schema.html" /> <!-- end layout.mako headers --> </head> <body> <div id="docs-container"> <div id="docs-top-navigation-container" class="body-background"> <div id="docs-header"> <div id="docs-version-header"> Release: <span class="version-num">1.2.19</span> | Release Date: April 15, 2019 </div> <h1>SQLAlchemy 1.2 Documentation</h1> </div> </div> <div id="docs-body-container"> <div id="fixed-sidebar" class="withsidebar"> <div id="docs-sidebar-popout"> <h3><a href="../index.html">SQLAlchemy 1.2 Documentation</a></h3> <p id="sidebar-topnav"> <a href="../contents.html">Contents</a> | <a href="../genindex.html">Index</a> </p> <div id="sidebar-search"> <form class="search" action="../search.html" method="get"> <label> Search terms: <input type="text" placeholder="search..." name="q" size="12" /> </label> <input type="hidden" name="check_keywords" value="yes" /> <input type="hidden" name="area" value="default" /> </form> </div> </div> <div id="docs-sidebar"> <div id="sidebar-banner"> </div> <div id="docs-sidebar-inner"> <h3> <a href="index.html" title="SQLAlchemy Core">SQLAlchemy Core</a> </h3> <ul> <li><span class="link-container"><a class="reference external" href="tutorial.html">SQL Expression Language Tutorial</a></span></li> <li><span class="link-container"><a class="reference external" href="expression_api.html">SQL Statements and Expressions API</a></span></li> <li><span class="link-container"><a class="reference external" href="schema.html">Schema Definition Language</a></span><ul> <li class="selected"><span class="link-container"><strong>Describing Databases with MetaData</strong><a class="paramlink headerlink reference internal" href="#">¶</a></span><ul> <li><span class="link-container"><a class="reference external" href="#accessing-tables-and-columns">Accessing Tables and Columns</a></span></li> <li><span class="link-container"><a class="reference external" href="#creating-and-dropping-database-tables">Creating and Dropping Database Tables</a></span></li> <li><span class="link-container"><a class="reference external" href="#altering-schemas-through-migrations">Altering Schemas through Migrations</a></span></li> <li><span class="link-container"><a class="reference external" href="#specifying-the-schema-name">Specifying the Schema Name</a></span></li> <li><span class="link-container"><a class="reference external" href="#backend-specific-options">Backend-Specific Options</a></span></li> <li><span class="link-container"><a class="reference external" href="#column-table-metadata-api">Column, Table, MetaData API</a></span></li> </ul> </li> <li><span class="link-container"><a class="reference external" href="reflection.html">Reflecting Database Objects</a></span></li> <li><span class="link-container"><a class="reference external" href="defaults.html">Column Insert/Update Defaults</a></span></li> <li><span class="link-container"><a class="reference external" href="constraints.html">Defining Constraints and Indexes</a></span></li> <li><span class="link-container"><a class="reference external" href="ddl.html">Customizing DDL</a></span></li> </ul> </li> <li><span class="link-container"><a class="reference external" href="types.html">Column and Data Types</a></span></li> <li><span class="link-container"><a class="reference external" href="engines_connections.html">Engine and Connection Use</a></span></li> <li><span class="link-container"><a class="reference external" href="api_basics.html">Core API Basics</a></span></li> </ul> </div> </div> </div> <div id="docs-body" class="withsidebar" > <div class="section" id="module-sqlalchemy.schema"> <span id="describing-databases-with-metadata"></span><span id="metadata-describing"></span><span id="metadata-describing-toplevel"></span><span id="metadata-toplevel"></span><h1>Describing Databases with MetaData<a class="headerlink" href="#module-sqlalchemy.schema" title="Permalink to this headline">¶</a></h1> <p>This section discusses the fundamental <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> and <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> objects.</p> <p>A collection of metadata entities is stored in an object aptly named <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">sqlalchemy</span> <span class="k">import</span> <span class="o">*</span> <span class="n">metadata</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">()</span></pre></div> </div> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> is a container object that keeps together many different features of a database (or multiple databases) being described.</p> <p>To represent a table, use the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> class. Its two primary arguments are the table name, then the <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object which it will be associated with. The remaining positional arguments are mostly <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects describing each column:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">user</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'user'</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'user_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'user_name'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">16</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="kc">False</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'email_address'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">60</span><span class="p">)),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'nickname'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span> <span class="p">)</span></pre></div> </div> <p>Above, a table called <code class="docutils literal notranslate"><span class="pre">user</span></code> is described, which contains four columns. The primary key of the table consists of the <code class="docutils literal notranslate"><span class="pre">user_id</span></code> column. Multiple columns may be assigned the <code class="docutils literal notranslate"><span class="pre">primary_key=True</span></code> flag which denotes a multi-column primary key, known as a <em>composite</em> primary key.</p> <p>Note also that each column describes its datatype using objects corresponding to genericized types, such as <a class="reference internal" href="type_basics.html#sqlalchemy.types.Integer" title="sqlalchemy.types.Integer"><code class="xref py py-class docutils literal notranslate"><span class="pre">Integer</span></code></a> and <a class="reference internal" href="type_basics.html#sqlalchemy.types.String" title="sqlalchemy.types.String"><code class="xref py py-class docutils literal notranslate"><span class="pre">String</span></code></a>. SQLAlchemy features dozens of types of varying levels of specificity as well as the ability to create custom types. Documentation on the type system can be found at <a class="reference internal" href="types.html"><span class="std std-ref">Column and Data Types</span></a>.</p> <div class="section" id="accessing-tables-and-columns"> <h2>Accessing Tables and Columns<a class="headerlink" href="#accessing-tables-and-columns" title="Permalink to this headline">¶</a></h2> <p>The <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object contains all of the schema constructs we’ve associated with it. It supports a few methods of accessing these table objects, such as the <code class="docutils literal notranslate"><span class="pre">sorted_tables</span></code> accessor which returns a list of each <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object in order of foreign key dependency (that is, each table is preceded by all tables which it references):</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">for</span> <span class="n">t</span> <span class="ow">in</span> <span class="n">metadata</span><span class="o">.</span><span class="n">sorted_tables</span><span class="p">:</span> <span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="n">t</span><span class="o">.</span><span class="n">name</span><span class="p">)</span> <span class="go">user</span> <span class="go">user_preference</span> <span class="go">invoice</span> <span class="go">invoice_item</span></pre></div> </div> <p>In most cases, individual <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects have been explicitly declared, and these objects are typically accessed directly as module-level variables in an application. Once a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> has been defined, it has a full set of accessors which allow inspection of its properties. Given the following <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> definition:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">employees</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'employees'</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'employee_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'employee_name'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">60</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="kc">False</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'employee_dept'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">ForeignKey</span><span class="p">(</span><span class="s2">"departments.department_id"</span><span class="p">))</span> <span class="p">)</span></pre></div> </div> <p>Note the <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a> object used in this table - this construct defines a reference to a remote table, and is fully described in <a class="reference internal" href="constraints.html#metadata-foreignkeys"><span class="std std-ref">Defining Foreign Keys</span></a>. Methods of accessing information about this table include:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># access the column "EMPLOYEE_ID":</span> <span class="n">employees</span><span class="o">.</span><span class="n">columns</span><span class="o">.</span><span class="n">employee_id</span> <span class="c1"># or just</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_id</span> <span class="c1"># via string</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="p">[</span><span class="s1">'employee_id'</span><span class="p">]</span> <span class="c1"># iterate through all columns</span> <span class="k">for</span> <span class="n">c</span> <span class="ow">in</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">c</span><span class="p">)</span> <span class="c1"># get the table's primary key columns</span> <span class="k">for</span> <span class="n">primary_key</span> <span class="ow">in</span> <span class="n">employees</span><span class="o">.</span><span class="n">primary_key</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">primary_key</span><span class="p">)</span> <span class="c1"># get the table's foreign key objects:</span> <span class="k">for</span> <span class="n">fkey</span> <span class="ow">in</span> <span class="n">employees</span><span class="o">.</span><span class="n">foreign_keys</span><span class="p">:</span> <span class="nb">print</span><span class="p">(</span><span class="n">fkey</span><span class="p">)</span> <span class="c1"># access the table's MetaData:</span> <span class="n">employees</span><span class="o">.</span><span class="n">metadata</span> <span class="c1"># access the table's bound Engine or Connection, if its MetaData is bound:</span> <span class="n">employees</span><span class="o">.</span><span class="n">bind</span> <span class="c1"># access a column's name, type, nullable, primary key, foreign key</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_id</span><span class="o">.</span><span class="n">name</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_id</span><span class="o">.</span><span class="n">type</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_id</span><span class="o">.</span><span class="n">nullable</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_id</span><span class="o">.</span><span class="n">primary_key</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_dept</span><span class="o">.</span><span class="n">foreign_keys</span> <span class="c1"># get the "key" of a column, which defaults to its name, but can</span> <span class="c1"># be any user-defined string:</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_name</span><span class="o">.</span><span class="n">key</span> <span class="c1"># access a column's table:</span> <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_id</span><span class="o">.</span><span class="n">table</span> <span class="ow">is</span> <span class="n">employees</span> <span class="c1"># get the table related by a foreign key</span> <span class="nb">list</span><span class="p">(</span><span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">employee_dept</span><span class="o">.</span><span class="n">foreign_keys</span><span class="p">)[</span><span class="mi">0</span><span class="p">]</span><span class="o">.</span><span class="n">column</span><span class="o">.</span><span class="n">table</span></pre></div> </div> </div> <div class="section" id="creating-and-dropping-database-tables"> <h2>Creating and Dropping Database Tables<a class="headerlink" href="#creating-and-dropping-database-tables" title="Permalink to this headline">¶</a></h2> <p>Once you’ve defined some <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects, assuming you’re working with a brand new database one thing you might want to do is issue CREATE statements for those tables and their related constructs (as an aside, it’s also quite possible that you <em>don’t</em> want to do this, if you already have some preferred methodology such as tools included with your database or an existing scripting system - if that’s the case, feel free to skip this section - SQLAlchemy has no requirement that it be used to create your tables).</p> <p>The usual way to issue CREATE is to use <a class="reference internal" href="#sqlalchemy.schema.MetaData.create_all" title="sqlalchemy.schema.MetaData.create_all"><code class="xref py py-func docutils literal notranslate"><span class="pre">create_all()</span></code></a> on the <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object. This method will issue queries that first check for the existence of each individual table, and if not found will issue the CREATE statements:</p> <blockquote> <div><div class="highlight-python+sql notranslate"><div class="highlight"><pre><span></span><span class="n">engine</span> <span class="o">=</span> <span class="n">create_engine</span><span class="p">(</span><span class="s1">'sqlite:///:memory:'</span><span class="p">)</span> <span class="n">metadata</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">()</span> <span class="n">user</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'user'</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'user_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'user_name'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">16</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'email_address'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">60</span><span class="p">),</span> <span class="n">key</span><span class="o">=</span><span class="s1">'email'</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'nickname'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span> <span class="p">)</span> <span class="n">user_prefs</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'user_prefs'</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'pref_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'user_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">ForeignKey</span><span class="p">(</span><span class="s2">"user.user_id"</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'pref_name'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">40</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'pref_value'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">100</span><span class="p">))</span> <span class="p">)</span> <a href='#' class='sql_link'>sql</a><span class="n">metadata</span><span class="o">.</span><span class="n">create_all</span><span class="p">(</span><span class="n">engine</span><span class="p">)</span> <div class='popup_sql'>PRAGMA table_info(user){} CREATE TABLE user( user_id INTEGER NOT NULL PRIMARY KEY, user_name VARCHAR(16) NOT NULL, email_address VARCHAR(60), nickname VARCHAR(50) NOT NULL ) PRAGMA table_info(user_prefs){} CREATE TABLE user_prefs( pref_id INTEGER NOT NULL PRIMARY KEY, user_id INTEGER NOT NULL REFERENCES user(user_id), pref_name VARCHAR(40) NOT NULL, pref_value VARCHAR(100) )</div></pre></div> </div> </div></blockquote> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData.create_all" title="sqlalchemy.schema.MetaData.create_all"><code class="xref py py-func docutils literal notranslate"><span class="pre">create_all()</span></code></a> creates foreign key constraints between tables usually inline with the table definition itself, and for this reason it also generates the tables in order of their dependency. There are options to change this behavior such that <code class="docutils literal notranslate"><span class="pre">ALTER</span> <span class="pre">TABLE</span></code> is used instead.</p> <p>Dropping all tables is similarly achieved using the <a class="reference internal" href="#sqlalchemy.schema.MetaData.drop_all" title="sqlalchemy.schema.MetaData.drop_all"><code class="xref py py-func docutils literal notranslate"><span class="pre">drop_all()</span></code></a> method. This method does the exact opposite of <a class="reference internal" href="#sqlalchemy.schema.MetaData.create_all" title="sqlalchemy.schema.MetaData.create_all"><code class="xref py py-func docutils literal notranslate"><span class="pre">create_all()</span></code></a> - the presence of each table is checked first, and tables are dropped in reverse order of dependency.</p> <p>Creating and dropping individual tables can be done via the <code class="docutils literal notranslate"><span class="pre">create()</span></code> and <code class="docutils literal notranslate"><span class="pre">drop()</span></code> methods of <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>. These methods by default issue the CREATE or DROP regardless of the table being present:</p> <div class="highlight-python+sql notranslate"><div class="highlight"><pre><span></span><span class="n">engine</span> <span class="o">=</span> <span class="n">create_engine</span><span class="p">(</span><span class="s1">'sqlite:///:memory:'</span><span class="p">)</span> <span class="n">meta</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">()</span> <span class="n">employees</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'employees'</span><span class="p">,</span> <span class="n">meta</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'employee_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'employee_name'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">60</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="s1">'name'</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'employee_dept'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">ForeignKey</span><span class="p">(</span><span class="s2">"departments.department_id"</span><span class="p">))</span> <span class="p">)</span> <a href='#' class='sql_link'>sql</a><span class="n">employees</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">engine</span><span class="p">)</span> <div class='popup_sql'>CREATE TABLE employees( employee_id SERIAL NOT NULL PRIMARY KEY, employee_name VARCHAR(60) NOT NULL, employee_dept INTEGER REFERENCES departments(department_id) ) {}</div></pre></div> </div> <p><code class="docutils literal notranslate"><span class="pre">drop()</span></code> method:</p> <div class="highlight-python+sql notranslate"><div class="highlight"><pre><span></span><a href='#' class='sql_link'>sql</a><span class="n">employees</span><span class="o">.</span><span class="n">drop</span><span class="p">(</span><span class="n">engine</span><span class="p">)</span> <div class='popup_sql'>DROP TABLE employees {}</div></pre></div> </div> <p>To enable the “check first for the table existing” logic, add the <code class="docutils literal notranslate"><span class="pre">checkfirst=True</span></code> argument to <code class="docutils literal notranslate"><span class="pre">create()</span></code> or <code class="docutils literal notranslate"><span class="pre">drop()</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">employees</span><span class="o">.</span><span class="n">create</span><span class="p">(</span><span class="n">engine</span><span class="p">,</span> <span class="n">checkfirst</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span> <span class="n">employees</span><span class="o">.</span><span class="n">drop</span><span class="p">(</span><span class="n">engine</span><span class="p">,</span> <span class="n">checkfirst</span><span class="o">=</span><span class="kc">False</span><span class="p">)</span></pre></div> </div> </div> <div class="section" id="altering-schemas-through-migrations"> <span id="schema-migrations"></span><h2>Altering Schemas through Migrations<a class="headerlink" href="#altering-schemas-through-migrations" title="Permalink to this headline">¶</a></h2> <p>While SQLAlchemy directly supports emitting CREATE and DROP statements for schema constructs, the ability to alter those constructs, usually via the ALTER statement as well as other database-specific constructs, is outside of the scope of SQLAlchemy itself. While it’s easy enough to emit ALTER statements and similar by hand, such as by passing a string to <a class="reference internal" href="connections.html#sqlalchemy.engine.Connection.execute" title="sqlalchemy.engine.Connection.execute"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Connection.execute()</span></code></a> or by using the <a class="reference internal" href="ddl.html#sqlalchemy.schema.DDL" title="sqlalchemy.schema.DDL"><code class="xref py py-class docutils literal notranslate"><span class="pre">DDL</span></code></a> construct, it’s a common practice to automate the maintenance of database schemas in relation to application code using schema migration tools.</p> <p>There are two major migration tools available for SQLAlchemy:</p> <ul class="simple"> <li><p><a class="reference external" href="https://alembic.sqlalchemy.org">Alembic</a> - Written by the author of SQLAlchemy, Alembic features a highly customizable environment and a minimalistic usage pattern, supporting such features as transactional DDL, automatic generation of “candidate” migrations, an “offline” mode which generates SQL scripts, and support for branch resolution.</p></li> <li><p><a class="reference external" href="https://github.com/openstack/sqlalchemy-migrate">SQLAlchemy-Migrate</a> - The original migration tool for SQLAlchemy, SQLAlchemy-Migrate is still used by projects such as Openstack, however is being superseded by Alembic.</p></li> </ul> </div> <div class="section" id="specifying-the-schema-name"> <h2>Specifying the Schema Name<a class="headerlink" href="#specifying-the-schema-name" title="Permalink to this headline">¶</a></h2> <p>Some databases support the concept of multiple schemas. A <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> can reference this by specifying the <code class="docutils literal notranslate"><span class="pre">schema</span></code> keyword argument:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">financial_info</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'financial_info'</span><span class="p">,</span> <span class="n">meta</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'value'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">100</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="kc">False</span><span class="p">),</span> <span class="n">schema</span><span class="o">=</span><span class="s1">'remote_banks'</span> <span class="p">)</span></pre></div> </div> <p>Within the <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection, this table will be identified by the combination of <code class="docutils literal notranslate"><span class="pre">financial_info</span></code> and <code class="docutils literal notranslate"><span class="pre">remote_banks</span></code>. If another table called <code class="docutils literal notranslate"><span class="pre">financial_info</span></code> is referenced without the <code class="docutils literal notranslate"><span class="pre">remote_banks</span></code> schema, it will refer to a different <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>. <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a> objects can specify references to columns in this table using the form <code class="docutils literal notranslate"><span class="pre">remote_banks.financial_info.id</span></code>.</p> <p>The <code class="docutils literal notranslate"><span class="pre">schema</span></code> argument should be used for any name qualifiers required, including Oracle’s “owner” attribute and similar. It also can accommodate a dotted name for longer schemes:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">schema</span><span class="o">=</span><span class="s2">"dbo.scott"</span></pre></div> </div> </div> <div class="section" id="backend-specific-options"> <h2>Backend-Specific Options<a class="headerlink" href="#backend-specific-options" title="Permalink to this headline">¶</a></h2> <p><a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> supports database-specific options. For example, MySQL has different table backend types, including “MyISAM” and “InnoDB”. This can be expressed with <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> using <code class="docutils literal notranslate"><span class="pre">mysql_engine</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">addresses</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'engine_email_addresses'</span><span class="p">,</span> <span class="n">meta</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'address_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'remote_user_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">ForeignKey</span><span class="p">(</span><span class="n">users</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">user_id</span><span class="p">)),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'email_address'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">20</span><span class="p">)),</span> <span class="n">mysql_engine</span><span class="o">=</span><span class="s1">'InnoDB'</span> <span class="p">)</span></pre></div> </div> <p>Other backends may support table-level options as well - these would be described in the individual documentation sections for each dialect.</p> </div> <div class="section" id="column-table-metadata-api"> <h2>Column, Table, MetaData API<a class="headerlink" href="#column-table-metadata-api" title="Permalink to this headline">¶</a></h2> <dl class="attribute"> <dt id="sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA"> <code class="descclassname">sqlalchemy.schema.</code><code class="descname">BLANK_SCHEMA</code><a class="headerlink" href="#sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA" title="Permalink to this definition">¶</a></dt> <dd><p>Symbol indicating that a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> or <a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><code class="xref py py-class docutils literal notranslate"><span class="pre">Sequence</span></code></a> should have ‘None’ for its schema, even if the parent <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> has specified a schema.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData.params.schema" title="sqlalchemy.schema.MetaData"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">MetaData.schema</span></code></a></p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.schema" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.schema</span></code></a></p> <p><a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence.params.schema" title="sqlalchemy.schema.Sequence"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Sequence.schema</span></code></a></p> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.0.14.</span></p> </div> </dd></dl> <dl class="class"> <dt id="sqlalchemy.schema.Column"> <em class="property">class </em><code class="descclassname">sqlalchemy.schema.</code><code class="descname">Column</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.schema.SchemaItem</span></code></a>, <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnClause" title="sqlalchemy.sql.expression.ColumnClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.sql.expression.ColumnClause</span></code></a></p> <p>Represents a column in a database table.</p> <dl class="method"> <dt id="sqlalchemy.schema.Column.__eq__"> <code class="descname">__eq__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.__eq__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.__eq__" title="sqlalchemy.sql.operators.ColumnOperators.__eq__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__eq__()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">==</span></code> operator.</p> <p>In a column context, produces the clause <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">=</span> <span class="pre">b</span></code>. If the target is <code class="docutils literal notranslate"><span class="pre">None</span></code>, produces <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">IS</span> <span class="pre">NULL</span></code>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>*args</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Construct a new <code class="docutils literal notranslate"><span class="pre">Column</span></code> object.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.params.name"></span><strong>name</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.name">¶</a> – <p>The name of this column as represented in the database. This argument may be the first positional argument, or specified via keyword.</p> <p>Names which contain no upper case characters will be treated as case insensitive names, and will not be quoted unless they are a reserved word. Names with any number of upper case characters will be quoted and sent exactly. Note that this behavior applies even for databases which standardize upper case names as case insensitive such as Oracle.</p> <p>The name field may be omitted at construction time and applied later, at any time before the Column is associated with a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>. This is to support convenient usage within the <a class="reference internal" href="../orm/extensions/declarative/api.html#module-sqlalchemy.ext.declarative" title="sqlalchemy.ext.declarative"><code class="xref py py-mod docutils literal notranslate"><span class="pre">declarative</span></code></a> extension.</p> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.type_"></span><strong>type_</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.type_">¶</a> – <p>The column’s type, indicated using an instance which subclasses <a class="reference internal" href="type_api.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><code class="xref py py-class docutils literal notranslate"><span class="pre">TypeEngine</span></code></a>. If no arguments are required for the type, the class of the type can be sent as well, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># use a type with arguments</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'data'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">))</span> <span class="c1"># use no arguments</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'level'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">)</span></pre></div> </div> <p>The <code class="docutils literal notranslate"><span class="pre">type</span></code> argument may be the second positional argument or specified by keyword.</p> <p>If the <code class="docutils literal notranslate"><span class="pre">type</span></code> is <code class="docutils literal notranslate"><span class="pre">None</span></code> or is omitted, it will first default to the special type <a class="reference internal" href="type_api.html#sqlalchemy.types.NullType" title="sqlalchemy.types.NullType"><code class="xref py py-class docutils literal notranslate"><span class="pre">NullType</span></code></a>. If and when this <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> is made to refer to another column using <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a> and/or <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a>, the type of the remote-referenced column will be copied to this column as well, at the moment that the foreign key is resolved against that remote <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> object.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 0.9.0: </span>Support for propagation of type to a <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> from its <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a> object has been improved and should be more reliable and timely.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.*args"></span><strong>*args</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.*args">¶</a> – Additional positional arguments include various <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a> derived constructs which will be applied as options to the column. These include instances of <a class="reference internal" href="constraints.html#sqlalchemy.schema.Constraint" title="sqlalchemy.schema.Constraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constraint</span></code></a>, <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a>, <a class="reference internal" href="defaults.html#sqlalchemy.schema.ColumnDefault" title="sqlalchemy.schema.ColumnDefault"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnDefault</span></code></a>, and <a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><code class="xref py py-class docutils literal notranslate"><span class="pre">Sequence</span></code></a>. In some cases an equivalent keyword argument is available such as <code class="docutils literal notranslate"><span class="pre">server_default</span></code>, <code class="docutils literal notranslate"><span class="pre">default</span></code> and <code class="docutils literal notranslate"><span class="pre">unique</span></code>.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.autoincrement"></span><strong>autoincrement</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.autoincrement">¶</a> – <p>Set up “auto increment” semantics for an integer primary key column. The default value is the string <code class="docutils literal notranslate"><span class="pre">"auto"</span></code> which indicates that a single-column primary key that is of an INTEGER type with no stated client-side or python-side defaults should receive auto increment semantics automatically; all other varieties of primary key columns will not. This includes that <a class="reference internal" href="../glossary.html#term-ddl"><span class="xref std std-term">DDL</span></a> such as PostgreSQL SERIAL or MySQL AUTO_INCREMENT will be emitted for this column during a table create, as well as that the column is assumed to generate new integer primary key values when an INSERT statement invokes which will be retrieved by the dialect.</p> <p>The flag may be set to <code class="docutils literal notranslate"><span class="pre">True</span></code> to indicate that a column which is part of a composite (e.g. multi-column) primary key should have autoincrement semantics, though note that only one column within a primary key may have this setting. It can also be set to <code class="docutils literal notranslate"><span class="pre">True</span></code> to indicate autoincrement semantics on a column that has a client-side or server-side default configured, however note that not all dialects can accommodate all styles of default as an “autoincrement”. It can also be set to <code class="docutils literal notranslate"><span class="pre">False</span></code> on a single-column primary key that has a datatype of INTEGER in order to disable auto increment semantics for that column.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.1: </span>The autoincrement flag now defaults to <code class="docutils literal notranslate"><span class="pre">"auto"</span></code> which indicates autoincrement semantics by default for single-column integer primary keys only; for composite (multi-column) primary keys, autoincrement is never implicitly enabled; as always, <code class="docutils literal notranslate"><span class="pre">autoincrement=True</span></code> will allow for at most one of those columns to be an “autoincrement” column. <code class="docutils literal notranslate"><span class="pre">autoincrement=True</span></code> may also be set on a <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> that has an explicit client-side or server-side default, subject to limitations of the backend database and dialect.</p> </div> <p>The setting <em>only</em> has an effect for columns which are:</p> <ul> <li><p>Integer derived (i.e. INT, SMALLINT, BIGINT).</p></li> <li><p>Part of the primary key</p></li> <li><p>Not referring to another column via <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a>, unless the value is specified as <code class="docutils literal notranslate"><span class="pre">'ignore_fk'</span></code>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># turn on autoincrement for this column despite</span> <span class="c1"># the ForeignKey()</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'id'</span><span class="p">,</span> <span class="n">ForeignKey</span><span class="p">(</span><span class="s1">'other.id'</span><span class="p">),</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">autoincrement</span><span class="o">=</span><span class="s1">'ignore_fk'</span><span class="p">)</span></pre></div> </div> <p>It is typically not desirable to have “autoincrement” enabled on a column that refers to another via foreign key, as such a column is required to refer to a value that originates from elsewhere.</p> </li> </ul> <p>The setting has these two effects on columns that meet the above criteria:</p> <ul> <li><p>DDL issued for the column will include database-specific keywords intended to signify this column as an “autoincrement” column, such as AUTO INCREMENT on MySQL, SERIAL on PostgreSQL, and IDENTITY on MS-SQL. It does <em>not</em> issue AUTOINCREMENT for SQLite since this is a special SQLite flag that is not required for autoincrementing behavior.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="../dialects/sqlite.html#sqlite-autoincrement"><span class="std std-ref">SQLite Auto Incrementing Behavior</span></a></p> </div> </li> <li><p>The column will be considered to be available using an “autoincrement” method specific to the backend database, such as calling upon <code class="docutils literal notranslate"><span class="pre">cursor.lastrowid</span></code>, using RETURNING in an INSERT statement to get at a sequence-generated value, or using special functions such as “SELECT scope_identity()”. These methods are highly specific to the DBAPIs and databases in use and vary greatly, so care should be taken when associating <code class="docutils literal notranslate"><span class="pre">autoincrement=True</span></code> with a custom default generation function.</p></li> </ul> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.default"></span><strong>default</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.default">¶</a> – <p>A scalar, Python callable, or <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a> expression representing the <em>default value</em> for this column, which will be invoked upon insert if this column is otherwise not specified in the VALUES clause of the insert. This is a shortcut to using <a class="reference internal" href="defaults.html#sqlalchemy.schema.ColumnDefault" title="sqlalchemy.schema.ColumnDefault"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnDefault</span></code></a> as a positional argument; see that class for full detail on the structure of the argument.</p> <p>Contrast this argument to <a class="reference internal" href="#sqlalchemy.schema.Column.params.server_default" title="sqlalchemy.schema.Column"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Column.server_default</span></code></a> which creates a default generator on the database side.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="defaults.html"><span class="std std-ref">Column Insert/Update Defaults</span></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.doc"></span><strong>doc</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.doc">¶</a> – optional String that can be used by the ORM or similar to document attributes on the Python side. This attribute does <strong>not</strong> render SQL comments; use the <a class="reference internal" href="#sqlalchemy.schema.Column.params.comment" title="sqlalchemy.schema.Column"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Column.comment</span></code></a> parameter for this purpose.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.key"></span><strong>key</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.key">¶</a> – An optional string identifier which will identify this <code class="docutils literal notranslate"><span class="pre">Column</span></code> object on the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>. When a key is provided, this is the only identifier referencing the <code class="docutils literal notranslate"><span class="pre">Column</span></code> within the application, including ORM attribute mapping; the <code class="docutils literal notranslate"><span class="pre">name</span></code> field is used only when rendering SQL.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.index"></span><strong>index</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.index">¶</a> – When <code class="docutils literal notranslate"><span class="pre">True</span></code>, indicates that the column is indexed. This is a shortcut for using a <a class="reference internal" href="constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><code class="xref py py-class docutils literal notranslate"><span class="pre">Index</span></code></a> construct on the table. To specify indexes with explicit names or indexes that contain multiple columns, use the <a class="reference internal" href="constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><code class="xref py py-class docutils literal notranslate"><span class="pre">Index</span></code></a> construct instead.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.info"></span><strong>info</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.info">¶</a> – Optional data dictionary which will be populated into the <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.info" title="sqlalchemy.schema.SchemaItem.info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">SchemaItem.info</span></code></a> attribute of this object.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.nullable"></span><strong>nullable</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.nullable">¶</a> – When set to <code class="docutils literal notranslate"><span class="pre">False</span></code>, will cause the “NOT NULL” phrase to be added when generating DDL for the column. When <code class="docutils literal notranslate"><span class="pre">True</span></code>, will normally generate nothing (in SQL this defaults to “NULL”), except in some very specific backend-specific edge cases where “NULL” may render explicitly. Defaults to <code class="docutils literal notranslate"><span class="pre">True</span></code> unless <a class="reference internal" href="#sqlalchemy.schema.Column.params.primary_key" title="sqlalchemy.schema.Column"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">primary_key</span></code></a> is also <code class="docutils literal notranslate"><span class="pre">True</span></code>, in which case it defaults to <code class="docutils literal notranslate"><span class="pre">False</span></code>. This parameter is only used when issuing CREATE TABLE statements.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.onupdate"></span><strong>onupdate</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.onupdate">¶</a> – <p>A scalar, Python callable, or <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a> representing a default value to be applied to the column within UPDATE statements, which will be invoked upon update if this column is not present in the SET clause of the update. This is a shortcut to using <a class="reference internal" href="defaults.html#sqlalchemy.schema.ColumnDefault" title="sqlalchemy.schema.ColumnDefault"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnDefault</span></code></a> as a positional argument with <code class="docutils literal notranslate"><span class="pre">for_update=True</span></code>.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="defaults.html#metadata-defaults"><span class="std std-ref">Column Insert/Update Defaults</span></a> - complete discussion of onupdate</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.primary_key"></span><strong>primary_key</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.primary_key">¶</a> – If <code class="docutils literal notranslate"><span class="pre">True</span></code>, marks this column as a primary key column. Multiple columns can have this flag set to specify composite primary keys. As an alternative, the primary key of a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> can be specified via an explicit <a class="reference internal" href="constraints.html#sqlalchemy.schema.PrimaryKeyConstraint" title="sqlalchemy.schema.PrimaryKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">PrimaryKeyConstraint</span></code></a> object.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.server_default"></span><strong>server_default</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.server_default">¶</a> – <p>A <a class="reference internal" href="defaults.html#sqlalchemy.schema.FetchedValue" title="sqlalchemy.schema.FetchedValue"><code class="xref py py-class docutils literal notranslate"><span class="pre">FetchedValue</span></code></a> instance, str, Unicode or <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.text" title="sqlalchemy.sql.expression.text"><code class="xref py py-func docutils literal notranslate"><span class="pre">text()</span></code></a> construct representing the DDL DEFAULT value for the column.</p> <p>String types will be emitted as-is, surrounded by single quotes:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Column</span><span class="p">(</span><span class="s1">'x'</span><span class="p">,</span> <span class="n">Text</span><span class="p">,</span> <span class="n">server_default</span><span class="o">=</span><span class="s2">"val"</span><span class="p">)</span> <span class="n">x</span> <span class="n">TEXT</span> <span class="n">DEFAULT</span> <span class="s1">'val'</span></pre></div> </div> <p>A <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.text" title="sqlalchemy.sql.expression.text"><code class="xref py py-func docutils literal notranslate"><span class="pre">text()</span></code></a> expression will be rendered as-is, without quotes:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Column</span><span class="p">(</span><span class="s1">'y'</span><span class="p">,</span> <span class="n">DateTime</span><span class="p">,</span> <span class="n">server_default</span><span class="o">=</span><span class="n">text</span><span class="p">(</span><span class="s1">'NOW()'</span><span class="p">))</span> <span class="n">y</span> <span class="n">DATETIME</span> <span class="n">DEFAULT</span> <span class="n">NOW</span><span class="p">()</span></pre></div> </div> <p>Strings and text() will be converted into a <a class="reference internal" href="defaults.html#sqlalchemy.schema.DefaultClause" title="sqlalchemy.schema.DefaultClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">DefaultClause</span></code></a> object upon initialization.</p> <p>Use <a class="reference internal" href="defaults.html#sqlalchemy.schema.FetchedValue" title="sqlalchemy.schema.FetchedValue"><code class="xref py py-class docutils literal notranslate"><span class="pre">FetchedValue</span></code></a> to indicate that an already-existing column will generate a default value on the database side which will be available to SQLAlchemy for post-fetch after inserts. This construct does not specify any DDL and the implementation is left to the database, such as via a trigger.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="defaults.html#server-defaults"><span class="std std-ref">Server-invoked DDL-Explicit Default Expressions</span></a> - complete discussion of server side defaults</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.server_onupdate"></span><strong>server_onupdate</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.server_onupdate">¶</a> – <dl class="simple"> <dt>A <a class="reference internal" href="defaults.html#sqlalchemy.schema.FetchedValue" title="sqlalchemy.schema.FetchedValue"><code class="xref py py-class docutils literal notranslate"><span class="pre">FetchedValue</span></code></a> instance</dt><dd><p>representing a database-side default generation function, such as a trigger. This indicates to SQLAlchemy that a newly generated value will be available after updates. This construct does not actually implement any kind of generation function within the database, which instead must be specified separately.</p> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="defaults.html#triggered-columns"><span class="std std-ref">Marking Implicitly Generated Values, timestamps, and Triggered Columns</span></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.quote"></span><strong>quote</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.quote">¶</a> – Force quoting of this column’s name on or off, corresponding to <code class="docutils literal notranslate"><span class="pre">True</span></code> or <code class="docutils literal notranslate"><span class="pre">False</span></code>. When left at its default of <code class="docutils literal notranslate"><span class="pre">None</span></code>, the column identifier will be quoted according to whether the name is case sensitive (identifiers with at least one upper case character are treated as case sensitive), or if it’s a reserved word. This flag is only needed to force quoting of a reserved word which is not known by the SQLAlchemy dialect.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.unique"></span><strong>unique</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.unique">¶</a> – When <code class="docutils literal notranslate"><span class="pre">True</span></code>, indicates that this column contains a unique constraint, or if <code class="docutils literal notranslate"><span class="pre">index</span></code> is <code class="docutils literal notranslate"><span class="pre">True</span></code> as well, indicates that the <a class="reference internal" href="constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><code class="xref py py-class docutils literal notranslate"><span class="pre">Index</span></code></a> should be created with the unique flag. To specify multiple columns in the constraint/index or to specify an explicit name, use the <a class="reference internal" href="constraints.html#sqlalchemy.schema.UniqueConstraint" title="sqlalchemy.schema.UniqueConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">UniqueConstraint</span></code></a> or <a class="reference internal" href="constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><code class="xref py py-class docutils literal notranslate"><span class="pre">Index</span></code></a> constructs explicitly.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.system"></span><strong>system</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.system">¶</a> – <p>When <code class="docutils literal notranslate"><span class="pre">True</span></code>, indicates this is a “system” column, that is a column which is automatically made available by the database, and should not be included in the columns list for a <code class="docutils literal notranslate"><span class="pre">CREATE</span> <span class="pre">TABLE</span></code> statement.</p> <p>For more elaborate scenarios where columns should be conditionally rendered differently on different backends, consider custom compilation rules for <a class="reference internal" href="ddl.html#sqlalchemy.schema.CreateColumn" title="sqlalchemy.schema.CreateColumn"><code class="xref py py-class docutils literal notranslate"><span class="pre">CreateColumn</span></code></a>.</p> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.params.comment"></span><strong>comment</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.params.comment">¶</a> – <p>Optional string that will render an SQL comment on table creation.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2: </span>Added the <a class="reference internal" href="#sqlalchemy.schema.Column.params.comment" title="sqlalchemy.schema.Column"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Column.comment</span></code></a> parameter to <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a>.</p> </div> </p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.__le__"> <code class="descname">__le__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.__le__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.__le__" title="sqlalchemy.sql.operators.ColumnOperators.__le__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__le__()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre"><=</span></code> operator.</p> <p>In a column context, produces the clause <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre"><=</span> <span class="pre">b</span></code>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.__lt__"> <code class="descname">__lt__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.__lt__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.__lt__" title="sqlalchemy.sql.operators.ColumnOperators.__lt__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__lt__()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre"><</span></code> operator.</p> <p>In a column context, produces the clause <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre"><</span> <span class="pre">b</span></code>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.__ne__"> <code class="descname">__ne__</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.__ne__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.__ne__" title="sqlalchemy.sql.operators.ColumnOperators.__ne__"><code class="xref py py-meth docutils literal notranslate"><span class="pre">__ne__()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">!=</span></code> operator.</p> <p>In a column context, produces the clause <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">!=</span> <span class="pre">b</span></code>. If the target is <code class="docutils literal notranslate"><span class="pre">None</span></code>, produces <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">IS</span> <span class="pre">NOT</span> <span class="pre">NULL</span></code>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.all_"> <code class="descname">all_</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.all_" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.all_" title="sqlalchemy.sql.operators.ColumnOperators.all_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">all_()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.all_" title="sqlalchemy.sql.expression.all_"><code class="xref py py-func docutils literal notranslate"><span class="pre">all_()</span></code></a> clause against the parent object.</p> <p>This operator is only appropriate against a scalar subquery object, or for some backends an column expression that is against the ARRAY type, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># postgresql '5 = ALL (somearray)'</span> <span class="n">expr</span> <span class="o">=</span> <span class="mi">5</span> <span class="o">==</span> <span class="n">mytable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">somearray</span><span class="o">.</span><span class="n">all_</span><span class="p">()</span> <span class="c1"># mysql '5 = ALL (SELECT value FROM table)'</span> <span class="n">expr</span> <span class="o">=</span> <span class="mi">5</span> <span class="o">==</span> <span class="n">select</span><span class="p">([</span><span class="n">table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">value</span><span class="p">])</span><span class="o">.</span><span class="n">as_scalar</span><span class="p">()</span><span class="o">.</span><span class="n">all_</span><span class="p">()</span></pre></div> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.all_" title="sqlalchemy.sql.expression.all_"><code class="xref py py-func docutils literal notranslate"><span class="pre">all_()</span></code></a> - standalone version</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.any_" title="sqlalchemy.sql.expression.any_"><code class="xref py py-func docutils literal notranslate"><span class="pre">any_()</span></code></a> - ANY operator</p> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Column.anon_label"> <code class="descname">anon_label</code><a class="headerlink" href="#sqlalchemy.schema.Column.anon_label" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.anon_label" title="sqlalchemy.sql.expression.ColumnElement.anon_label"><code class="xref py py-attr docutils literal notranslate"><span class="pre">anon_label</span></code></a> <em>attribute of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>provides a constant ‘anonymous label’ for this ColumnElement.</p> <p>This is a label() expression which will be named at compile time. The same label() is returned each time anon_label is called so that expressions can reference anon_label multiple times, producing the same label name at compile time.</p> <p>the compiler uses this function automatically at compile time for expressions that are known to be ‘unnamed’ like binary expressions and function calls.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.any_"> <code class="descname">any_</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.any_" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.any_" title="sqlalchemy.sql.operators.ColumnOperators.any_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">any_()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.any_" title="sqlalchemy.sql.expression.any_"><code class="xref py py-func docutils literal notranslate"><span class="pre">any_()</span></code></a> clause against the parent object.</p> <p>This operator is only appropriate against a scalar subquery object, or for some backends an column expression that is against the ARRAY type, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="c1"># postgresql '5 = ANY (somearray)'</span> <span class="n">expr</span> <span class="o">=</span> <span class="mi">5</span> <span class="o">==</span> <span class="n">mytable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">somearray</span><span class="o">.</span><span class="n">any_</span><span class="p">()</span> <span class="c1"># mysql '5 = ANY (SELECT value FROM table)'</span> <span class="n">expr</span> <span class="o">=</span> <span class="mi">5</span> <span class="o">==</span> <span class="n">select</span><span class="p">([</span><span class="n">table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">value</span><span class="p">])</span><span class="o">.</span><span class="n">as_scalar</span><span class="p">()</span><span class="o">.</span><span class="n">any_</span><span class="p">()</span></pre></div> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.any_" title="sqlalchemy.sql.expression.any_"><code class="xref py py-func docutils literal notranslate"><span class="pre">any_()</span></code></a> - standalone version</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.all_" title="sqlalchemy.sql.expression.all_"><code class="xref py py-func docutils literal notranslate"><span class="pre">all_()</span></code></a> - ALL operator</p> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.asc"> <code class="descname">asc</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.asc" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.asc" title="sqlalchemy.sql.operators.ColumnOperators.asc"><code class="xref py py-meth docutils literal notranslate"><span class="pre">asc()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.asc" title="sqlalchemy.sql.expression.asc"><code class="xref py py-func docutils literal notranslate"><span class="pre">asc()</span></code></a> clause against the parent object.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.between"> <code class="descname">between</code><span class="sig-paren">(</span><em>cleft</em>, <em>cright</em>, <em>symmetric=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.between" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.between" title="sqlalchemy.sql.operators.ColumnOperators.between"><code class="xref py py-meth docutils literal notranslate"><span class="pre">between()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.between" title="sqlalchemy.sql.expression.between"><code class="xref py py-func docutils literal notranslate"><span class="pre">between()</span></code></a> clause against the parent object, given the lower and upper range.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.bool_op"> <code class="descname">bool_op</code><span class="sig-paren">(</span><em>opstring</em>, <em>precedence=0</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.bool_op" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.bool_op" title="sqlalchemy.sql.operators.Operators.bool_op"><code class="xref py py-meth docutils literal notranslate"><span class="pre">bool_op()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators" title="sqlalchemy.sql.operators.Operators"><code class="xref py py-class docutils literal notranslate"><span class="pre">Operators</span></code></a></p> </div> <p>Return a custom boolean operator.</p> <p>This method is shorthand for calling <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Operators.op()</span></code></a> and passing the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op.params.is_comparison" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Operators.op.is_comparison</span></code></a> flag with True.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2.0b3.</span></p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Operators.op()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.cast"> <code class="descname">cast</code><span class="sig-paren">(</span><em>type_</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.cast" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.cast" title="sqlalchemy.sql.expression.ColumnElement.cast"><code class="xref py py-meth docutils literal notranslate"><span class="pre">cast()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Produce a type cast, i.e. <code class="docutils literal notranslate"><span class="pre">CAST(<expression></span> <span class="pre">AS</span> <span class="pre"><type>)</span></code>.</p> <p>This is a shortcut to the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.cast" title="sqlalchemy.sql.expression.cast"><code class="xref py py-func docutils literal notranslate"><span class="pre">cast()</span></code></a> function.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.0.7.</span></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.collate"> <code class="descname">collate</code><span class="sig-paren">(</span><em>collation</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.collate" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.collate" title="sqlalchemy.sql.operators.ColumnOperators.collate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">collate()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.collate" title="sqlalchemy.sql.expression.collate"><code class="xref py py-func docutils literal notranslate"><span class="pre">collate()</span></code></a> clause against the parent object, given the collation string.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.collate" title="sqlalchemy.sql.expression.collate"><code class="xref py py-func docutils literal notranslate"><span class="pre">collate()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.compare"> <code class="descname">compare</code><span class="sig-paren">(</span><em>other</em>, <em>use_proxies=False</em>, <em>equivalents=None</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.compare" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.compare" title="sqlalchemy.sql.expression.ColumnElement.compare"><code class="xref py py-meth docutils literal notranslate"><span class="pre">compare()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Compare this ColumnElement to another.</p> <p>Special arguments understood:</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.compare.params.use_proxies"></span><strong>use_proxies</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compare.params.use_proxies">¶</a> – when True, consider two columns that share a common base column as equivalent (i.e. shares_lineage())</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.compare.params.equivalents"></span><strong>equivalents</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compare.params.equivalents">¶</a> – a dictionary of columns as keys mapped to sets of columns. If the given “other” column is present in this dictionary, if any of the columns in the corresponding set() pass the comparison test, the result is True. This is used to expand the comparison to other columns that may be known to be equivalent to this one via foreign key or other criterion.</p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.compile"> <code class="descname">compile</code><span class="sig-paren">(</span><em>default</em>, <em>bind=None</em>, <em>dialect=None</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.compile" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement.compile" title="sqlalchemy.sql.expression.ClauseElement.compile"><code class="xref py py-meth docutils literal notranslate"><span class="pre">compile()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a></p> </div> <p>Compile this SQL expression.</p> <p>The return value is a <a class="reference internal" href="internals.html#sqlalchemy.engine.interfaces.Compiled" title="sqlalchemy.engine.interfaces.Compiled"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compiled</span></code></a> object. Calling <code class="docutils literal notranslate"><span class="pre">str()</span></code> or <code class="docutils literal notranslate"><span class="pre">unicode()</span></code> on the returned value will yield a string representation of the result. The <a class="reference internal" href="internals.html#sqlalchemy.engine.interfaces.Compiled" title="sqlalchemy.engine.interfaces.Compiled"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compiled</span></code></a> object also can return a dictionary of bind parameter names and values using the <code class="docutils literal notranslate"><span class="pre">params</span></code> accessor.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.compile.params.bind"></span><strong>bind</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compile.params.bind">¶</a> – An <code class="docutils literal notranslate"><span class="pre">Engine</span></code> or <code class="docutils literal notranslate"><span class="pre">Connection</span></code> from which a <code class="docutils literal notranslate"><span class="pre">Compiled</span></code> will be acquired. This argument takes precedence over this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a>’s bound engine, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.compile.params.column_keys"></span><strong>column_keys</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compile.params.column_keys">¶</a> – Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, all columns from the target table object are rendered.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.compile.params.dialect"></span><strong>dialect</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compile.params.dialect">¶</a> – A <code class="docutils literal notranslate"><span class="pre">Dialect</span></code> instance from which a <code class="docutils literal notranslate"><span class="pre">Compiled</span></code> will be acquired. This argument takes precedence over the <cite>bind</cite> argument as well as this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a>’s bound engine, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.compile.params.inline"></span><strong>inline</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compile.params.inline">¶</a> – Used for INSERT statements, for a dialect which does not support inline retrieval of newly generated primary key columns, will force the expression used to create the new primary key value to be rendered inline within the INSERT statement’s VALUES clause. This typically refers to Sequence execution but may also refer to any server-side default generation function associated with a primary key <cite>Column</cite>.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.compile.params.compile_kwargs"></span><strong>compile_kwargs</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.compile.params.compile_kwargs">¶</a> – <p>optional dictionary of additional parameters that will be passed through to the compiler within all “visit” methods. This allows any custom flag to be passed through to a custom compilation construct, for example. It is also used for the case of passing the <code class="docutils literal notranslate"><span class="pre">literal_binds</span></code> flag through:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">sqlalchemy.sql</span> <span class="k">import</span> <span class="n">table</span><span class="p">,</span> <span class="n">column</span><span class="p">,</span> <span class="n">select</span> <span class="n">t</span> <span class="o">=</span> <span class="n">table</span><span class="p">(</span><span class="s1">'t'</span><span class="p">,</span> <span class="n">column</span><span class="p">(</span><span class="s1">'x'</span><span class="p">))</span> <span class="n">s</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">t</span><span class="p">])</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">t</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">x</span> <span class="o">==</span> <span class="mi">5</span><span class="p">)</span> <span class="nb">print</span> <span class="n">s</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="n">compile_kwargs</span><span class="o">=</span><span class="p">{</span><span class="s2">"literal_binds"</span><span class="p">:</span> <span class="kc">True</span><span class="p">})</span></pre></div> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.0.</span></p> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="../faq/sqlexpressions.html#faq-sql-expression-string"><span class="std std-ref">How do I render SQL expressions as strings, possibly with bound parameters inlined?</span></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.concat"> <code class="descname">concat</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.concat" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.concat" title="sqlalchemy.sql.operators.ColumnOperators.concat"><code class="xref py py-meth docutils literal notranslate"><span class="pre">concat()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the ‘concat’ operator.</p> <p>In a column context, produces the clause <code class="docutils literal notranslate"><span class="pre">a</span> <span class="pre">||</span> <span class="pre">b</span></code>, or uses the <code class="docutils literal notranslate"><span class="pre">concat()</span></code> operator on MySQL.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.contains"> <code class="descname">contains</code><span class="sig-paren">(</span><em>other</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.contains" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-meth docutils literal notranslate"><span class="pre">contains()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the ‘contains’ operator.</p> <p>Produces a LIKE expression that tests against a match for the middle of a string value:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">column</span> <span class="n">LIKE</span> <span class="s1">'%'</span> <span class="o">||</span> <span class="o"><</span><span class="n">other</span><span class="o">></span> <span class="o">||</span> <span class="s1">'%'</span></pre></div> </div> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">sometable</span><span class="p">])</span><span class="o">.</span>\ <span class="n">where</span><span class="p">(</span><span class="n">sometable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">column</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="s2">"foobar"</span><span class="p">))</span></pre></div> </div> <p>Since the operator uses <code class="docutils literal notranslate"><span class="pre">LIKE</span></code>, wildcard characters <code class="docutils literal notranslate"><span class="pre">"%"</span></code> and <code class="docutils literal notranslate"><span class="pre">"_"</span></code> that are present inside the <other> expression will behave like wildcards as well. For literal string values, the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.contains.autoescape</span></code></a> flag may be set to <code class="docutils literal notranslate"><span class="pre">True</span></code> to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains.params.escape" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.contains.escape</span></code></a> parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.contains.params.other"></span><strong>other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.contains.params.other">¶</a> – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters <code class="docutils literal notranslate"><span class="pre">%</span></code> and <code class="docutils literal notranslate"><span class="pre">_</span></code> are not escaped by default unless the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.contains.autoescape</span></code></a> flag is set to True.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.contains.params.autoescape"></span><strong>autoescape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.contains.params.autoescape">¶</a> – <p>boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of <code class="docutils literal notranslate"><span class="pre">"%"</span></code>, <code class="docutils literal notranslate"><span class="pre">"_"</span></code> and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.</p> <p>An expression such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="s2">"foo%bar"</span><span class="p">,</span> <span class="n">autoescape</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <p>Will render as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="n">LIKE</span> <span class="s1">'%'</span> <span class="o">||</span> <span class="p">:</span><span class="n">param</span> <span class="o">||</span> <span class="s1">'%'</span> <span class="n">ESCAPE</span> <span class="s1">'/'</span></pre></div> </div> <p>With the value of :param as <code class="docutils literal notranslate"><span class="pre">"foo/%bar"</span></code>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2.</span></p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.2.0: </span>The <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.contains.autoescape</span></code></a> parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains.params.escape" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.contains.escape</span></code></a> parameter.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.contains.params.escape"></span><strong>escape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.contains.params.escape">¶</a> – <p>a character which when given will render with the <code class="docutils literal notranslate"><span class="pre">ESCAPE</span></code> keyword to establish that character as the escape character. This character can then be placed preceding occurrences of <code class="docutils literal notranslate"><span class="pre">%</span></code> and <code class="docutils literal notranslate"><span class="pre">_</span></code> to allow them to act as themselves and not wildcard characters.</p> <p>An expression such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="s2">"foo/%bar"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"^"</span><span class="p">)</span></pre></div> </div> <p>Will render as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="n">LIKE</span> <span class="s1">'%'</span> <span class="o">||</span> <span class="p">:</span><span class="n">param</span> <span class="o">||</span> <span class="s1">'%'</span> <span class="n">ESCAPE</span> <span class="s1">'^'</span></pre></div> </div> <p>The parameter may also be combined with <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.contains.autoescape</span></code></a>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">contains</span><span class="p">(</span><span class="s2">"foo%bar^bat"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"^"</span><span class="p">,</span> <span class="n">autoescape</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <p>Where above, the given literal parameter will be converted to <code class="docutils literal notranslate"><span class="pre">"foo^%bar^^bat"</span></code> before being passed to the database.</p> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.startswith()</span></code></a></p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.endswith()</span></code></a></p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.like()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.copy"> <code class="descname">copy</code><span class="sig-paren">(</span><em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.copy" title="Permalink to this definition">¶</a></dt> <dd><p>Create a copy of this <code class="docutils literal notranslate"><span class="pre">Column</span></code>, uninitialized.</p> <p>This is used in <code class="docutils literal notranslate"><span class="pre">Table.tometadata</span></code>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.desc"> <code class="descname">desc</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.desc" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.desc" title="sqlalchemy.sql.operators.ColumnOperators.desc"><code class="xref py py-meth docutils literal notranslate"><span class="pre">desc()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.desc" title="sqlalchemy.sql.expression.desc"><code class="xref py py-func docutils literal notranslate"><span class="pre">desc()</span></code></a> clause against the parent object.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.distinct"> <code class="descname">distinct</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.distinct" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.distinct" title="sqlalchemy.sql.operators.ColumnOperators.distinct"><code class="xref py py-meth docutils literal notranslate"><span class="pre">distinct()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.distinct" title="sqlalchemy.sql.expression.distinct"><code class="xref py py-func docutils literal notranslate"><span class="pre">distinct()</span></code></a> clause against the parent object.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.endswith"> <code class="descname">endswith</code><span class="sig-paren">(</span><em>other</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.endswith" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-meth docutils literal notranslate"><span class="pre">endswith()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the ‘endswith’ operator.</p> <p>Produces a LIKE expression that tests against a match for the end of a string value:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">column</span> <span class="n">LIKE</span> <span class="s1">'%'</span> <span class="o">||</span> <span class="o"><</span><span class="n">other</span><span class="o">></span></pre></div> </div> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">sometable</span><span class="p">])</span><span class="o">.</span>\ <span class="n">where</span><span class="p">(</span><span class="n">sometable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">column</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s2">"foobar"</span><span class="p">))</span></pre></div> </div> <p>Since the operator uses <code class="docutils literal notranslate"><span class="pre">LIKE</span></code>, wildcard characters <code class="docutils literal notranslate"><span class="pre">"%"</span></code> and <code class="docutils literal notranslate"><span class="pre">"_"</span></code> that are present inside the <other> expression will behave like wildcards as well. For literal string values, the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.endswith.autoescape</span></code></a> flag may be set to <code class="docutils literal notranslate"><span class="pre">True</span></code> to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith.params.escape" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.endswith.escape</span></code></a> parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.endswith.params.other"></span><strong>other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.endswith.params.other">¶</a> – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters <code class="docutils literal notranslate"><span class="pre">%</span></code> and <code class="docutils literal notranslate"><span class="pre">_</span></code> are not escaped by default unless the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.endswith.autoescape</span></code></a> flag is set to True.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.endswith.params.autoescape"></span><strong>autoescape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.endswith.params.autoescape">¶</a> – <p>boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of <code class="docutils literal notranslate"><span class="pre">"%"</span></code>, <code class="docutils literal notranslate"><span class="pre">"_"</span></code> and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.</p> <p>An expression such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s2">"foo%bar"</span><span class="p">,</span> <span class="n">autoescape</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <p>Will render as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="n">LIKE</span> <span class="s1">'%'</span> <span class="o">||</span> <span class="p">:</span><span class="n">param</span> <span class="n">ESCAPE</span> <span class="s1">'/'</span></pre></div> </div> <p>With the value of :param as <code class="docutils literal notranslate"><span class="pre">"foo/%bar"</span></code>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2.</span></p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.2.0: </span>The <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.endswith.autoescape</span></code></a> parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith.params.escape" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.endswith.escape</span></code></a> parameter.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.endswith.params.escape"></span><strong>escape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.endswith.params.escape">¶</a> – <p>a character which when given will render with the <code class="docutils literal notranslate"><span class="pre">ESCAPE</span></code> keyword to establish that character as the escape character. This character can then be placed preceding occurrences of <code class="docutils literal notranslate"><span class="pre">%</span></code> and <code class="docutils literal notranslate"><span class="pre">_</span></code> to allow them to act as themselves and not wildcard characters.</p> <p>An expression such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s2">"foo/%bar"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"^"</span><span class="p">)</span></pre></div> </div> <p>Will render as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="n">LIKE</span> <span class="s1">'%'</span> <span class="o">||</span> <span class="p">:</span><span class="n">param</span> <span class="n">ESCAPE</span> <span class="s1">'^'</span></pre></div> </div> <p>The parameter may also be combined with <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.endswith.autoescape</span></code></a>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">endswith</span><span class="p">(</span><span class="s2">"foo%bar^bat"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"^"</span><span class="p">,</span> <span class="n">autoescape</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <p>Where above, the given literal parameter will be converted to <code class="docutils literal notranslate"><span class="pre">"foo^%bar^^bat"</span></code> before being passed to the database.</p> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.startswith()</span></code></a></p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.contains()</span></code></a></p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.like()</span></code></a></p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Column.expression"> <code class="descname">expression</code><a class="headerlink" href="#sqlalchemy.schema.Column.expression" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.expression" title="sqlalchemy.sql.expression.ColumnElement.expression"><code class="xref py py-attr docutils literal notranslate"><span class="pre">expression</span></code></a> <em>attribute of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Return a column expression.</p> <p>Part of the inspection interface; returns self.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.get_children"> <code class="descname">get_children</code><span class="sig-paren">(</span><em>schema_visitor=False</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.get_children" title="Permalink to this definition">¶</a></dt> <dd><p>used to allow SchemaVisitor access</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.ilike"> <code class="descname">ilike</code><span class="sig-paren">(</span><em>other</em>, <em>escape=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.ilike" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.ilike" title="sqlalchemy.sql.operators.ColumnOperators.ilike"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ilike()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">ilike</span></code> operator, e.g. case insensitive LIKE.</p> <p>In a column context, produces an expression either of the form:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">lower</span><span class="p">(</span><span class="n">a</span><span class="p">)</span> <span class="n">LIKE</span> <span class="n">lower</span><span class="p">(</span><span class="n">other</span><span class="p">)</span></pre></div> </div> <p>Or on backends that support the ILIKE operator:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="n">ILIKE</span> <span class="n">other</span></pre></div> </div> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">sometable</span><span class="p">])</span><span class="o">.</span>\ <span class="n">where</span><span class="p">(</span><span class="n">sometable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">column</span><span class="o">.</span><span class="n">ilike</span><span class="p">(</span><span class="s2">"</span><span class="si">%f</span><span class="s2">oobar%"</span><span class="p">))</span></pre></div> </div> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.ilike.params.other"></span><strong>other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.ilike.params.other">¶</a> – expression to be compared</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.ilike.params.escape"></span><strong>escape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.ilike.params.escape">¶</a> – <p>optional escape character, renders the <code class="docutils literal notranslate"><span class="pre">ESCAPE</span></code> keyword, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">ilike</span><span class="p">(</span><span class="s2">"foo/%bar"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"/"</span><span class="p">)</span></pre></div> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.like()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.in_"> <code class="descname">in_</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.in_" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.in_" title="sqlalchemy.sql.operators.ColumnOperators.in_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">in_()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">in</span></code> operator.</p> <p>In a column context, produces the clause <code class="docutils literal notranslate"><span class="pre">column</span> <span class="pre">IN</span> <span class="pre"><other></span></code>.</p> <p>The given parameter <code class="docutils literal notranslate"><span class="pre">other</span></code> may be:</p> <ul> <li><p>A list of literal values, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">column</span><span class="o">.</span><span class="n">in_</span><span class="p">([</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]))</span></pre></div> </div> <p>In this calling form, the list of items is converted to a set of bound parameters the same length as the list given:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>WHERE COL IN (?, ?, ?)</pre></div> </div> </li> <li><p>An empty list, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">column</span><span class="o">.</span><span class="n">in_</span><span class="p">([]))</span></pre></div> </div> <p>In this calling form, the expression renders a “false” expression, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">WHERE</span> <span class="mi">1</span> <span class="o">!=</span> <span class="mi">1</span></pre></div> </div> <p>This “false” expression has historically had different behaviors in older SQLAlchemy versions, see <a class="reference internal" href="engines.html#sqlalchemy.create_engine.params.empty_in_strategy" title="sqlalchemy.create_engine"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">create_engine.empty_in_strategy</span></code></a> for behavioral options.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.2: </span>simplified the behavior of “empty in” expressions</p> </div> </li> <li><p>A bound parameter, e.g. <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.bindparam" title="sqlalchemy.sql.expression.bindparam"><code class="xref py py-func docutils literal notranslate"><span class="pre">bindparam()</span></code></a>, may be used if it includes the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.bindparam.params.expanding" title="sqlalchemy.sql.expression.bindparam"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">bindparam.expanding</span></code></a> flag:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">column</span><span class="o">.</span><span class="n">in_</span><span class="p">(</span><span class="n">bindparam</span><span class="p">(</span><span class="s1">'value'</span><span class="p">,</span> <span class="n">expanding</span><span class="o">=</span><span class="kc">True</span><span class="p">)))</span></pre></div> </div> <p>In this calling form, the expression renders a special non-SQL placeholder expression that looks like:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">WHERE</span> <span class="n">COL</span> <span class="n">IN</span> <span class="p">([</span><span class="n">EXPANDING_value</span><span class="p">])</span></pre></div> </div> <p>This placeholder expression is intercepted at statement execution time to be converted into the variable number of bound parameter form illustrated earlier. If the statement were executed as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">connection</span><span class="o">.</span><span class="n">execute</span><span class="p">(</span><span class="n">stmt</span><span class="p">,</span> <span class="p">{</span><span class="s2">"value"</span><span class="p">:</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">]})</span></pre></div> </div> <p>The database would be passed a bound parameter for each value:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span>WHERE COL IN (?, ?, ?)</pre></div> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2: </span>added “expanding” bound parameters</p> </div> <p>The “expanding” feature in version 1.2 of SQLAlchemy does not support passing an empty list as a parameter value; however, version 1.3 does support this.</p> </li> <li><p>a <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a> construct, which is usually a correlated scalar select:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span><span class="o">.</span><span class="n">where</span><span class="p">(</span> <span class="n">column</span><span class="o">.</span><span class="n">in_</span><span class="p">(</span> <span class="n">select</span><span class="p">([</span><span class="n">othertable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">y</span><span class="p">])</span><span class="o">.</span> <span class="n">where</span><span class="p">(</span><span class="n">table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">x</span> <span class="o">==</span> <span class="n">othertable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">x</span><span class="p">)</span> <span class="p">)</span> <span class="p">)</span></pre></div> </div> <p>In this calling form, <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.in_" title="sqlalchemy.sql.operators.ColumnOperators.in_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.in_()</span></code></a> renders as given:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">WHERE</span> <span class="n">COL</span> <span class="n">IN</span> <span class="p">(</span><span class="n">SELECT</span> <span class="n">othertable</span><span class="o">.</span><span class="n">y</span> <span class="n">FROM</span> <span class="n">othertable</span> <span class="n">WHERE</span> <span class="n">othertable</span><span class="o">.</span><span class="n">x</span> <span class="o">=</span> <span class="n">table</span><span class="o">.</span><span class="n">x</span><span class="p">)</span></pre></div> </div> </li> </ul> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><p><span class="target" id="sqlalchemy.schema.Column.in_.params.other"></span><strong>other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.in_.params.other">¶</a> – a list of literals, a <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a> construct, or a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.bindparam" title="sqlalchemy.sql.expression.bindparam"><code class="xref py py-func docutils literal notranslate"><span class="pre">bindparam()</span></code></a> construct that includes the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.bindparam.params.expanding" title="sqlalchemy.sql.expression.bindparam"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">bindparam.expanding</span></code></a> flag set to True.</p> </dd> </dl> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Column.info"> <code class="descname">info</code><a class="headerlink" href="#sqlalchemy.schema.Column.info" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.info" title="sqlalchemy.schema.SchemaItem.info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">info</span></code></a> <em>attribute of</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a></p> </div> <p>Info dictionary associated with the object, allowing user-defined data to be associated with this <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a>.</p> <p>The dictionary is automatically generated when first accessed. It can also be specified in the constructor of some objects, such as <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> and <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.is_"> <code class="descname">is_</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.is_" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.is_" title="sqlalchemy.sql.operators.ColumnOperators.is_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">is_()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">IS</span></code> operator.</p> <p>Normally, <code class="docutils literal notranslate"><span class="pre">IS</span></code> is generated automatically when comparing to a value of <code class="docutils literal notranslate"><span class="pre">None</span></code>, which resolves to <code class="docutils literal notranslate"><span class="pre">NULL</span></code>. However, explicit usage of <code class="docutils literal notranslate"><span class="pre">IS</span></code> may be desirable if comparing to boolean values on certain platforms.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.isnot" title="sqlalchemy.sql.operators.ColumnOperators.isnot"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.isnot()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.is_distinct_from"> <code class="descname">is_distinct_from</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.is_distinct_from" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.is_distinct_from" title="sqlalchemy.sql.operators.ColumnOperators.is_distinct_from"><code class="xref py py-meth docutils literal notranslate"><span class="pre">is_distinct_from()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">IS</span> <span class="pre">DISTINCT</span> <span class="pre">FROM</span></code> operator.</p> <p>Renders “a IS DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS NOT b”.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.isnot"> <code class="descname">isnot</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.isnot" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.isnot" title="sqlalchemy.sql.operators.ColumnOperators.isnot"><code class="xref py py-meth docutils literal notranslate"><span class="pre">isnot()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">IS</span> <span class="pre">NOT</span></code> operator.</p> <p>Normally, <code class="docutils literal notranslate"><span class="pre">IS</span> <span class="pre">NOT</span></code> is generated automatically when comparing to a value of <code class="docutils literal notranslate"><span class="pre">None</span></code>, which resolves to <code class="docutils literal notranslate"><span class="pre">NULL</span></code>. However, explicit usage of <code class="docutils literal notranslate"><span class="pre">IS</span> <span class="pre">NOT</span></code> may be desirable if comparing to boolean values on certain platforms.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.is_" title="sqlalchemy.sql.operators.ColumnOperators.is_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.is_()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.isnot_distinct_from"> <code class="descname">isnot_distinct_from</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.isnot_distinct_from" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.isnot_distinct_from" title="sqlalchemy.sql.operators.ColumnOperators.isnot_distinct_from"><code class="xref py py-meth docutils literal notranslate"><span class="pre">isnot_distinct_from()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">IS</span> <span class="pre">NOT</span> <span class="pre">DISTINCT</span> <span class="pre">FROM</span></code> operator.</p> <p>Renders “a IS NOT DISTINCT FROM b” on most platforms; on some such as SQLite may render “a IS b”.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.label"> <code class="descname">label</code><span class="sig-paren">(</span><em>name</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.label" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.label" title="sqlalchemy.sql.expression.ColumnElement.label"><code class="xref py py-meth docutils literal notranslate"><span class="pre">label()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Produce a column label, i.e. <code class="docutils literal notranslate"><span class="pre"><columnname></span> <span class="pre">AS</span> <span class="pre"><name></span></code>.</p> <p>This is a shortcut to the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.label" title="sqlalchemy.sql.expression.label"><code class="xref py py-func docutils literal notranslate"><span class="pre">label()</span></code></a> function.</p> <p>if ‘name’ is None, an anonymous label name will be generated.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.like"> <code class="descname">like</code><span class="sig-paren">(</span><em>other</em>, <em>escape=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.like" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">like()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">like</span></code> operator.</p> <p>In a column context, produces the expression:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">a</span> <span class="n">LIKE</span> <span class="n">other</span></pre></div> </div> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">sometable</span><span class="p">])</span><span class="o">.</span>\ <span class="n">where</span><span class="p">(</span><span class="n">sometable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">column</span><span class="o">.</span><span class="n">like</span><span class="p">(</span><span class="s2">"</span><span class="si">%f</span><span class="s2">oobar%"</span><span class="p">))</span></pre></div> </div> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.like.params.other"></span><strong>other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.like.params.other">¶</a> – expression to be compared</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.like.params.escape"></span><strong>escape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.like.params.escape">¶</a> – <p>optional escape character, renders the <code class="docutils literal notranslate"><span class="pre">ESCAPE</span></code> keyword, e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">like</span><span class="p">(</span><span class="s2">"foo/%bar"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"/"</span><span class="p">)</span></pre></div> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.ilike" title="sqlalchemy.sql.operators.ColumnOperators.ilike"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.ilike()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.match"> <code class="descname">match</code><span class="sig-paren">(</span><em>other</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.match" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.match" title="sqlalchemy.sql.operators.ColumnOperators.match"><code class="xref py py-meth docutils literal notranslate"><span class="pre">match()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implements a database-specific ‘match’ operator.</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.match" title="sqlalchemy.sql.operators.ColumnOperators.match"><code class="xref py py-meth docutils literal notranslate"><span class="pre">match()</span></code></a> attempts to resolve to a MATCH-like function or operator provided by the backend. Examples include:</p> <ul class="simple"> <li><p>PostgreSQL - renders <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">@@</span> <span class="pre">to_tsquery(y)</span></code></p></li> <li><p>MySQL - renders <code class="docutils literal notranslate"><span class="pre">MATCH</span> <span class="pre">(x)</span> <span class="pre">AGAINST</span> <span class="pre">(y</span> <span class="pre">IN</span> <span class="pre">BOOLEAN</span> <span class="pre">MODE)</span></code></p></li> <li><p>Oracle - renders <code class="docutils literal notranslate"><span class="pre">CONTAINS(x,</span> <span class="pre">y)</span></code></p></li> <li><p>other backends may provide special implementations.</p></li> <li><p>Backends without any special implementation will emit the operator as “MATCH”. This is compatible with SQLite, for example.</p></li> </ul> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.notilike"> <code class="descname">notilike</code><span class="sig-paren">(</span><em>other</em>, <em>escape=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.notilike" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.notilike" title="sqlalchemy.sql.operators.ColumnOperators.notilike"><code class="xref py py-meth docutils literal notranslate"><span class="pre">notilike()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>implement the <code class="docutils literal notranslate"><span class="pre">NOT</span> <span class="pre">ILIKE</span></code> operator.</p> <p>This is equivalent to using negation with <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.ilike" title="sqlalchemy.sql.operators.ColumnOperators.ilike"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.ilike()</span></code></a>, i.e. <code class="docutils literal notranslate"><span class="pre">~x.ilike(y)</span></code>.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.ilike" title="sqlalchemy.sql.operators.ColumnOperators.ilike"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.ilike()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.notin_"> <code class="descname">notin_</code><span class="sig-paren">(</span><em>other</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.notin_" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.notin_" title="sqlalchemy.sql.operators.ColumnOperators.notin_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">notin_()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>implement the <code class="docutils literal notranslate"><span class="pre">NOT</span> <span class="pre">IN</span></code> operator.</p> <p>This is equivalent to using negation with <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.in_" title="sqlalchemy.sql.operators.ColumnOperators.in_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.in_()</span></code></a>, i.e. <code class="docutils literal notranslate"><span class="pre">~x.in_(y)</span></code>.</p> <p>In the case that <code class="docutils literal notranslate"><span class="pre">other</span></code> is an empty sequence, the compiler produces an “empty not in” expression. This defaults to the expression “1 = 1” to produce true in all cases. The <a class="reference internal" href="engines.html#sqlalchemy.create_engine.params.empty_in_strategy" title="sqlalchemy.create_engine"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">create_engine.empty_in_strategy</span></code></a> may be used to alter this behavior.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.2: </span>The <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.in_" title="sqlalchemy.sql.operators.ColumnOperators.in_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.in_()</span></code></a> and <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.notin_" title="sqlalchemy.sql.operators.ColumnOperators.notin_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.notin_()</span></code></a> operators now produce a “static” expression for an empty IN sequence by default.</p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.in_" title="sqlalchemy.sql.operators.ColumnOperators.in_"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.in_()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.notlike"> <code class="descname">notlike</code><span class="sig-paren">(</span><em>other</em>, <em>escape=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.notlike" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.notlike" title="sqlalchemy.sql.operators.ColumnOperators.notlike"><code class="xref py py-meth docutils literal notranslate"><span class="pre">notlike()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>implement the <code class="docutils literal notranslate"><span class="pre">NOT</span> <span class="pre">LIKE</span></code> operator.</p> <p>This is equivalent to using negation with <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.like()</span></code></a>, i.e. <code class="docutils literal notranslate"><span class="pre">~x.like(y)</span></code>.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.like()</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.nullsfirst"> <code class="descname">nullsfirst</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.nullsfirst" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.nullsfirst" title="sqlalchemy.sql.operators.ColumnOperators.nullsfirst"><code class="xref py py-meth docutils literal notranslate"><span class="pre">nullsfirst()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.nullsfirst" title="sqlalchemy.sql.expression.nullsfirst"><code class="xref py py-func docutils literal notranslate"><span class="pre">nullsfirst()</span></code></a> clause against the parent object.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.nullslast"> <code class="descname">nullslast</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.nullslast" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.nullslast" title="sqlalchemy.sql.operators.ColumnOperators.nullslast"><code class="xref py py-meth docutils literal notranslate"><span class="pre">nullslast()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Produce a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.nullslast" title="sqlalchemy.sql.expression.nullslast"><code class="xref py py-func docutils literal notranslate"><span class="pre">nullslast()</span></code></a> clause against the parent object.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.op"> <code class="descname">op</code><span class="sig-paren">(</span><em>opstring</em>, <em>precedence=0</em>, <em>is_comparison=False</em>, <em>return_type=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.op" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-meth docutils literal notranslate"><span class="pre">op()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators" title="sqlalchemy.sql.operators.Operators"><code class="xref py py-class docutils literal notranslate"><span class="pre">Operators</span></code></a></p> </div> <p>produce a generic operator function.</p> <p>e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">op</span><span class="p">(</span><span class="s2">"*"</span><span class="p">)(</span><span class="mi">5</span><span class="p">)</span></pre></div> </div> <p>produces:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="o">*</span> <span class="mi">5</span></pre></div> </div> <p>This function can also be used to make bitwise operators explicit. For example:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">op</span><span class="p">(</span><span class="s1">'&'</span><span class="p">)(</span><span class="mh">0xff</span><span class="p">)</span></pre></div> </div> <p>is a bitwise AND of the value in <code class="docutils literal notranslate"><span class="pre">somecolumn</span></code>.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.op.params.operator"></span><strong>operator</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.op.params.operator">¶</a> – a string which will be output as the infix operator between this element and the expression passed to the generated function.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.op.params.precedence"></span><strong>precedence</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.op.params.precedence">¶</a> – precedence to apply to the operator, when parenthesizing expressions. A lower number will cause the expression to be parenthesized when applied against another operator with higher precedence. The default value of <code class="docutils literal notranslate"><span class="pre">0</span></code> is lower than all operators except for the comma (<code class="docutils literal notranslate"><span class="pre">,</span></code>) and <code class="docutils literal notranslate"><span class="pre">AS</span></code> operators. A value of 100 will be higher or equal to all operators, and -100 will be lower than or equal to all operators.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.op.params.is_comparison"></span><strong>is_comparison</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.op.params.is_comparison">¶</a> – <p>if True, the operator will be considered as a “comparison” operator, that is which evaluates to a boolean true/false value, like <code class="docutils literal notranslate"><span class="pre">==</span></code>, <code class="docutils literal notranslate"><span class="pre">></span></code>, etc. This flag should be set so that ORM relationships can establish that the operator is a comparison operator when used in a custom join condition.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.2: </span>- added the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op.params.is_comparison" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Operators.op.is_comparison</span></code></a> flag.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.op.params.return_type"></span><strong>return_type</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.op.params.return_type">¶</a> – <p>a <a class="reference internal" href="type_api.html#sqlalchemy.types.TypeEngine" title="sqlalchemy.types.TypeEngine"><code class="xref py py-class docutils literal notranslate"><span class="pre">TypeEngine</span></code></a> class or object that will force the return type of an expression produced by this operator to be of that type. By default, operators that specify <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op.params.is_comparison" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Operators.op.is_comparison</span></code></a> will resolve to <a class="reference internal" href="type_basics.html#sqlalchemy.types.Boolean" title="sqlalchemy.types.Boolean"><code class="xref py py-class docutils literal notranslate"><span class="pre">Boolean</span></code></a>, and those that do not will be of the same type as the left-hand operand.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2.0b3: </span>- added the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.Operators.op.params.return_type" title="sqlalchemy.sql.operators.Operators.op"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Operators.op.return_type</span></code></a> argument.</p> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="custom_types.html#types-operators"><span class="std std-ref">Redefining and Creating New Operators</span></a></p> <p><a class="reference internal" href="../orm/join_conditions.html#relationship-custom-operator"><span class="std std-ref">Using custom operators in join conditions</span></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.operate"> <code class="descname">operate</code><span class="sig-paren">(</span><em>op</em>, <em>*other</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.operate" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.operate" title="sqlalchemy.sql.expression.ColumnElement.operate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">operate()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Operate on an argument.</p> <p>This is the lowest level of operation, raises <code class="xref py py-class docutils literal notranslate"><span class="pre">NotImplementedError</span></code> by default.</p> <p>Overriding this on a subclass can allow common behavior to be applied to all operations. For example, overriding <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a> to apply <code class="docutils literal notranslate"><span class="pre">func.lower()</span></code> to the left and right side:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">MyComparator</span><span class="p">(</span><span class="n">ColumnOperators</span><span class="p">):</span> <span class="k">def</span> <span class="nf">operate</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">op</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span> <span class="k">return</span> <span class="n">op</span><span class="p">(</span><span class="n">func</span><span class="o">.</span><span class="n">lower</span><span class="p">(</span><span class="bp">self</span><span class="p">),</span> <span class="n">func</span><span class="o">.</span><span class="n">lower</span><span class="p">(</span><span class="n">other</span><span class="p">))</span></pre></div> </div> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.operate.params.op"></span><strong>op</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.operate.params.op">¶</a> – Operator callable.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.operate.params.*other"></span><strong>*other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.operate.params.*other">¶</a> – the ‘other’ side of the operation. Will be a single scalar for most operations.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.operate.params.**kwargs"></span><strong>**kwargs</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.operate.params.**kwargs">¶</a> – modifiers. These may be passed by special operators such as <code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.contains()</span></code>.</p></li> </ul> </dd> </dl> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Column.quote"> <code class="descname">quote</code><a class="headerlink" href="#sqlalchemy.schema.Column.quote" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.quote" title="sqlalchemy.schema.SchemaItem.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">quote</span></code></a> <em>attribute of</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a></p> </div> <p>Return the value of the <code class="docutils literal notranslate"><span class="pre">quote</span></code> flag passed to this schema object, for those schema items which have a <code class="docutils literal notranslate"><span class="pre">name</span></code> field.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.9: </span>The <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.quote" title="sqlalchemy.schema.SchemaItem.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">SchemaItem.quote</span></code></a> attribute is deprecated and will be removed in a future release. Use the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.elements.quoted_name.quote" title="sqlalchemy.sql.elements.quoted_name.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">quoted_name.quote</span></code></a> attribute on the <code class="docutils literal notranslate"><span class="pre">name</span></code> field of the target schema item to retrievequoted status.</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.references"> <code class="descname">references</code><span class="sig-paren">(</span><em>column</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.references" title="Permalink to this definition">¶</a></dt> <dd><p>Return True if this Column references the given column via foreign key.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.reverse_operate"> <code class="descname">reverse_operate</code><span class="sig-paren">(</span><em>op</em>, <em>other</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.reverse_operate" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.reverse_operate" title="sqlalchemy.sql.expression.ColumnElement.reverse_operate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">reverse_operate()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Reverse operate on an argument.</p> <p>Usage is the same as <a class="reference internal" href="#sqlalchemy.schema.Column.operate" title="sqlalchemy.schema.Column.operate"><code class="xref py py-meth docutils literal notranslate"><span class="pre">operate()</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.self_group"> <code class="descname">self_group</code><span class="sig-paren">(</span><em>against=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.self_group" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.self_group" title="sqlalchemy.sql.expression.ColumnElement.self_group"><code class="xref py py-meth docutils literal notranslate"><span class="pre">self_group()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Apply a ‘grouping’ to this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a>.</p> <p>This method is overridden by subclasses to return a “grouping” construct, i.e. parenthesis. In particular it’s used by “binary” expressions to provide a grouping around themselves when placed into a larger expression, as well as by <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a> constructs when placed into the FROM clause of another <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a>. (Note that subqueries should be normally created using the <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Select.alias" title="sqlalchemy.sql.expression.Select.alias"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Select.alias()</span></code></a> method, as many platforms require nested SELECT statements to be named).</p> <p>As expressions are composed together, the application of <a class="reference internal" href="#sqlalchemy.schema.Column.self_group" title="sqlalchemy.schema.Column.self_group"><code class="xref py py-meth docutils literal notranslate"><span class="pre">self_group()</span></code></a> is automatic - end-user code should never need to use this method directly. Note that SQLAlchemy’s clause constructs take operator precedence into account - so parenthesis might not be needed, for example, in an expression like <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">OR</span> <span class="pre">(y</span> <span class="pre">AND</span> <span class="pre">z)</span></code> - AND takes precedence over OR.</p> <p>The base <a class="reference internal" href="#sqlalchemy.schema.Column.self_group" title="sqlalchemy.schema.Column.self_group"><code class="xref py py-meth docutils literal notranslate"><span class="pre">self_group()</span></code></a> method of <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a> just returns self.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.shares_lineage"> <code class="descname">shares_lineage</code><span class="sig-paren">(</span><em>othercolumn</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.shares_lineage" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement.shares_lineage" title="sqlalchemy.sql.expression.ColumnElement.shares_lineage"><code class="xref py py-meth docutils literal notranslate"><span class="pre">shares_lineage()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a></p> </div> <p>Return True if the given <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a> has a common ancestor to this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Column.startswith"> <code class="descname">startswith</code><span class="sig-paren">(</span><em>other</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Column.startswith" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-meth docutils literal notranslate"><span class="pre">startswith()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators" title="sqlalchemy.sql.operators.ColumnOperators"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnOperators</span></code></a></p> </div> <p>Implement the <code class="docutils literal notranslate"><span class="pre">startswith</span></code> operator.</p> <p>Produces a LIKE expression that tests against a match for the start of a string value:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">column</span> <span class="n">LIKE</span> <span class="o"><</span><span class="n">other</span><span class="o">></span> <span class="o">||</span> <span class="s1">'%'</span></pre></div> </div> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">stmt</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">sometable</span><span class="p">])</span><span class="o">.</span>\ <span class="n">where</span><span class="p">(</span><span class="n">sometable</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">column</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"foobar"</span><span class="p">))</span></pre></div> </div> <p>Since the operator uses <code class="docutils literal notranslate"><span class="pre">LIKE</span></code>, wildcard characters <code class="docutils literal notranslate"><span class="pre">"%"</span></code> and <code class="docutils literal notranslate"><span class="pre">"_"</span></code> that are present inside the <other> expression will behave like wildcards as well. For literal string values, the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.startswith.autoescape</span></code></a> flag may be set to <code class="docutils literal notranslate"><span class="pre">True</span></code> to apply escaping to occurrences of these characters within the string value so that they match as themselves and not as wildcard characters. Alternatively, the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith.params.escape" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.startswith.escape</span></code></a> parameter will establish a given character as an escape character which can be of use when the target expression is not a literal string.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Column.startswith.params.other"></span><strong>other</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.startswith.params.other">¶</a> – expression to be compared. This is usually a plain string value, but can also be an arbitrary SQL expression. LIKE wildcard characters <code class="docutils literal notranslate"><span class="pre">%</span></code> and <code class="docutils literal notranslate"><span class="pre">_</span></code> are not escaped by default unless the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.startswith.autoescape</span></code></a> flag is set to True.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.startswith.params.autoescape"></span><strong>autoescape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.startswith.params.autoescape">¶</a> – <p>boolean; when True, establishes an escape character within the LIKE expression, then applies it to all occurrences of <code class="docutils literal notranslate"><span class="pre">"%"</span></code>, <code class="docutils literal notranslate"><span class="pre">"_"</span></code> and the escape character itself within the comparison value, which is assumed to be a literal string and not a SQL expression.</p> <p>An expression such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"foo%bar"</span><span class="p">,</span> <span class="n">autoescape</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <p>Will render as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="n">LIKE</span> <span class="p">:</span><span class="n">param</span> <span class="o">||</span> <span class="s1">'%'</span> <span class="n">ESCAPE</span> <span class="s1">'/'</span></pre></div> </div> <p>With the value of :param as <code class="docutils literal notranslate"><span class="pre">"foo/%bar"</span></code>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2.</span></p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.2.0: </span>The <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.startswith.autoescape</span></code></a> parameter is now a simple boolean rather than a character; the escape character itself is also escaped, and defaults to a forwards slash, which itself can be customized using the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith.params.escape" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.startswith.escape</span></code></a> parameter.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Column.startswith.params.escape"></span><strong>escape</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Column.startswith.params.escape">¶</a> – <p>a character which when given will render with the <code class="docutils literal notranslate"><span class="pre">ESCAPE</span></code> keyword to establish that character as the escape character. This character can then be placed preceding occurrences of <code class="docutils literal notranslate"><span class="pre">%</span></code> and <code class="docutils literal notranslate"><span class="pre">_</span></code> to allow them to act as themselves and not wildcard characters.</p> <p>An expression such as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"foo/%bar"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"^"</span><span class="p">)</span></pre></div> </div> <p>Will render as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span> <span class="n">LIKE</span> <span class="p">:</span><span class="n">param</span> <span class="o">||</span> <span class="s1">'%'</span> <span class="n">ESCAPE</span> <span class="s1">'^'</span></pre></div> </div> <p>The parameter may also be combined with <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.startswith.params.autoescape" title="sqlalchemy.sql.operators.ColumnOperators.startswith"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ColumnOperators.startswith.autoescape</span></code></a>:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">somecolumn</span><span class="o">.</span><span class="n">startswith</span><span class="p">(</span><span class="s2">"foo%bar^bat"</span><span class="p">,</span> <span class="n">escape</span><span class="o">=</span><span class="s2">"^"</span><span class="p">,</span> <span class="n">autoescape</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <p>Where above, the given literal parameter will be converted to <code class="docutils literal notranslate"><span class="pre">"foo^%bar^^bat"</span></code> before being passed to the database.</p> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.endswith" title="sqlalchemy.sql.operators.ColumnOperators.endswith"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.endswith()</span></code></a></p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.contains" title="sqlalchemy.sql.operators.ColumnOperators.contains"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.contains()</span></code></a></p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.operators.ColumnOperators.like" title="sqlalchemy.sql.operators.ColumnOperators.like"><code class="xref py py-meth docutils literal notranslate"><span class="pre">ColumnOperators.like()</span></code></a></p> </div> </dd></dl> </dd></dl> <dl class="class"> <dt id="sqlalchemy.schema.MetaData"> <em class="property">class </em><code class="descclassname">sqlalchemy.schema.</code><code class="descname">MetaData</code><span class="sig-paren">(</span><em>bind=None</em>, <em>reflect=False</em>, <em>schema=None</em>, <em>quote_schema=None</em>, <em>naming_convention={'ix': 'ix_%(column_0_label)s'}</em>, <em>info=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.schema.SchemaItem</span></code></a></p> <p>A collection of <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects and their associated schema constructs.</p> <p>Holds a collection of <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects as well as an optional binding to an <a class="reference internal" href="connections.html#sqlalchemy.engine.Engine" title="sqlalchemy.engine.Engine"><code class="xref py py-class docutils literal notranslate"><span class="pre">Engine</span></code></a> or <a class="reference internal" href="connections.html#sqlalchemy.engine.Connection" title="sqlalchemy.engine.Connection"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connection</span></code></a>. If bound, the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects in the collection and their columns may participate in implicit SQL execution.</p> <p>The <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects themselves are stored in the <a class="reference internal" href="#sqlalchemy.schema.MetaData.tables" title="sqlalchemy.schema.MetaData.tables"><code class="xref py py-attr docutils literal notranslate"><span class="pre">MetaData.tables</span></code></a> dictionary.</p> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> is a thread-safe object for read operations. Construction of new tables within a single <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object, either explicitly or via reflection, may not be completely thread-safe.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#metadata-describing"><span class="std std-ref">Describing Databases with MetaData</span></a> - Introduction to database metadata</p> </div> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>bind=None</em>, <em>reflect=False</em>, <em>schema=None</em>, <em>quote_schema=None</em>, <em>naming_convention={'ix': 'ix_%(column_0_label)s'}</em>, <em>info=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Create a new MetaData object.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.MetaData.params.bind"></span><strong>bind</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.params.bind">¶</a> – An Engine or Connection to bind to. May also be a string or URL instance, these are passed to create_engine() and this MetaData will be bound to the resulting engine.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.params.reflect"></span><strong>reflect</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.params.reflect">¶</a> – <p>Optional, automatically load all tables from the bound database. Defaults to False. <code class="docutils literal notranslate"><span class="pre">bind</span></code> is required when this option is set.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.8: </span>The <a class="reference internal" href="#sqlalchemy.schema.MetaData.params.reflect" title="sqlalchemy.schema.MetaData"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">MetaData.reflect</span></code></a> flag is deprecated and will be removed in a future release. Please use the <a class="reference internal" href="#sqlalchemy.schema.MetaData.reflect" title="sqlalchemy.schema.MetaData.reflect"><code class="xref py py-meth docutils literal notranslate"><span class="pre">MetaData.reflect()</span></code></a> method.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.params.schema"></span><strong>schema</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.params.schema">¶</a> – <p>The default schema to use for the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, <a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><code class="xref py py-class docutils literal notranslate"><span class="pre">Sequence</span></code></a>, and potentially other objects associated with this <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>. Defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p> <p>When this value is set, any <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> or <a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><code class="xref py py-class docutils literal notranslate"><span class="pre">Sequence</span></code></a> which specifies <code class="docutils literal notranslate"><span class="pre">None</span></code> for the schema parameter will instead have this schema name defined. To build a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> or <a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><code class="xref py py-class docutils literal notranslate"><span class="pre">Sequence</span></code></a> that still has <code class="docutils literal notranslate"><span class="pre">None</span></code> for the schema even when this parameter is present, use the <a class="reference internal" href="#sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA" title="sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA"><code class="xref py py-attr docutils literal notranslate"><span class="pre">BLANK_SCHEMA</span></code></a> symbol.</p> <div class="admonition note"> <p class="admonition-title">Note</p> <p>As refered above, the <a class="reference internal" href="#sqlalchemy.schema.MetaData.params.schema" title="sqlalchemy.schema.MetaData"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">MetaData.schema</span></code></a> parameter only refers to the <strong>default value</strong> that will be applied to the <a class="reference internal" href="#sqlalchemy.schema.Table.params.schema" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.schema</span></code></a> parameter of an incoming <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object. It does not refer to how the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> is catalogued within the <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>, which remains consistent vs. a <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection that does not define this parameter. The <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> within the <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> will still be keyed based on its schema-qualified name, e.g. <code class="docutils literal notranslate"><span class="pre">my_metadata.tables["some_schema.my_table"]</span></code>.</p> <p>The current behavior of the <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a> object is to circumvent this restriction, where it can locate a table given the table name alone, where the schema will be assumed to be present from this value as specified on the owning <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection. However, this implies that a table qualified with BLANK_SCHEMA cannot currently be referred to by string name from <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a>. Other parts of SQLAlchemy such as Declarative may not have similar behaviors built in, however may do so in a future release, along with a consistent method of referring to a table in BLANK_SCHEMA.</p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.schema" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.schema</span></code></a></p> <p><a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence.params.schema" title="sqlalchemy.schema.Sequence"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Sequence.schema</span></code></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.params.quote_schema"></span><strong>quote_schema</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.params.quote_schema">¶</a> – Sets the <code class="docutils literal notranslate"><span class="pre">quote_schema</span></code> flag for those <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, <a class="reference internal" href="defaults.html#sqlalchemy.schema.Sequence" title="sqlalchemy.schema.Sequence"><code class="xref py py-class docutils literal notranslate"><span class="pre">Sequence</span></code></a>, and other objects which make usage of the local <code class="docutils literal notranslate"><span class="pre">schema</span></code> name.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.params.info"></span><strong>info</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.params.info">¶</a> – <p>Optional data dictionary which will be populated into the <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.info" title="sqlalchemy.schema.SchemaItem.info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">SchemaItem.info</span></code></a> attribute of this object.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.0.0.</span></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.params.naming_convention"></span><strong>naming_convention</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.params.naming_convention">¶</a> – <p>a dictionary referring to values which will establish default naming conventions for <a class="reference internal" href="constraints.html#sqlalchemy.schema.Constraint" title="sqlalchemy.schema.Constraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constraint</span></code></a> and <a class="reference internal" href="constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><code class="xref py py-class docutils literal notranslate"><span class="pre">Index</span></code></a> objects, for those objects which are not given a name explicitly.</p> <p>The keys of this dictionary may be:</p> <ul> <li><p>a constraint or Index class, e.g. the <a class="reference internal" href="constraints.html#sqlalchemy.schema.UniqueConstraint" title="sqlalchemy.schema.UniqueConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">UniqueConstraint</span></code></a>, <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a> class, the <a class="reference internal" href="constraints.html#sqlalchemy.schema.Index" title="sqlalchemy.schema.Index"><code class="xref py py-class docutils literal notranslate"><span class="pre">Index</span></code></a> class</p></li> <li><p>a string mnemonic for one of the known constraint classes; <code class="docutils literal notranslate"><span class="pre">"fk"</span></code>, <code class="docutils literal notranslate"><span class="pre">"pk"</span></code>, <code class="docutils literal notranslate"><span class="pre">"ix"</span></code>, <code class="docutils literal notranslate"><span class="pre">"ck"</span></code>, <code class="docutils literal notranslate"><span class="pre">"uq"</span></code> for foreign key, primary key, index, check, and unique constraint, respectively.</p></li> <li><p>the string name of a user-defined “token” that can be used to define new naming tokens.</p></li> </ul> <p>The values associated with each “constraint class” or “constraint mnemonic” key are string naming templates, such as <code class="docutils literal notranslate"><span class="pre">"uq_%(table_name)s_%(column_0_name)s"</span></code>, which describe how the name should be composed. The values associated with user-defined “token” keys should be callables of the form <code class="docutils literal notranslate"><span class="pre">fn(constraint,</span> <span class="pre">table)</span></code>, which accepts the constraint/index object and <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> as arguments, returning a string result.</p> <p>The built-in names are as follows, some of which may only be available for certain types of constraint:</p> <blockquote> <div><ul> <li><p><code class="docutils literal notranslate"><span class="pre">%(table_name)s</span></code> - the name of the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object associated with the constraint.</p></li> <li><p><code class="docutils literal notranslate"><span class="pre">%(referred_table_name)s</span></code> - the name of the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object associated with the referencing target of a <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a>.</p></li> <li><p><code class="docutils literal notranslate"><span class="pre">%(column_0_name)s</span></code> - the name of the <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> at index position “0” within the constraint.</p></li> <li><p><code class="docutils literal notranslate"><span class="pre">%(column_0_label)s</span></code> - the label of the <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> at index position “0”, e.g. <code class="xref py py-attr docutils literal notranslate"><span class="pre">Column.label</span></code></p></li> <li><p><code class="docutils literal notranslate"><span class="pre">%(column_0_key)s</span></code> - the key of the <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> at index position “0”, e.g. <code class="xref py py-attr docutils literal notranslate"><span class="pre">Column.key</span></code></p></li> <li><p><code class="docutils literal notranslate"><span class="pre">%(referred_column_0_name)s</span></code> - the name of a <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> at index position “0” referenced by a <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a>.</p></li> <li><p><code class="docutils literal notranslate"><span class="pre">%(constraint_name)s</span></code> - a special key that refers to the existing name given to the constraint. When this key is present, the <a class="reference internal" href="constraints.html#sqlalchemy.schema.Constraint" title="sqlalchemy.schema.Constraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constraint</span></code></a> object’s existing name will be replaced with one that is composed from template string that uses this token. When this token is present, it is required that the <a class="reference internal" href="constraints.html#sqlalchemy.schema.Constraint" title="sqlalchemy.schema.Constraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constraint</span></code></a> is given an explicit name ahead of time.</p></li> <li><p>user-defined: any additional token may be implemented by passing it along with a <code class="docutils literal notranslate"><span class="pre">fn(constraint,</span> <span class="pre">table)</span></code> callable to the naming_convention dictionary.</p></li> </ul> </div></blockquote> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.2.</span></p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="constraints.html#constraint-naming-conventions"><span class="std std-ref">Configuring Constraint Naming Conventions</span></a> - for detailed usage examples.</p> </div> </p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.append_ddl_listener"> <code class="descname">append_ddl_listener</code><span class="sig-paren">(</span><em>event_name</em>, <em>listener</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.append_ddl_listener" title="Permalink to this definition">¶</a></dt> <dd><p>Append a DDL event listener to this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code>.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.7: </span>See <a class="reference internal" href="events.html#sqlalchemy.events.DDLEvents" title="sqlalchemy.events.DDLEvents"><code class="xref py py-class docutils literal notranslate"><span class="pre">DDLEvents</span></code></a>.</p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.MetaData.bind"> <code class="descname">bind</code><a class="headerlink" href="#sqlalchemy.schema.MetaData.bind" title="Permalink to this definition">¶</a></dt> <dd><p>An <a class="reference internal" href="connections.html#sqlalchemy.engine.Engine" title="sqlalchemy.engine.Engine"><code class="xref py py-class docutils literal notranslate"><span class="pre">Engine</span></code></a> or <a class="reference internal" href="connections.html#sqlalchemy.engine.Connection" title="sqlalchemy.engine.Connection"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connection</span></code></a> to which this <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> is bound.</p> <p>Typically, a <a class="reference internal" href="connections.html#sqlalchemy.engine.Engine" title="sqlalchemy.engine.Engine"><code class="xref py py-class docutils literal notranslate"><span class="pre">Engine</span></code></a> is assigned to this attribute so that “implicit execution” may be used, or alternatively as a means of providing engine binding information to an ORM <a class="reference internal" href="../orm/session_api.html#sqlalchemy.orm.session.Session" title="sqlalchemy.orm.session.Session"><code class="xref py py-class docutils literal notranslate"><span class="pre">Session</span></code></a> object:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">engine</span> <span class="o">=</span> <span class="n">create_engine</span><span class="p">(</span><span class="s2">"someurl://"</span><span class="p">)</span> <span class="n">metadata</span><span class="o">.</span><span class="n">bind</span> <span class="o">=</span> <span class="n">engine</span></pre></div> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="connections.html#dbengine-implicit"><span class="std std-ref">Connectionless Execution, Implicit Execution</span></a> - background on “bound metadata”</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.clear"> <code class="descname">clear</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.clear" title="Permalink to this definition">¶</a></dt> <dd><p>Clear all Table objects from this MetaData.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.create_all"> <code class="descname">create_all</code><span class="sig-paren">(</span><em>bind=None</em>, <em>tables=None</em>, <em>checkfirst=True</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.create_all" title="Permalink to this definition">¶</a></dt> <dd><p>Create all tables stored in this metadata.</p> <p>Conditional by default, will not attempt to recreate tables already present in the target database.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.MetaData.create_all.params.bind"></span><strong>bind</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.create_all.params.bind">¶</a> – A <a class="reference internal" href="connections.html#sqlalchemy.engine.Connectable" title="sqlalchemy.engine.Connectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connectable</span></code></a> used to access the database; if None, uses the existing bind on this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code>, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.create_all.params.tables"></span><strong>tables</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.create_all.params.tables">¶</a> – Optional list of <code class="docutils literal notranslate"><span class="pre">Table</span></code> objects, which is a subset of the total tables in the <code class="docutils literal notranslate"><span class="pre">MetaData</span></code> (others are ignored).</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.create_all.params.checkfirst"></span><strong>checkfirst</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.create_all.params.checkfirst">¶</a> – Defaults to True, don’t issue CREATEs for tables already present in the target database.</p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.drop_all"> <code class="descname">drop_all</code><span class="sig-paren">(</span><em>bind=None</em>, <em>tables=None</em>, <em>checkfirst=True</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.drop_all" title="Permalink to this definition">¶</a></dt> <dd><p>Drop all tables stored in this metadata.</p> <p>Conditional by default, will not attempt to drop tables not present in the target database.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.MetaData.drop_all.params.bind"></span><strong>bind</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.drop_all.params.bind">¶</a> – A <a class="reference internal" href="connections.html#sqlalchemy.engine.Connectable" title="sqlalchemy.engine.Connectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connectable</span></code></a> used to access the database; if None, uses the existing bind on this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code>, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.drop_all.params.tables"></span><strong>tables</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.drop_all.params.tables">¶</a> – Optional list of <code class="docutils literal notranslate"><span class="pre">Table</span></code> objects, which is a subset of the total tables in the <code class="docutils literal notranslate"><span class="pre">MetaData</span></code> (others are ignored).</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.drop_all.params.checkfirst"></span><strong>checkfirst</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.drop_all.params.checkfirst">¶</a> – Defaults to True, only issue DROPs for tables confirmed to be present in the target database.</p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.is_bound"> <code class="descname">is_bound</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.is_bound" title="Permalink to this definition">¶</a></dt> <dd><p>True if this MetaData is bound to an Engine or Connection.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.reflect"> <code class="descname">reflect</code><span class="sig-paren">(</span><em>bind=None</em>, <em>schema=None</em>, <em>views=False</em>, <em>only=None</em>, <em>extend_existing=False</em>, <em>autoload_replace=True</em>, <em>**dialect_kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.reflect" title="Permalink to this definition">¶</a></dt> <dd><p>Load all available table definitions from the database.</p> <p>Automatically creates <code class="docutils literal notranslate"><span class="pre">Table</span></code> entries in this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code> for any table available in the database but not yet present in the <code class="docutils literal notranslate"><span class="pre">MetaData</span></code>. May be called multiple times to pick up tables recently added to the database, however no special action is taken if a table in this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code> no longer exists in the database.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.bind"></span><strong>bind</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.bind">¶</a> – A <a class="reference internal" href="connections.html#sqlalchemy.engine.Connectable" title="sqlalchemy.engine.Connectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connectable</span></code></a> used to access the database; if None, uses the existing bind on this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code>, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.schema"></span><strong>schema</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.schema">¶</a> – Optional, query and reflect tables from an alternate schema. If None, the schema associated with this <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> is used, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.views"></span><strong>views</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.views">¶</a> – If True, also reflect views.</p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.only"></span><strong>only</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.only">¶</a> – <p>Optional. Load only a sub-set of available named tables. May be specified as a sequence of names or a callable.</p> <p>If a sequence of names is provided, only those tables will be reflected. An error is raised if a table is requested but not available. Named tables already present in this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code> are ignored.</p> <p>If a callable is provided, it will be used as a boolean predicate to filter the list of potential table names. The callable is called with a table name and this <code class="docutils literal notranslate"><span class="pre">MetaData</span></code> instance as positional arguments and should return a true value for any table to reflect.</p> </p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.extend_existing"></span><strong>extend_existing</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.extend_existing">¶</a> – <p>Passed along to each <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> as <a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.1.</span></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.autoload_replace"></span><strong>autoload_replace</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.autoload_replace">¶</a> – <p>Passed along to each <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> as <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload_replace" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload_replace</span></code></a>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.1.</span></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.MetaData.reflect.params.**dialect_kwargs"></span><strong>**dialect_kwargs</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.**dialect_kwargs">¶</a> – <p>Additional keyword arguments not mentioned above are dialect specific, and passed in the form <code class="docutils literal notranslate"><span class="pre"><dialectname>_<argname></span></code>. See the documentation regarding an individual dialect at <a class="reference internal" href="../dialects/index.html"><span class="std std-ref">Dialects</span></a> for detail on documented arguments.</p> <blockquote> <div><div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.2: </span>- Added <a class="reference internal" href="#sqlalchemy.schema.MetaData.reflect.params.**dialect_kwargs" title="sqlalchemy.schema.MetaData.reflect"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">MetaData.reflect.**dialect_kwargs</span></code></a> to support dialect-level reflection options for all <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects reflected.</p> </div> </div></blockquote> </p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.MetaData.remove"> <code class="descname">remove</code><span class="sig-paren">(</span><em>table</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.MetaData.remove" title="Permalink to this definition">¶</a></dt> <dd><p>Remove the given Table object from this MetaData.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.MetaData.sorted_tables"> <code class="descname">sorted_tables</code><a class="headerlink" href="#sqlalchemy.schema.MetaData.sorted_tables" title="Permalink to this definition">¶</a></dt> <dd><p>Returns a list of <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects sorted in order of foreign key dependency.</p> <p>The sorting will place <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects that have dependencies first, before the dependencies themselves, representing the order in which they can be created. To get the order in which the tables would be dropped, use the <code class="docutils literal notranslate"><span class="pre">reversed()</span></code> Python built-in.</p> <div class="admonition warning"> <p class="admonition-title">Warning</p> <p>The <a class="reference internal" href="#sqlalchemy.schema.MetaData.sorted_tables" title="sqlalchemy.schema.MetaData.sorted_tables"><code class="xref py py-attr docutils literal notranslate"><span class="pre">sorted_tables</span></code></a> accessor cannot by itself accommodate automatic resolution of dependency cycles between tables, which are usually caused by mutually dependent foreign key constraints. To resolve these cycles, either the <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint.params.use_alter" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">ForeignKeyConstraint.use_alter</span></code></a> parameter may be applied to those constraints, or use the <a class="reference internal" href="ddl.html#sqlalchemy.schema.sort_tables_and_constraints" title="sqlalchemy.schema.sort_tables_and_constraints"><code class="xref py py-func docutils literal notranslate"><span class="pre">schema.sort_tables_and_constraints()</span></code></a> function which will break out foreign key constraints involved in cycles separately.</p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="ddl.html#sqlalchemy.schema.sort_tables" title="sqlalchemy.schema.sort_tables"><code class="xref py py-func docutils literal notranslate"><span class="pre">schema.sort_tables()</span></code></a></p> <p><a class="reference internal" href="ddl.html#sqlalchemy.schema.sort_tables_and_constraints" title="sqlalchemy.schema.sort_tables_and_constraints"><code class="xref py py-func docutils literal notranslate"><span class="pre">schema.sort_tables_and_constraints()</span></code></a></p> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData.tables" title="sqlalchemy.schema.MetaData.tables"><code class="xref py py-attr docutils literal notranslate"><span class="pre">MetaData.tables</span></code></a></p> <p><a class="reference internal" href="reflection.html#sqlalchemy.engine.reflection.Inspector.get_table_names" title="sqlalchemy.engine.reflection.Inspector.get_table_names"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Inspector.get_table_names()</span></code></a></p> <p><a class="reference internal" href="reflection.html#sqlalchemy.engine.reflection.Inspector.get_sorted_table_and_fkc_names" title="sqlalchemy.engine.reflection.Inspector.get_sorted_table_and_fkc_names"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Inspector.get_sorted_table_and_fkc_names()</span></code></a></p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.MetaData.tables"> <code class="descname">tables</code><em class="property"> = None</em><a class="headerlink" href="#sqlalchemy.schema.MetaData.tables" title="Permalink to this definition">¶</a></dt> <dd><p>A dictionary of <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> objects keyed to their name or “table key”.</p> <p>The exact key is that determined by the <a class="reference internal" href="#sqlalchemy.schema.Table.key" title="sqlalchemy.schema.Table.key"><code class="xref py py-attr docutils literal notranslate"><span class="pre">Table.key</span></code></a> attribute; for a table with no <code class="xref py py-attr docutils literal notranslate"><span class="pre">Table.schema</span></code> attribute, this is the same as <code class="xref py py-attr docutils literal notranslate"><span class="pre">Table.name</span></code>. For a table with a schema, it is typically of the form <code class="docutils literal notranslate"><span class="pre">schemaname.tablename</span></code>.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData.sorted_tables" title="sqlalchemy.schema.MetaData.sorted_tables"><code class="xref py py-attr docutils literal notranslate"><span class="pre">MetaData.sorted_tables</span></code></a></p> </div> </dd></dl> </dd></dl> <dl class="class"> <dt id="sqlalchemy.schema.SchemaItem"> <em class="property">class </em><code class="descclassname">sqlalchemy.schema.</code><code class="descname">SchemaItem</code><a class="headerlink" href="#sqlalchemy.schema.SchemaItem" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.sql.expression.SchemaEventTarget</span></code>, <code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.sql.visitors.Visitable</span></code></p> <p>Base class for items that define a database schema.</p> <dl class="method"> <dt id="sqlalchemy.schema.SchemaItem.get_children"> <code class="descname">get_children</code><span class="sig-paren">(</span><em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.SchemaItem.get_children" title="Permalink to this definition">¶</a></dt> <dd><p>used to allow SchemaVisitor access</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.SchemaItem.info"> <code class="descname">info</code><a class="headerlink" href="#sqlalchemy.schema.SchemaItem.info" title="Permalink to this definition">¶</a></dt> <dd><p>Info dictionary associated with the object, allowing user-defined data to be associated with this <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a>.</p> <p>The dictionary is automatically generated when first accessed. It can also be specified in the constructor of some objects, such as <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> and <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a>.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.SchemaItem.quote"> <code class="descname">quote</code><a class="headerlink" href="#sqlalchemy.schema.SchemaItem.quote" title="Permalink to this definition">¶</a></dt> <dd><p>Return the value of the <code class="docutils literal notranslate"><span class="pre">quote</span></code> flag passed to this schema object, for those schema items which have a <code class="docutils literal notranslate"><span class="pre">name</span></code> field.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.9: </span>The <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.quote" title="sqlalchemy.schema.SchemaItem.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">SchemaItem.quote</span></code></a> attribute is deprecated and will be removed in a future release. Use the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.elements.quoted_name.quote" title="sqlalchemy.sql.elements.quoted_name.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">quoted_name.quote</span></code></a> attribute on the <code class="docutils literal notranslate"><span class="pre">name</span></code> field of the target schema item to retrievequoted status.</p> </div> </dd></dl> </dd></dl> <dl class="class"> <dt id="sqlalchemy.schema.Table"> <em class="property">class </em><code class="descclassname">sqlalchemy.schema.</code><code class="descname">Table</code><span class="sig-paren">(</span><em>*args</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs" title="sqlalchemy.sql.base.DialectKWArgs"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.sql.base.DialectKWArgs</span></code></a>, <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.schema.SchemaItem</span></code></a>, <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.sql.expression.TableClause</span></code></a></p> <p>Represent a table in a database.</p> <p>e.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">mytable</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s2">"mytable"</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'mytable_id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">),</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'value'</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">))</span> <span class="p">)</span></pre></div> </div> <p>The <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object constructs a unique instance of itself based on its name and optional schema name within the given <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object. Calling the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> constructor with the same name and same <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> argument a second time will return the <em>same</em> <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object - in this way the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> constructor acts as a registry function.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#metadata-describing"><span class="std std-ref">Describing Databases with MetaData</span></a> - Introduction to database metadata</p> </div> <p>Constructor arguments are as follows:</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.params.name"></span><strong>name</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.name">¶</a> – <p>The name of this table as represented in the database.</p> <p>The table name, along with the value of the <code class="docutils literal notranslate"><span class="pre">schema</span></code> parameter, forms a key which uniquely identifies this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> within the owning <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection. Additional calls to <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> with the same name, metadata, and schema name will return the same <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object.</p> <p>Names which contain no upper case characters will be treated as case insensitive names, and will not be quoted unless they are a reserved word or contain special characters. A name with any number of upper case characters is considered to be case sensitive, and will be sent as quoted.</p> <p>To enable unconditional quoting for the table name, specify the flag <code class="docutils literal notranslate"><span class="pre">quote=True</span></code> to the constructor, or use the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.elements.quoted_name" title="sqlalchemy.sql.elements.quoted_name"><code class="xref py py-class docutils literal notranslate"><span class="pre">quoted_name</span></code></a> construct to specify the name.</p> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.metadata"></span><strong>metadata</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.metadata">¶</a> – a <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object which will contain this table. The metadata is used as a point of association of this table with other tables which are referenced via foreign key. It also may be used to associate this table with a particular <a class="reference internal" href="connections.html#sqlalchemy.engine.Connectable" title="sqlalchemy.engine.Connectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connectable</span></code></a>.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.*args"></span><strong>*args</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.*args">¶</a> – Additional positional arguments are used primarily to add the list of <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects contained within this table. Similar to the style of a CREATE TABLE statement, other <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a> constructs may be added here, including <a class="reference internal" href="constraints.html#sqlalchemy.schema.PrimaryKeyConstraint" title="sqlalchemy.schema.PrimaryKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">PrimaryKeyConstraint</span></code></a>, and <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a>.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.autoload"></span><strong>autoload</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.autoload">¶</a> – <p>Defaults to False, unless <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload_with" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload_with</span></code></a> is set in which case it defaults to True; <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects for this table should be reflected from the database, possibly augmenting or replacing existing <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects that were explicitly specified.</p> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 1.0.0: </span>setting the <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload_with" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload_with</span></code></a> parameter implies that <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a> will default to True.</p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="reflection.html"><span class="std std-ref">Reflecting Database Objects</span></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.autoload_replace"></span><strong>autoload_replace</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.autoload_replace">¶</a> – <p>Defaults to <code class="docutils literal notranslate"><span class="pre">True</span></code>; when using <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a> in conjunction with <a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a>, indicates that <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects present in the already-existing <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object should be replaced with columns of the same name retrieved from the autoload process. When <code class="docutils literal notranslate"><span class="pre">False</span></code>, columns already present under existing names will be omitted from the reflection process.</p> <p>Note that this setting does not impact <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects specified programmatically within the call to <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> that also is autoloading; those <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects will always replace existing columns of the same name when <a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a> is <code class="docutils literal notranslate"><span class="pre">True</span></code>.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a></p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.autoload_with"></span><strong>autoload_with</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.autoload_with">¶</a> – <p>An <a class="reference internal" href="connections.html#sqlalchemy.engine.Engine" title="sqlalchemy.engine.Engine"><code class="xref py py-class docutils literal notranslate"><span class="pre">Engine</span></code></a> or <a class="reference internal" href="connections.html#sqlalchemy.engine.Connection" title="sqlalchemy.engine.Connection"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connection</span></code></a> object with which this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object will be reflected; when set to a non-None value, it implies that <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a> is <code class="docutils literal notranslate"><span class="pre">True</span></code>. If left unset, but <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a> is explicitly set to <code class="docutils literal notranslate"><span class="pre">True</span></code>, an autoload operation will attempt to proceed by locating an <a class="reference internal" href="connections.html#sqlalchemy.engine.Engine" title="sqlalchemy.engine.Engine"><code class="xref py py-class docutils literal notranslate"><span class="pre">Engine</span></code></a> or <a class="reference internal" href="connections.html#sqlalchemy.engine.Connection" title="sqlalchemy.engine.Connection"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connection</span></code></a> bound to the underlying <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.extend_existing"></span><strong>extend_existing</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.extend_existing">¶</a> – <p>When <code class="docutils literal notranslate"><span class="pre">True</span></code>, indicates that if this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> is already present in the given <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>, apply further arguments within the constructor to the existing <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <p>If <a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a> or <a class="reference internal" href="#sqlalchemy.schema.Table.params.keep_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.keep_existing</span></code></a> are not set, and the given name of the new <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> refers to a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> that is already present in the target <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection, and this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> specifies additional columns or other constructs or flags that modify the table’s state, an error is raised. The purpose of these two mutually-exclusive flags is to specify what action should be taken when a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> is specified that matches an existing <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, yet specifies additional constructs.</p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a> will also work in conjunction with <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a> to run a new reflection operation against the database, even if a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> of the same name is already present in the target <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>; newly reflected <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects and other options will be added into the state of the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, potentially overwriting existing columns and options of the same name.</p> <p>As is always the case with <a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a>, <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects can be specified in the same <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> constructor, which will take precedence. Below, the existing table <code class="docutils literal notranslate"><span class="pre">mytable</span></code> will be augmented with <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> objects both reflected from the database, as well as the given <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> named “y”:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Table</span><span class="p">(</span><span class="s2">"mytable"</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'y'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">),</span> <span class="n">extend_existing</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">autoload</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">autoload_with</span><span class="o">=</span><span class="n">engine</span> <span class="p">)</span></pre></div> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload</span></code></a></p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.autoload_replace" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.autoload_replace</span></code></a></p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.keep_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.keep_existing</span></code></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.implicit_returning"></span><strong>implicit_returning</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.implicit_returning">¶</a> – True by default - indicates that RETURNING can be used by default to fetch newly inserted primary key values, for backends which support this. Note that create_engine() also provides an implicit_returning flag.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.include_columns"></span><strong>include_columns</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.include_columns">¶</a> – A list of strings indicating a subset of columns to be loaded via the <code class="docutils literal notranslate"><span class="pre">autoload</span></code> operation; table columns who aren’t present in this list will not be represented on the resulting <code class="docutils literal notranslate"><span class="pre">Table</span></code> object. Defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code> which indicates all columns should be reflected.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.info"></span><strong>info</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.info">¶</a> – Optional data dictionary which will be populated into the <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.info" title="sqlalchemy.schema.SchemaItem.info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">SchemaItem.info</span></code></a> attribute of this object.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.keep_existing"></span><strong>keep_existing</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.keep_existing">¶</a> – <p>When <code class="docutils literal notranslate"><span class="pre">True</span></code>, indicates that if this Table is already present in the given <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>, ignore further arguments within the constructor to the existing <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, and return the <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object as originally created. This is to allow a function that wishes to define a new <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> on first call, but on subsequent calls will return the same <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, without any of the declarations (particularly constraints) being applied a second time.</p> <p>If <a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a> or <a class="reference internal" href="#sqlalchemy.schema.Table.params.keep_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.keep_existing</span></code></a> are not set, and the given name of the new <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> refers to a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> that is already present in the target <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection, and this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> specifies additional columns or other constructs or flags that modify the table’s state, an error is raised. The purpose of these two mutually-exclusive flags is to specify what action should be taken when a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> is specified that matches an existing <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, yet specifies additional constructs.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.listeners"></span><strong>listeners</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.listeners">¶</a> – <p>A list of tuples of the form <code class="docutils literal notranslate"><span class="pre">(<eventname>,</span> <span class="pre"><fn>)</span></code> which will be passed to <a class="reference internal" href="event.html#sqlalchemy.event.listen" title="sqlalchemy.event.listen"><code class="xref py py-func docutils literal notranslate"><span class="pre">event.listen()</span></code></a> upon construction. This alternate hook to <a class="reference internal" href="event.html#sqlalchemy.event.listen" title="sqlalchemy.event.listen"><code class="xref py py-func docutils literal notranslate"><span class="pre">event.listen()</span></code></a> allows the establishment of a listener function specific to this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> before the “autoload” process begins. Particularly useful for the <a class="reference internal" href="events.html#sqlalchemy.events.DDLEvents.column_reflect" title="sqlalchemy.events.DDLEvents.column_reflect"><code class="xref py py-meth docutils literal notranslate"><span class="pre">DDLEvents.column_reflect()</span></code></a> event:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">listen_for_reflect</span><span class="p">(</span><span class="n">table</span><span class="p">,</span> <span class="n">column_info</span><span class="p">):</span> <span class="s2">"handle the column reflection event"</span> <span class="c1"># ...</span> <span class="n">t</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span> <span class="s1">'sometable'</span><span class="p">,</span> <span class="n">autoload</span><span class="o">=</span><span class="kc">True</span><span class="p">,</span> <span class="n">listeners</span><span class="o">=</span><span class="p">[</span> <span class="p">(</span><span class="s1">'column_reflect'</span><span class="p">,</span> <span class="n">listen_for_reflect</span><span class="p">)</span> <span class="p">])</span></pre></div> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.mustexist"></span><strong>mustexist</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.mustexist">¶</a> – When <code class="docutils literal notranslate"><span class="pre">True</span></code>, indicates that this Table must already be present in the given <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> collection, else an exception is raised.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.prefixes"></span><strong>prefixes</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.prefixes">¶</a> – A list of strings to insert after CREATE in the CREATE TABLE statement. They will be separated by spaces.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.quote"></span><strong>quote</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.quote">¶</a> – Force quoting of this table’s name on or off, corresponding to <code class="docutils literal notranslate"><span class="pre">True</span></code> or <code class="docutils literal notranslate"><span class="pre">False</span></code>. When left at its default of <code class="docutils literal notranslate"><span class="pre">None</span></code>, the column identifier will be quoted according to whether the name is case sensitive (identifiers with at least one upper case character are treated as case sensitive), or if it’s a reserved word. This flag is only needed to force quoting of a reserved word which is not known by the SQLAlchemy dialect.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.quote_schema"></span><strong>quote_schema</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.quote_schema">¶</a> – same as ‘quote’ but applies to the schema identifier.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.schema"></span><strong>schema</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.schema">¶</a> – <p>The schema name for this table, which is required if the table resides in a schema other than the default selected schema for the engine’s database connection. Defaults to <code class="docutils literal notranslate"><span class="pre">None</span></code>.</p> <p>If the owning <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> of this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> specifies its own <a class="reference internal" href="#sqlalchemy.schema.MetaData.params.schema" title="sqlalchemy.schema.MetaData"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">MetaData.schema</span></code></a> parameter, then that schema name will be applied to this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> if the schema parameter here is set to <code class="docutils literal notranslate"><span class="pre">None</span></code>. To set a blank schema name on a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> that would otherwise use the schema set on the owning <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>, specify the special symbol <a class="reference internal" href="#sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA" title="sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA"><code class="xref py py-attr docutils literal notranslate"><span class="pre">BLANK_SCHEMA</span></code></a>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.0.14: </span>Added the <a class="reference internal" href="#sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA" title="sqlalchemy.schema.sqlalchemy.schema.BLANK_SCHEMA"><code class="xref py py-attr docutils literal notranslate"><span class="pre">BLANK_SCHEMA</span></code></a> symbol to allow a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> to have a blank schema name even when the parent <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> specifies <a class="reference internal" href="#sqlalchemy.schema.MetaData.params.schema" title="sqlalchemy.schema.MetaData"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">MetaData.schema</span></code></a>.</p> </div> <p>The quoting rules for the schema name are the same as those for the <code class="docutils literal notranslate"><span class="pre">name</span></code> parameter, in that quoting is applied for reserved words or case-sensitive names; to enable unconditional quoting for the schema name, specify the flag <code class="docutils literal notranslate"><span class="pre">quote_schema=True</span></code> to the constructor, or use the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.elements.quoted_name" title="sqlalchemy.sql.elements.quoted_name"><code class="xref py py-class docutils literal notranslate"><span class="pre">quoted_name</span></code></a> construct to specify the name.</p> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.useexisting"></span><strong>useexisting</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.useexisting">¶</a> – Deprecated. Use <a class="reference internal" href="#sqlalchemy.schema.Table.params.extend_existing" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.extend_existing</span></code></a>.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.comment"></span><strong>comment</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.comment">¶</a> – <p>Optional string that will render an SQL comment on table creation.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.2: </span>Added the <a class="reference internal" href="#sqlalchemy.schema.Table.params.comment" title="sqlalchemy.schema.Table"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">Table.comment</span></code></a> parameter to <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.params.**kw"></span><strong>**kw</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.params.**kw">¶</a> – Additional keyword arguments not mentioned above are dialect specific, and passed in the form <code class="docutils literal notranslate"><span class="pre"><dialectname>_<argname></span></code>. See the documentation regarding an individual dialect at <a class="reference internal" href="../dialects/index.html"><span class="std std-ref">Dialects</span></a> for detail on documented arguments.</p></li> </ul> </dd> </dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.__eq__"> <code class="descname">__eq__</code><a class="headerlink" href="#sqlalchemy.schema.Table.__eq__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <code class="xref py py-attr docutils literal notranslate"><span class="pre">__eq__</span></code> <em>attribute of</em> <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> </div> <p>Return self==value.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><em>*args</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Constructor for <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <p>This method is a no-op. See the top-level documentation for <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> for constructor arguments.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.__le__"> <code class="descname">__le__</code><a class="headerlink" href="#sqlalchemy.schema.Table.__le__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <code class="xref py py-attr docutils literal notranslate"><span class="pre">__le__</span></code> <em>attribute of</em> <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> </div> <p>Return self<=value.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.__lt__"> <code class="descname">__lt__</code><a class="headerlink" href="#sqlalchemy.schema.Table.__lt__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <code class="xref py py-attr docutils literal notranslate"><span class="pre">__lt__</span></code> <em>attribute of</em> <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> </div> <p>Return self<value.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.__ne__"> <code class="descname">__ne__</code><a class="headerlink" href="#sqlalchemy.schema.Table.__ne__" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <code class="xref py py-attr docutils literal notranslate"><span class="pre">__ne__</span></code> <em>attribute of</em> <code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></p> </div> <p>Return self!=value.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.add_is_dependent_on"> <code class="descname">add_is_dependent_on</code><span class="sig-paren">(</span><em>table</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.add_is_dependent_on" title="Permalink to this definition">¶</a></dt> <dd><p>Add a ‘dependency’ for this Table.</p> <p>This is another Table object which must be created first before this one can, or dropped after this one.</p> <p>Usually, dependencies between tables are determined via ForeignKey objects. However, for other situations that create dependencies outside of foreign keys (rules, inheriting), this method can manually establish such a link.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.alias"> <code class="descname">alias</code><span class="sig-paren">(</span><em>name=None</em>, <em>flat=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.alias" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.alias" title="sqlalchemy.sql.expression.FromClause.alias"><code class="xref py py-meth docutils literal notranslate"><span class="pre">alias()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>return an alias of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> <p>This is shorthand for calling:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">sqlalchemy</span> <span class="k">import</span> <span class="n">alias</span> <span class="n">a</span> <span class="o">=</span> <span class="n">alias</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="o">=</span><span class="n">name</span><span class="p">)</span></pre></div> </div> <p>See <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.alias" title="sqlalchemy.sql.expression.alias"><code class="xref py py-func docutils literal notranslate"><span class="pre">alias()</span></code></a> for details.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.append_column"> <code class="descname">append_column</code><span class="sig-paren">(</span><em>column</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.append_column" title="Permalink to this definition">¶</a></dt> <dd><p>Append a <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> to this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <p>The “key” of the newly added <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a>, i.e. the value of its <code class="docutils literal notranslate"><span class="pre">.key</span></code> attribute, will then be available in the <code class="docutils literal notranslate"><span class="pre">.c</span></code> collection of this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, and the column definition will be included in any CREATE TABLE, SELECT, UPDATE, etc. statements generated from this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> construct.</p> <p>Note that this does <strong>not</strong> change the definition of the table as it exists within any underlying database, assuming that table has already been created in the database. Relational databases support the addition of columns to existing tables using the SQL ALTER command, which would need to be emitted for an already-existing table that doesn’t contain the newly added column.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.append_constraint"> <code class="descname">append_constraint</code><span class="sig-paren">(</span><em>constraint</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.append_constraint" title="Permalink to this definition">¶</a></dt> <dd><p>Append a <a class="reference internal" href="constraints.html#sqlalchemy.schema.Constraint" title="sqlalchemy.schema.Constraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constraint</span></code></a> to this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <p>This has the effect of the constraint being included in any future CREATE TABLE statement, assuming specific DDL creation events have not been associated with the given <a class="reference internal" href="constraints.html#sqlalchemy.schema.Constraint" title="sqlalchemy.schema.Constraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">Constraint</span></code></a> object.</p> <p>Note that this does <strong>not</strong> produce the constraint within the relational database automatically, for a table that already exists in the database. To add a constraint to an existing relational database table, the SQL ALTER command must be used. SQLAlchemy also provides the <a class="reference internal" href="ddl.html#sqlalchemy.schema.AddConstraint" title="sqlalchemy.schema.AddConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">AddConstraint</span></code></a> construct which can produce this SQL when invoked as an executable clause.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.append_ddl_listener"> <code class="descname">append_ddl_listener</code><span class="sig-paren">(</span><em>event_name</em>, <em>listener</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.append_ddl_listener" title="Permalink to this definition">¶</a></dt> <dd><p>Append a DDL event listener to this <code class="docutils literal notranslate"><span class="pre">Table</span></code>.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.7: </span>See <a class="reference internal" href="events.html#sqlalchemy.events.DDLEvents" title="sqlalchemy.events.DDLEvents"><code class="xref py py-class docutils literal notranslate"><span class="pre">DDLEvents</span></code></a>.</p> </div> </dd></dl> <dl class="classmethod"> <dt id="sqlalchemy.schema.Table.argument_for"> <em class="property">classmethod </em><code class="descname">argument_for</code><span class="sig-paren">(</span><em>dialect_name</em>, <em>argument_name</em>, <em>default</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.argument_for" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.argument_for" title="sqlalchemy.sql.base.DialectKWArgs.argument_for"><code class="xref py py-meth docutils literal notranslate"><span class="pre">argument_for()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs" title="sqlalchemy.sql.base.DialectKWArgs"><code class="xref py py-class docutils literal notranslate"><span class="pre">DialectKWArgs</span></code></a></p> </div> <p>Add a new kind of dialect-specific keyword argument for this class.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">Index</span><span class="o">.</span><span class="n">argument_for</span><span class="p">(</span><span class="s2">"mydialect"</span><span class="p">,</span> <span class="s2">"length"</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span> <span class="n">some_index</span> <span class="o">=</span> <span class="n">Index</span><span class="p">(</span><span class="s1">'a'</span><span class="p">,</span> <span class="s1">'b'</span><span class="p">,</span> <span class="n">mydialect_length</span><span class="o">=</span><span class="mi">5</span><span class="p">)</span></pre></div> </div> <p>The <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.argument_for" title="sqlalchemy.sql.base.DialectKWArgs.argument_for"><code class="xref py py-meth docutils literal notranslate"><span class="pre">DialectKWArgs.argument_for()</span></code></a> method is a per-argument way adding extra arguments to the <a class="reference internal" href="internals.html#sqlalchemy.engine.default.DefaultDialect.construct_arguments" title="sqlalchemy.engine.default.DefaultDialect.construct_arguments"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DefaultDialect.construct_arguments</span></code></a> dictionary. This dictionary provides a list of argument names accepted by various schema-level constructs on behalf of a dialect.</p> <p>New dialects should typically specify this dictionary all at once as a data member of the dialect class. The use case for ad-hoc addition of argument names is typically for end-user code that is also using a custom compilation scheme which consumes the additional arguments.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.argument_for.params.dialect_name"></span><strong>dialect_name</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.argument_for.params.dialect_name">¶</a> – name of a dialect. The dialect must be locatable, else a <a class="reference internal" href="exceptions.html#sqlalchemy.exc.NoSuchModuleError" title="sqlalchemy.exc.NoSuchModuleError"><code class="xref py py-class docutils literal notranslate"><span class="pre">NoSuchModuleError</span></code></a> is raised. The dialect must also include an existing <a class="reference internal" href="internals.html#sqlalchemy.engine.default.DefaultDialect.construct_arguments" title="sqlalchemy.engine.default.DefaultDialect.construct_arguments"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DefaultDialect.construct_arguments</span></code></a> collection, indicating that it participates in the keyword-argument validation and default system, else <a class="reference internal" href="exceptions.html#sqlalchemy.exc.ArgumentError" title="sqlalchemy.exc.ArgumentError"><code class="xref py py-class docutils literal notranslate"><span class="pre">ArgumentError</span></code></a> is raised. If the dialect does not include this collection, then any keyword argument can be specified on behalf of this dialect already. All dialects packaged within SQLAlchemy include this collection, however for third party dialects, support may vary.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.argument_for.params.argument_name"></span><strong>argument_name</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.argument_for.params.argument_name">¶</a> – name of the parameter.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.argument_for.params.default"></span><strong>default</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.argument_for.params.default">¶</a> – default value of the parameter.</p></li> </ul> </dd> </dl> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.4.</span></p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.bind"> <code class="descname">bind</code><a class="headerlink" href="#sqlalchemy.schema.Table.bind" title="Permalink to this definition">¶</a></dt> <dd><p>Return the connectable associated with this Table.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.c"> <code class="descname">c</code><a class="headerlink" href="#sqlalchemy.schema.Table.c" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.c" title="sqlalchemy.sql.expression.FromClause.c"><code class="xref py py-attr docutils literal notranslate"><span class="pre">c</span></code></a> <em>attribute of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>An alias for the <a class="reference internal" href="#sqlalchemy.schema.Table.columns" title="sqlalchemy.schema.Table.columns"><code class="xref py py-attr docutils literal notranslate"><span class="pre">columns</span></code></a> attribute.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.columns"> <code class="descname">columns</code><a class="headerlink" href="#sqlalchemy.schema.Table.columns" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.columns" title="sqlalchemy.sql.expression.FromClause.columns"><code class="xref py py-attr docutils literal notranslate"><span class="pre">columns</span></code></a> <em>attribute of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>A named-based collection of <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a> objects maintained by this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> <p>The <a class="reference internal" href="#sqlalchemy.schema.Table.columns" title="sqlalchemy.schema.Table.columns"><code class="xref py py-attr docutils literal notranslate"><span class="pre">columns</span></code></a>, or <a class="reference internal" href="#sqlalchemy.schema.Table.c" title="sqlalchemy.schema.Table.c"><code class="xref py py-attr docutils literal notranslate"><span class="pre">c</span></code></a> collection, is the gateway to the construction of SQL expressions using table-bound or other selectable-bound columns:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">select</span><span class="p">([</span><span class="n">mytable</span><span class="p">])</span><span class="o">.</span><span class="n">where</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">somecolumn</span> <span class="o">==</span> <span class="mi">5</span><span class="p">)</span></pre></div> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.compare"> <code class="descname">compare</code><span class="sig-paren">(</span><em>other</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.compare" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement.compare" title="sqlalchemy.sql.expression.ClauseElement.compare"><code class="xref py py-meth docutils literal notranslate"><span class="pre">compare()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a></p> </div> <p>Compare this ClauseElement to the given ClauseElement.</p> <p>Subclasses should override the default behavior, which is a straight identity comparison.</p> <p>**kw are arguments consumed by subclass compare() methods and may be used to modify the criteria for comparison. (see <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a>)</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.compile"> <code class="descname">compile</code><span class="sig-paren">(</span><em>default</em>, <em>bind=None</em>, <em>dialect=None</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.compile" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement.compile" title="sqlalchemy.sql.expression.ClauseElement.compile"><code class="xref py py-meth docutils literal notranslate"><span class="pre">compile()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a></p> </div> <p>Compile this SQL expression.</p> <p>The return value is a <a class="reference internal" href="internals.html#sqlalchemy.engine.interfaces.Compiled" title="sqlalchemy.engine.interfaces.Compiled"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compiled</span></code></a> object. Calling <code class="docutils literal notranslate"><span class="pre">str()</span></code> or <code class="docutils literal notranslate"><span class="pre">unicode()</span></code> on the returned value will yield a string representation of the result. The <a class="reference internal" href="internals.html#sqlalchemy.engine.interfaces.Compiled" title="sqlalchemy.engine.interfaces.Compiled"><code class="xref py py-class docutils literal notranslate"><span class="pre">Compiled</span></code></a> object also can return a dictionary of bind parameter names and values using the <code class="docutils literal notranslate"><span class="pre">params</span></code> accessor.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.compile.params.bind"></span><strong>bind</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.compile.params.bind">¶</a> – An <code class="docutils literal notranslate"><span class="pre">Engine</span></code> or <code class="docutils literal notranslate"><span class="pre">Connection</span></code> from which a <code class="docutils literal notranslate"><span class="pre">Compiled</span></code> will be acquired. This argument takes precedence over this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a>’s bound engine, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.compile.params.column_keys"></span><strong>column_keys</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.compile.params.column_keys">¶</a> – Used for INSERT and UPDATE statements, a list of column names which should be present in the VALUES clause of the compiled statement. If <code class="docutils literal notranslate"><span class="pre">None</span></code>, all columns from the target table object are rendered.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.compile.params.dialect"></span><strong>dialect</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.compile.params.dialect">¶</a> – A <code class="docutils literal notranslate"><span class="pre">Dialect</span></code> instance from which a <code class="docutils literal notranslate"><span class="pre">Compiled</span></code> will be acquired. This argument takes precedence over the <cite>bind</cite> argument as well as this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a>’s bound engine, if any.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.compile.params.inline"></span><strong>inline</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.compile.params.inline">¶</a> – Used for INSERT statements, for a dialect which does not support inline retrieval of newly generated primary key columns, will force the expression used to create the new primary key value to be rendered inline within the INSERT statement’s VALUES clause. This typically refers to Sequence execution but may also refer to any server-side default generation function associated with a primary key <cite>Column</cite>.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.compile.params.compile_kwargs"></span><strong>compile_kwargs</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.compile.params.compile_kwargs">¶</a> – <p>optional dictionary of additional parameters that will be passed through to the compiler within all “visit” methods. This allows any custom flag to be passed through to a custom compilation construct, for example. It is also used for the case of passing the <code class="docutils literal notranslate"><span class="pre">literal_binds</span></code> flag through:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">sqlalchemy.sql</span> <span class="k">import</span> <span class="n">table</span><span class="p">,</span> <span class="n">column</span><span class="p">,</span> <span class="n">select</span> <span class="n">t</span> <span class="o">=</span> <span class="n">table</span><span class="p">(</span><span class="s1">'t'</span><span class="p">,</span> <span class="n">column</span><span class="p">(</span><span class="s1">'x'</span><span class="p">))</span> <span class="n">s</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">t</span><span class="p">])</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">t</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">x</span> <span class="o">==</span> <span class="mi">5</span><span class="p">)</span> <span class="nb">print</span> <span class="n">s</span><span class="o">.</span><span class="n">compile</span><span class="p">(</span><span class="n">compile_kwargs</span><span class="o">=</span><span class="p">{</span><span class="s2">"literal_binds"</span><span class="p">:</span> <span class="kc">True</span><span class="p">})</span></pre></div> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.0.</span></p> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="../faq/sqlexpressions.html#faq-sql-expression-string"><span class="std std-ref">How do I render SQL expressions as strings, possibly with bound parameters inlined?</span></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.correspond_on_equivalents"> <code class="descname">correspond_on_equivalents</code><span class="sig-paren">(</span><em>column</em>, <em>equivalents</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.correspond_on_equivalents" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.correspond_on_equivalents" title="sqlalchemy.sql.expression.FromClause.correspond_on_equivalents"><code class="xref py py-meth docutils literal notranslate"><span class="pre">correspond_on_equivalents()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return corresponding_column for the given column, or if None search for a match in the given dictionary.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.corresponding_column"> <code class="descname">corresponding_column</code><span class="sig-paren">(</span><em>column</em>, <em>require_embedded=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.corresponding_column" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.corresponding_column" title="sqlalchemy.sql.expression.FromClause.corresponding_column"><code class="xref py py-meth docutils literal notranslate"><span class="pre">corresponding_column()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Given a <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a>, return the exported <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a> object from this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Selectable" title="sqlalchemy.sql.expression.Selectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Selectable</span></code></a> which corresponds to that original <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a> via a common ancestor column.</p> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.corresponding_column.params.column"></span><strong>column</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.corresponding_column.params.column">¶</a> – the target <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a> to be matched</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.corresponding_column.params.require_embedded"></span><strong>require_embedded</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.corresponding_column.params.require_embedded">¶</a> – only return corresponding columns for the given <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a>, if the given <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ColumnElement" title="sqlalchemy.sql.expression.ColumnElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ColumnElement</span></code></a> is actually present within a sub-element of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>. Normally the column will match if it merely shares a common ancestor with one of the exported columns of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.count"> <code class="descname">count</code><span class="sig-paren">(</span><em>functions</em>, <em>whereclause=None</em>, <em>**params</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.count" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.count" title="sqlalchemy.sql.expression.FromClause.count"><code class="xref py py-meth docutils literal notranslate"><span class="pre">count()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>return a SELECT COUNT generated against this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 1.1: </span>The <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.count" title="sqlalchemy.sql.expression.FromClause.count"><code class="xref py py-meth docutils literal notranslate"><span class="pre">FromClause.count()</span></code></a> method is deprecated, and will be removed in a future release. Please use the <a class="reference internal" href="functions.html#sqlalchemy.sql.functions.count" title="sqlalchemy.sql.functions.count"><code class="xref py py-class docutils literal notranslate"><span class="pre">functions.count</span></code></a> function available from the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.Over.func" title="sqlalchemy.sql.expression.Over.func"><code class="xref py py-attr docutils literal notranslate"><span class="pre">func</span></code></a> namespace.</p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="functions.html#sqlalchemy.sql.functions.count" title="sqlalchemy.sql.functions.count"><code class="xref py py-class docutils literal notranslate"><span class="pre">functions.count</span></code></a></p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.create"> <code class="descname">create</code><span class="sig-paren">(</span><em>bind=None</em>, <em>checkfirst=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.create" title="Permalink to this definition">¶</a></dt> <dd><p>Issue a <code class="docutils literal notranslate"><span class="pre">CREATE</span></code> statement for this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, using the given <a class="reference internal" href="connections.html#sqlalchemy.engine.Connectable" title="sqlalchemy.engine.Connectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connectable</span></code></a> for connectivity.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData.create_all" title="sqlalchemy.schema.MetaData.create_all"><code class="xref py py-meth docutils literal notranslate"><span class="pre">MetaData.create_all()</span></code></a>.</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.delete"> <code class="descname">delete</code><span class="sig-paren">(</span><em>dml</em>, <em>whereclause=None</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.delete" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause.delete" title="sqlalchemy.sql.expression.TableClause.delete"><code class="xref py py-meth docutils literal notranslate"><span class="pre">delete()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableClause</span></code></a></p> </div> <p>Generate a <a class="reference internal" href="dml.html#sqlalchemy.sql.expression.delete" title="sqlalchemy.sql.expression.delete"><code class="xref py py-func docutils literal notranslate"><span class="pre">delete()</span></code></a> construct against this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableClause</span></code></a>.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">table</span><span class="o">.</span><span class="n">delete</span><span class="p">()</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span><span class="o">==</span><span class="mi">7</span><span class="p">)</span></pre></div> </div> <p>See <a class="reference internal" href="dml.html#sqlalchemy.sql.expression.delete" title="sqlalchemy.sql.expression.delete"><code class="xref py py-func docutils literal notranslate"><span class="pre">delete()</span></code></a> for argument and usage information.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.dialect_kwargs"> <code class="descname">dialect_kwargs</code><a class="headerlink" href="#sqlalchemy.schema.Table.dialect_kwargs" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs" title="sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs"><code class="xref py py-attr docutils literal notranslate"><span class="pre">dialect_kwargs</span></code></a> <em>attribute of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs" title="sqlalchemy.sql.base.DialectKWArgs"><code class="xref py py-class docutils literal notranslate"><span class="pre">DialectKWArgs</span></code></a></p> </div> <p>A collection of keyword arguments specified as dialect-specific options to this construct.</p> <p>The arguments are present here in their original <code class="docutils literal notranslate"><span class="pre"><dialect>_<kwarg></span></code> format. Only arguments that were actually passed are included; unlike the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_options" title="sqlalchemy.sql.base.DialectKWArgs.dialect_options"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DialectKWArgs.dialect_options</span></code></a> collection, which contains all options known by this dialect including defaults.</p> <p>The collection is also writable; keys are accepted of the form <code class="docutils literal notranslate"><span class="pre"><dialect>_<kwarg></span></code> where the value will be assembled into the list of options.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.2.</span></p> </div> <div class="versionchanged"> <p><span class="versionmodified changed">Changed in version 0.9.4: </span>The <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs" title="sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DialectKWArgs.dialect_kwargs</span></code></a> collection is now writable.</p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_options" title="sqlalchemy.sql.base.DialectKWArgs.dialect_options"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DialectKWArgs.dialect_options</span></code></a> - nested dictionary form</p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.dialect_options"> <code class="descname">dialect_options</code><a class="headerlink" href="#sqlalchemy.schema.Table.dialect_options" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_options" title="sqlalchemy.sql.base.DialectKWArgs.dialect_options"><code class="xref py py-attr docutils literal notranslate"><span class="pre">dialect_options</span></code></a> <em>attribute of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs" title="sqlalchemy.sql.base.DialectKWArgs"><code class="xref py py-class docutils literal notranslate"><span class="pre">DialectKWArgs</span></code></a></p> </div> <p>A collection of keyword arguments specified as dialect-specific options to this construct.</p> <p>This is a two-level nested registry, keyed to <code class="docutils literal notranslate"><span class="pre"><dialect_name></span></code> and <code class="docutils literal notranslate"><span class="pre"><argument_name></span></code>. For example, the <code class="docutils literal notranslate"><span class="pre">postgresql_where</span></code> argument would be locatable as:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">arg</span> <span class="o">=</span> <span class="n">my_object</span><span class="o">.</span><span class="n">dialect_options</span><span class="p">[</span><span class="s1">'postgresql'</span><span class="p">][</span><span class="s1">'where'</span><span class="p">]</span></pre></div> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.2.</span></p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs" title="sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DialectKWArgs.dialect_kwargs</span></code></a> - flat dictionary form</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.drop"> <code class="descname">drop</code><span class="sig-paren">(</span><em>bind=None</em>, <em>checkfirst=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.drop" title="Permalink to this definition">¶</a></dt> <dd><p>Issue a <code class="docutils literal notranslate"><span class="pre">DROP</span></code> statement for this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, using the given <a class="reference internal" href="connections.html#sqlalchemy.engine.Connectable" title="sqlalchemy.engine.Connectable"><code class="xref py py-class docutils literal notranslate"><span class="pre">Connectable</span></code></a> for connectivity.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="#sqlalchemy.schema.MetaData.drop_all" title="sqlalchemy.schema.MetaData.drop_all"><code class="xref py py-meth docutils literal notranslate"><span class="pre">MetaData.drop_all()</span></code></a>.</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.exists"> <code class="descname">exists</code><span class="sig-paren">(</span><em>bind=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.exists" title="Permalink to this definition">¶</a></dt> <dd><p>Return True if this table exists.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.foreign_key_constraints"> <code class="descname">foreign_key_constraints</code><a class="headerlink" href="#sqlalchemy.schema.Table.foreign_key_constraints" title="Permalink to this definition">¶</a></dt> <dd><p><a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a> objects referred to by this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <p>This list is produced from the collection of <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKey" title="sqlalchemy.schema.ForeignKey"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKey</span></code></a> objects currently associated.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.0.0.</span></p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.foreign_keys"> <code class="descname">foreign_keys</code><a class="headerlink" href="#sqlalchemy.schema.Table.foreign_keys" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.foreign_keys" title="sqlalchemy.sql.expression.FromClause.foreign_keys"><code class="xref py py-attr docutils literal notranslate"><span class="pre">foreign_keys</span></code></a> <em>attribute of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return the collection of ForeignKey objects which this FromClause references.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.get_children"> <code class="descname">get_children</code><span class="sig-paren">(</span><em>column_collections=True</em>, <em>schema_visitor=False</em>, <em>**kw</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.get_children" title="Permalink to this definition">¶</a></dt> <dd><p>used to allow SchemaVisitor access</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.info"> <code class="descname">info</code><a class="headerlink" href="#sqlalchemy.schema.Table.info" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.info" title="sqlalchemy.schema.SchemaItem.info"><code class="xref py py-attr docutils literal notranslate"><span class="pre">info</span></code></a> <em>attribute of</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a></p> </div> <p>Info dictionary associated with the object, allowing user-defined data to be associated with this <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a>.</p> <p>The dictionary is automatically generated when first accessed. It can also be specified in the constructor of some objects, such as <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> and <a class="reference internal" href="#sqlalchemy.schema.Column" title="sqlalchemy.schema.Column"><code class="xref py py-class docutils literal notranslate"><span class="pre">Column</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.insert"> <code class="descname">insert</code><span class="sig-paren">(</span><em>dml</em>, <em>values=None</em>, <em>inline=False</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.insert" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause.insert" title="sqlalchemy.sql.expression.TableClause.insert"><code class="xref py py-meth docutils literal notranslate"><span class="pre">insert()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableClause</span></code></a></p> </div> <p>Generate an <a class="reference internal" href="dml.html#sqlalchemy.sql.expression.insert" title="sqlalchemy.sql.expression.insert"><code class="xref py py-func docutils literal notranslate"><span class="pre">insert()</span></code></a> construct against this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableClause</span></code></a>.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">table</span><span class="o">.</span><span class="n">insert</span><span class="p">()</span><span class="o">.</span><span class="n">values</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s1">'foo'</span><span class="p">)</span></pre></div> </div> <p>See <a class="reference internal" href="dml.html#sqlalchemy.sql.expression.insert" title="sqlalchemy.sql.expression.insert"><code class="xref py py-func docutils literal notranslate"><span class="pre">insert()</span></code></a> for argument and usage information.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.is_derived_from"> <code class="descname">is_derived_from</code><span class="sig-paren">(</span><em>fromclause</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.is_derived_from" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.is_derived_from" title="sqlalchemy.sql.expression.FromClause.is_derived_from"><code class="xref py py-meth docutils literal notranslate"><span class="pre">is_derived_from()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return True if this FromClause is ‘derived’ from the given FromClause.</p> <p>An example would be an Alias of a Table is derived from that Table.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.join"> <code class="descname">join</code><span class="sig-paren">(</span><em>right</em>, <em>onclause=None</em>, <em>isouter=False</em>, <em>full=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.join" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.join" title="sqlalchemy.sql.expression.FromClause.join"><code class="xref py py-meth docutils literal notranslate"><span class="pre">join()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return a <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Join" title="sqlalchemy.sql.expression.Join"><code class="xref py py-class docutils literal notranslate"><span class="pre">Join</span></code></a> from this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a> to another <code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code>.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">sqlalchemy</span> <span class="k">import</span> <span class="n">join</span> <span class="n">j</span> <span class="o">=</span> <span class="n">user_table</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">address_table</span><span class="p">,</span> <span class="n">user_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">address_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">user_id</span><span class="p">)</span> <span class="n">stmt</span> <span class="o">=</span> <span class="n">select</span><span class="p">([</span><span class="n">user_table</span><span class="p">])</span><span class="o">.</span><span class="n">select_from</span><span class="p">(</span><span class="n">j</span><span class="p">)</span></pre></div> </div> <p>would emit SQL along the lines of:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">SELECT</span> <span class="n">user</span><span class="o">.</span><span class="n">id</span><span class="p">,</span> <span class="n">user</span><span class="o">.</span><span class="n">name</span> <span class="n">FROM</span> <span class="n">user</span> <span class="n">JOIN</span> <span class="n">address</span> <span class="n">ON</span> <span class="n">user</span><span class="o">.</span><span class="n">id</span> <span class="o">=</span> <span class="n">address</span><span class="o">.</span><span class="n">user_id</span></pre></div> </div> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.join.params.right"></span><strong>right</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.join.params.right">¶</a> – the right side of the join; this is any <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a> object such as a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object, and may also be a selectable-compatible object such as an ORM-mapped class.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.join.params.onclause"></span><strong>onclause</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.join.params.onclause">¶</a> – a SQL expression representing the ON clause of the join. If left at <code class="docutils literal notranslate"><span class="pre">None</span></code>, <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.join" title="sqlalchemy.sql.expression.FromClause.join"><code class="xref py py-meth docutils literal notranslate"><span class="pre">FromClause.join()</span></code></a> will attempt to join the two tables based on a foreign key relationship.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.join.params.isouter"></span><strong>isouter</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.join.params.isouter">¶</a> – if True, render a LEFT OUTER JOIN, instead of JOIN.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.join.params.full"></span><strong>full</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.join.params.full">¶</a> – <p>if True, render a FULL OUTER JOIN, instead of LEFT OUTER JOIN. Implies <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.join.params.isouter" title="sqlalchemy.sql.expression.FromClause.join"><code class="xref py py-paramref docutils literal notranslate"><span class="pre">FromClause.join.isouter</span></code></a>.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.join" title="sqlalchemy.sql.expression.join"><code class="xref py py-func docutils literal notranslate"><span class="pre">join()</span></code></a> - standalone function</p> <p><a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Join" title="sqlalchemy.sql.expression.Join"><code class="xref py py-class docutils literal notranslate"><span class="pre">Join</span></code></a> - the type of object produced</p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.key"> <code class="descname">key</code><a class="headerlink" href="#sqlalchemy.schema.Table.key" title="Permalink to this definition">¶</a></dt> <dd><p>Return the ‘key’ for this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <p>This value is used as the dictionary key within the <a class="reference internal" href="#sqlalchemy.schema.MetaData.tables" title="sqlalchemy.schema.MetaData.tables"><code class="xref py py-attr docutils literal notranslate"><span class="pre">MetaData.tables</span></code></a> collection. It is typically the same as that of <code class="xref py py-attr docutils literal notranslate"><span class="pre">Table.name</span></code> for a table with no <code class="xref py py-attr docutils literal notranslate"><span class="pre">Table.schema</span></code> set; otherwise it is typically of the form <code class="docutils literal notranslate"><span class="pre">schemaname.tablename</span></code>.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.kwargs"> <code class="descname">kwargs</code><a class="headerlink" href="#sqlalchemy.schema.Table.kwargs" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.kwargs" title="sqlalchemy.sql.base.DialectKWArgs.kwargs"><code class="xref py py-attr docutils literal notranslate"><span class="pre">kwargs</span></code></a> <em>attribute of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs" title="sqlalchemy.sql.base.DialectKWArgs"><code class="xref py py-class docutils literal notranslate"><span class="pre">DialectKWArgs</span></code></a></p> </div> <p>A synonym for <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs" title="sqlalchemy.sql.base.DialectKWArgs.dialect_kwargs"><code class="xref py py-attr docutils literal notranslate"><span class="pre">DialectKWArgs.dialect_kwargs</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.lateral"> <code class="descname">lateral</code><span class="sig-paren">(</span><em>name=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.lateral" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.lateral" title="sqlalchemy.sql.expression.FromClause.lateral"><code class="xref py py-meth docutils literal notranslate"><span class="pre">lateral()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return a LATERAL alias of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> <p>The return value is the <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Lateral" title="sqlalchemy.sql.expression.Lateral"><code class="xref py py-class docutils literal notranslate"><span class="pre">Lateral</span></code></a> construct also provided by the top-level <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.lateral" title="sqlalchemy.sql.expression.lateral"><code class="xref py py-func docutils literal notranslate"><span class="pre">lateral()</span></code></a> function.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="tutorial.html#lateral-selects"><span class="std std-ref">LATERAL correlation</span></a> - overview of usage.</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.outerjoin"> <code class="descname">outerjoin</code><span class="sig-paren">(</span><em>right</em>, <em>onclause=None</em>, <em>full=False</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.outerjoin" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.outerjoin" title="sqlalchemy.sql.expression.FromClause.outerjoin"><code class="xref py py-meth docutils literal notranslate"><span class="pre">outerjoin()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return a <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Join" title="sqlalchemy.sql.expression.Join"><code class="xref py py-class docutils literal notranslate"><span class="pre">Join</span></code></a> from this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a> to another <code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code>, with the “isouter” flag set to True.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="kn">from</span> <span class="nn">sqlalchemy</span> <span class="k">import</span> <span class="n">outerjoin</span> <span class="n">j</span> <span class="o">=</span> <span class="n">user_table</span><span class="o">.</span><span class="n">outerjoin</span><span class="p">(</span><span class="n">address_table</span><span class="p">,</span> <span class="n">user_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">address_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">user_id</span><span class="p">)</span></pre></div> </div> <p>The above is equivalent to:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">j</span> <span class="o">=</span> <span class="n">user_table</span><span class="o">.</span><span class="n">join</span><span class="p">(</span> <span class="n">address_table</span><span class="p">,</span> <span class="n">user_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">address_table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">user_id</span><span class="p">,</span> <span class="n">isouter</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span></pre></div> </div> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.outerjoin.params.right"></span><strong>right</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.outerjoin.params.right">¶</a> – the right side of the join; this is any <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a> object such as a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object, and may also be a selectable-compatible object such as an ORM-mapped class.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.outerjoin.params.onclause"></span><strong>onclause</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.outerjoin.params.onclause">¶</a> – a SQL expression representing the ON clause of the join. If left at <code class="docutils literal notranslate"><span class="pre">None</span></code>, <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.join" title="sqlalchemy.sql.expression.FromClause.join"><code class="xref py py-meth docutils literal notranslate"><span class="pre">FromClause.join()</span></code></a> will attempt to join the two tables based on a foreign key relationship.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.outerjoin.params.full"></span><strong>full</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.outerjoin.params.full">¶</a> – <p>if True, render a FULL OUTER JOIN, instead of LEFT OUTER JOIN.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> </p></li> </ul> </dd> </dl> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.join" title="sqlalchemy.sql.expression.FromClause.join"><code class="xref py py-meth docutils literal notranslate"><span class="pre">FromClause.join()</span></code></a></p> <p><a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Join" title="sqlalchemy.sql.expression.Join"><code class="xref py py-class docutils literal notranslate"><span class="pre">Join</span></code></a></p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.primary_key"> <code class="descname">primary_key</code><a class="headerlink" href="#sqlalchemy.schema.Table.primary_key" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.primary_key" title="sqlalchemy.sql.expression.FromClause.primary_key"><code class="xref py py-attr docutils literal notranslate"><span class="pre">primary_key</span></code></a> <em>attribute of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return the collection of Column objects which comprise the primary key of this FromClause.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.quote"> <code class="descname">quote</code><a class="headerlink" href="#sqlalchemy.schema.Table.quote" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.quote" title="sqlalchemy.schema.SchemaItem.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">quote</span></code></a> <em>attribute of</em> <a class="reference internal" href="#sqlalchemy.schema.SchemaItem" title="sqlalchemy.schema.SchemaItem"><code class="xref py py-class docutils literal notranslate"><span class="pre">SchemaItem</span></code></a></p> </div> <p>Return the value of the <code class="docutils literal notranslate"><span class="pre">quote</span></code> flag passed to this schema object, for those schema items which have a <code class="docutils literal notranslate"><span class="pre">name</span></code> field.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.9: </span>The <a class="reference internal" href="#sqlalchemy.schema.SchemaItem.quote" title="sqlalchemy.schema.SchemaItem.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">SchemaItem.quote</span></code></a> attribute is deprecated and will be removed in a future release. Use the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.elements.quoted_name.quote" title="sqlalchemy.sql.elements.quoted_name.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">quoted_name.quote</span></code></a> attribute on the <code class="docutils literal notranslate"><span class="pre">name</span></code> field of the target schema item to retrievequoted status.</p> </div> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.Table.quote_schema"> <code class="descname">quote_schema</code><a class="headerlink" href="#sqlalchemy.schema.Table.quote_schema" title="Permalink to this definition">¶</a></dt> <dd><p>Return the value of the <code class="docutils literal notranslate"><span class="pre">quote_schema</span></code> flag passed to this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>.</p> <div class="deprecated"> <p><span class="versionmodified deprecated">Deprecated since version 0.9: </span>The <code class="xref py py-meth docutils literal notranslate"><span class="pre">SchemaItem.quote()</span></code> method is deprecated and will be removed in a future release. Use the <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.elements.quoted_name.quote" title="sqlalchemy.sql.elements.quoted_name.quote"><code class="xref py py-attr docutils literal notranslate"><span class="pre">quoted_name.quote</span></code></a> attribute on the <code class="docutils literal notranslate"><span class="pre">schema</span></code> field of the target schema item to retrieve quoted status.</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.replace_selectable"> <code class="descname">replace_selectable</code><span class="sig-paren">(</span><em>sqlutil</em>, <em>old</em>, <em>alias</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.replace_selectable" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.replace_selectable" title="sqlalchemy.sql.expression.FromClause.replace_selectable"><code class="xref py py-meth docutils literal notranslate"><span class="pre">replace_selectable()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>replace all occurrences of FromClause ‘old’ with the given Alias object, returning a copy of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.select"> <code class="descname">select</code><span class="sig-paren">(</span><em>whereclause=None</em>, <em>**params</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.select" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.select" title="sqlalchemy.sql.expression.FromClause.select"><code class="xref py py-meth docutils literal notranslate"><span class="pre">select()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>return a SELECT of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a> - general purpose method which allows for arbitrary column lists.</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.self_group"> <code class="descname">self_group</code><span class="sig-paren">(</span><em>against=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.self_group" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement.self_group" title="sqlalchemy.sql.expression.ClauseElement.self_group"><code class="xref py py-meth docutils literal notranslate"><span class="pre">self_group()</span></code></a> <em>method of</em> <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a></p> </div> <p>Apply a ‘grouping’ to this <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a>.</p> <p>This method is overridden by subclasses to return a “grouping” construct, i.e. parenthesis. In particular it’s used by “binary” expressions to provide a grouping around themselves when placed into a larger expression, as well as by <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a> constructs when placed into the FROM clause of another <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.select" title="sqlalchemy.sql.expression.select"><code class="xref py py-func docutils literal notranslate"><span class="pre">select()</span></code></a>. (Note that subqueries should be normally created using the <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.Select.alias" title="sqlalchemy.sql.expression.Select.alias"><code class="xref py py-meth docutils literal notranslate"><span class="pre">Select.alias()</span></code></a> method, as many platforms require nested SELECT statements to be named).</p> <p>As expressions are composed together, the application of <a class="reference internal" href="#sqlalchemy.schema.Table.self_group" title="sqlalchemy.schema.Table.self_group"><code class="xref py py-meth docutils literal notranslate"><span class="pre">self_group()</span></code></a> is automatic - end-user code should never need to use this method directly. Note that SQLAlchemy’s clause constructs take operator precedence into account - so parenthesis might not be needed, for example, in an expression like <code class="docutils literal notranslate"><span class="pre">x</span> <span class="pre">OR</span> <span class="pre">(y</span> <span class="pre">AND</span> <span class="pre">z)</span></code> - AND takes precedence over OR.</p> <p>The base <a class="reference internal" href="#sqlalchemy.schema.Table.self_group" title="sqlalchemy.schema.Table.self_group"><code class="xref py py-meth docutils literal notranslate"><span class="pre">self_group()</span></code></a> method of <a class="reference internal" href="sqlelement.html#sqlalchemy.sql.expression.ClauseElement" title="sqlalchemy.sql.expression.ClauseElement"><code class="xref py py-class docutils literal notranslate"><span class="pre">ClauseElement</span></code></a> just returns self.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.tablesample"> <code class="descname">tablesample</code><span class="sig-paren">(</span><em>sampling</em>, <em>name=None</em>, <em>seed=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.tablesample" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause.tablesample" title="sqlalchemy.sql.expression.FromClause.tablesample"><code class="xref py py-meth docutils literal notranslate"><span class="pre">tablesample()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a></p> </div> <p>Return a TABLESAMPLE alias of this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.FromClause" title="sqlalchemy.sql.expression.FromClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">FromClause</span></code></a>.</p> <p>The return value is the <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableSample" title="sqlalchemy.sql.expression.TableSample"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableSample</span></code></a> construct also provided by the top-level <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.tablesample" title="sqlalchemy.sql.expression.tablesample"><code class="xref py py-func docutils literal notranslate"><span class="pre">tablesample()</span></code></a> function.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.1.</span></p> </div> <div class="admonition seealso"> <p class="admonition-title">See also</p> <p><a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.tablesample" title="sqlalchemy.sql.expression.tablesample"><code class="xref py py-func docutils literal notranslate"><span class="pre">tablesample()</span></code></a> - usage guidelines and parameters</p> </div> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.tometadata"> <code class="descname">tometadata</code><span class="sig-paren">(</span><em>metadata</em>, <em>schema=symbol('retain_schema')</em>, <em>referred_schema_fn=None</em>, <em>name=None</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.tometadata" title="Permalink to this definition">¶</a></dt> <dd><p>Return a copy of this <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> associated with a different <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">m1</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">()</span> <span class="n">user</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s1">'user'</span><span class="p">,</span> <span class="n">m1</span><span class="p">,</span> <span class="n">Column</span><span class="p">(</span><span class="s1">'id'</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span> <span class="n">primary_key</span><span class="o">=</span><span class="kc">True</span><span class="p">))</span> <span class="n">m2</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">()</span> <span class="n">user_copy</span> <span class="o">=</span> <span class="n">user</span><span class="o">.</span><span class="n">tometadata</span><span class="p">(</span><span class="n">m2</span><span class="p">)</span></pre></div> </div> <dl class="field-list simple"> <dt class="field-odd">Parameters</dt> <dd class="field-odd"><ul class="simple"> <li><p><span class="target" id="sqlalchemy.schema.Table.tometadata.params.metadata"></span><strong>metadata</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.tometadata.params.metadata">¶</a> – Target <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> object, into which the new <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> object will be created.</p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.tometadata.params.schema"></span><strong>schema</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.tometadata.params.schema">¶</a> – <p>optional string name indicating the target schema. Defaults to the special symbol <code class="xref py py-attr docutils literal notranslate"><span class="pre">RETAIN_SCHEMA</span></code> which indicates that no change to the schema name should be made in the new <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>. If set to a string name, the new <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> will have this new name as the <code class="docutils literal notranslate"><span class="pre">.schema</span></code>. If set to <code class="docutils literal notranslate"><span class="pre">None</span></code>, the schema will be set to that of the schema set on the target <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a>, which is typically <code class="docutils literal notranslate"><span class="pre">None</span></code> as well, unless set explicitly:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">m2</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">(</span><span class="n">schema</span><span class="o">=</span><span class="s1">'newschema'</span><span class="p">)</span> <span class="c1"># user_copy_one will have "newschema" as the schema name</span> <span class="n">user_copy_one</span> <span class="o">=</span> <span class="n">user</span><span class="o">.</span><span class="n">tometadata</span><span class="p">(</span><span class="n">m2</span><span class="p">,</span> <span class="n">schema</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span> <span class="n">m3</span> <span class="o">=</span> <span class="n">MetaData</span><span class="p">()</span> <span class="c1"># schema defaults to None</span> <span class="c1"># user_copy_two will have None as the schema name</span> <span class="n">user_copy_two</span> <span class="o">=</span> <span class="n">user</span><span class="o">.</span><span class="n">tometadata</span><span class="p">(</span><span class="n">m3</span><span class="p">,</span> <span class="n">schema</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span></pre></div> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.tometadata.params.referred_schema_fn"></span><strong>referred_schema_fn</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.tometadata.params.referred_schema_fn">¶</a> – <p>optional callable which can be supplied in order to provide for the schema name that should be assigned to the referenced table of a <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a>. The callable accepts this parent <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a>, the target schema that we are changing to, the <a class="reference internal" href="constraints.html#sqlalchemy.schema.ForeignKeyConstraint" title="sqlalchemy.schema.ForeignKeyConstraint"><code class="xref py py-class docutils literal notranslate"><span class="pre">ForeignKeyConstraint</span></code></a> object, and the existing “target schema” of that constraint. The function should return the string schema name that should be applied. E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">referred_schema_fn</span><span class="p">(</span><span class="n">table</span><span class="p">,</span> <span class="n">to_schema</span><span class="p">,</span> <span class="n">constraint</span><span class="p">,</span> <span class="n">referred_schema</span><span class="p">):</span> <span class="k">if</span> <span class="n">referred_schema</span> <span class="o">==</span> <span class="s1">'base_tables'</span><span class="p">:</span> <span class="k">return</span> <span class="n">referred_schema</span> <span class="k">else</span><span class="p">:</span> <span class="k">return</span> <span class="n">to_schema</span> <span class="n">new_table</span> <span class="o">=</span> <span class="n">table</span><span class="o">.</span><span class="n">tometadata</span><span class="p">(</span><span class="n">m2</span><span class="p">,</span> <span class="n">schema</span><span class="o">=</span><span class="s2">"alt_schema"</span><span class="p">,</span> <span class="n">referred_schema_fn</span><span class="o">=</span><span class="n">referred_schema_fn</span><span class="p">)</span></pre></div> </div> <div class="versionadded"> <p><span class="versionmodified added">New in version 0.9.2.</span></p> </div> </p></li> <li><p><span class="target" id="sqlalchemy.schema.Table.tometadata.params.name"></span><strong>name</strong><a class="paramlink headerlink reference internal" href="#sqlalchemy.schema.Table.tometadata.params.name">¶</a> – <p>optional string name indicating the target table name. If not specified or None, the table name is retained. This allows a <a class="reference internal" href="#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><code class="xref py py-class docutils literal notranslate"><span class="pre">Table</span></code></a> to be copied to the same <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">MetaData</span></code></a> target with a new name.</p> <div class="versionadded"> <p><span class="versionmodified added">New in version 1.0.0.</span></p> </div> </p></li> </ul> </dd> </dl> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.Table.update"> <code class="descname">update</code><span class="sig-paren">(</span><em>dml</em>, <em>whereclause=None</em>, <em>values=None</em>, <em>inline=False</em>, <em>**kwargs</em><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.Table.update" title="Permalink to this definition">¶</a></dt> <dd><div class="inherited-member docutils container"> <p><em>inherited from the</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause.update" title="sqlalchemy.sql.expression.TableClause.update"><code class="xref py py-meth docutils literal notranslate"><span class="pre">update()</span></code></a> <em>method of</em> <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableClause</span></code></a></p> </div> <p>Generate an <a class="reference internal" href="dml.html#sqlalchemy.sql.expression.update" title="sqlalchemy.sql.expression.update"><code class="xref py py-func docutils literal notranslate"><span class="pre">update()</span></code></a> construct against this <a class="reference internal" href="selectable.html#sqlalchemy.sql.expression.TableClause" title="sqlalchemy.sql.expression.TableClause"><code class="xref py py-class docutils literal notranslate"><span class="pre">TableClause</span></code></a>.</p> <p>E.g.:</p> <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">table</span><span class="o">.</span><span class="n">update</span><span class="p">()</span><span class="o">.</span><span class="n">where</span><span class="p">(</span><span class="n">table</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span><span class="o">==</span><span class="mi">7</span><span class="p">)</span><span class="o">.</span><span class="n">values</span><span class="p">(</span><span class="n">name</span><span class="o">=</span><span class="s1">'foo'</span><span class="p">)</span></pre></div> </div> <p>See <a class="reference internal" href="dml.html#sqlalchemy.sql.expression.update" title="sqlalchemy.sql.expression.update"><code class="xref py py-func docutils literal notranslate"><span class="pre">update()</span></code></a> for argument and usage information.</p> </dd></dl> </dd></dl> <dl class="class"> <dt id="sqlalchemy.schema.ThreadLocalMetaData"> <em class="property">class </em><code class="descclassname">sqlalchemy.schema.</code><code class="descname">ThreadLocalMetaData</code><a class="headerlink" href="#sqlalchemy.schema.ThreadLocalMetaData" title="Permalink to this definition">¶</a></dt> <dd><p>Bases: <a class="reference internal" href="#sqlalchemy.schema.MetaData" title="sqlalchemy.schema.MetaData"><code class="xref py py-class docutils literal notranslate"><span class="pre">sqlalchemy.schema.MetaData</span></code></a></p> <p>A MetaData variant that presents a different <code class="docutils literal notranslate"><span class="pre">bind</span></code> in every thread.</p> <p>Makes the <code class="docutils literal notranslate"><span class="pre">bind</span></code> property of the MetaData a thread-local value, allowing this collection of tables to be bound to different <code class="docutils literal notranslate"><span class="pre">Engine</span></code> implementations or connections in each thread.</p> <p>The ThreadLocalMetaData starts off bound to None in each thread. Binds must be made explicitly by assigning to the <code class="docutils literal notranslate"><span class="pre">bind</span></code> property or using <code class="docutils literal notranslate"><span class="pre">connect()</span></code>. You can also re-bind dynamically multiple times per thread, just like a regular <code class="docutils literal notranslate"><span class="pre">MetaData</span></code>.</p> <dl class="method"> <dt id="sqlalchemy.schema.ThreadLocalMetaData.__init__"> <code class="descname">__init__</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.ThreadLocalMetaData.__init__" title="Permalink to this definition">¶</a></dt> <dd><p>Construct a ThreadLocalMetaData.</p> </dd></dl> <dl class="attribute"> <dt id="sqlalchemy.schema.ThreadLocalMetaData.bind"> <code class="descname">bind</code><a class="headerlink" href="#sqlalchemy.schema.ThreadLocalMetaData.bind" title="Permalink to this definition">¶</a></dt> <dd><p>The bound Engine or Connection for this thread.</p> <p>This property may be assigned an Engine or Connection, or assigned a string or URL to automatically create a basic Engine for this bind with <code class="docutils literal notranslate"><span class="pre">create_engine()</span></code>.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.ThreadLocalMetaData.dispose"> <code class="descname">dispose</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.ThreadLocalMetaData.dispose" title="Permalink to this definition">¶</a></dt> <dd><p>Dispose all bound engines, in all thread contexts.</p> </dd></dl> <dl class="method"> <dt id="sqlalchemy.schema.ThreadLocalMetaData.is_bound"> <code class="descname">is_bound</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#sqlalchemy.schema.ThreadLocalMetaData.is_bound" title="Permalink to this definition">¶</a></dt> <dd><p>True if there is a bind for this thread.</p> </dd></dl> </dd></dl> </div> </div> </div> </div> <div id="docs-bottom-navigation" class="docs-navigation-links, withsidebar"> Previous: <a href="schema.html" title="previous chapter">Schema Definition Language</a> Next: <a href="reflection.html" title="next chapter">Reflecting Database Objects</a> <div id="docs-copyright"> © <a href="../copyright.html">Copyright</a> 2007-2019, the SQLAlchemy authors and contributors. Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 2.0.1. </div> </div> </div> <script type="text/javascript"> var DOCUMENTATION_OPTIONS = { URL_ROOT: '../', VERSION: '1.2.19', COLLAPSE_MODINDEX: false, FILE_SUFFIX: '.html' }; </script> <script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script> <!-- begin iterate through sphinx environment script_files --> <script type="text/javascript" src="../_static/jquery.js"></script> <script type="text/javascript" src="../_static/underscore.js"></script> <script type="text/javascript" src="../_static/doctools.js"></script> <script type="text/javascript" src="../_static/language_data.js"></script> <!-- end iterate through sphinx environment script_files --> <script type="text/javascript" src="../_static/detectmobile.js"></script> <script type="text/javascript" src="../_static/init.js"></script> </body> </html>