PageRenderTime 831ms CodeModel.GetById 51ms RepoModel.GetById 1ms app.codeStats 1ms

/SQLAlchemy-0.7.8/doc/orm/inheritance.html

#
HTML | 752 lines | 675 code | 77 blank | 0 comment | 0 complexity | 8b05ee4e03b6544f02751f3d8ce6cf0f MD5 | raw file

Large files files are truncated, but you can click here to view the full file

    

  1. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    2. 

  2.   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    3. 

  3. 

  4. <html>
    5. 

  5.     <head>
    6. 

  6.         <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
    7. 

  7.         
    8. 

  8.         <title>
    9. 

  9.             
    10. 

  10.     
    11. 

  11.                 Mapping Class Inheritance Hierarchies
    12. 

  12.              &mdash; 
    13. 

  13.     SQLAlchemy 0.7 Documentation
    14. 

  14. 

  15.         </title>
    16. 

  16.         
    17. 

  17.     <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
    18. 

  18.     <link rel="stylesheet" href="../_static/docs.css" type="text/css" />
    19. 

  19. 

  20.     <script type="text/javascript">
    21. 

  21.       var DOCUMENTATION_OPTIONS = {
    22. 

  22.           URL_ROOT:    '../',
    23. 

  23.           VERSION:     '0.7.8',
    24. 

  24.           COLLAPSE_MODINDEX: false,
    25. 

  25.           FILE_SUFFIX: '.html'
    26. 

  26.       };
    27. 

  27.     </script>
    28. 

  28.         <script type="text/javascript" src="../_static/jquery.js"></script>
    29. 

  29.         <script type="text/javascript" src="../_static/underscore.js"></script>
    30. 

  30.         <script type="text/javascript" src="../_static/doctools.js"></script>
    31. 

  31.     <script type="text/javascript" src="../_static/init.js"></script>
    32. 

  32.     <link rel="index" title="Index" href="../genindex.html" />
    33. 

  33.     <link rel="search" title="Search" href="../search.html" />
    34. 

  34.         <link rel="copyright" title="Copyright" href="../copyright.html" />
    35. 

  35.     <link rel="top" title="SQLAlchemy 0.7 Documentation" href="../index.html" />
    36. 

  36.         <link rel="up" title="SQLAlchemy ORM" href="index.html" />
    37. 

  37.         <link rel="next" title="Using the Session" href="session.html" />
    38. 

  38.         <link rel="prev" title="Collection Configuration and Techniques" href="collections.html" />
    39. 

  39. 

  40.     </head>
    41. 

  41.     <body>
    42. 

  42.         
    43. 

  43. 

  44. 

  45. 

  46. 

  47. 

  48. 

  49. 

  50. 

  51. 

  52. 

  53. <div id="docs-container">
    54. 

  54. 

  55. 

  56. 

  57. <div id="docs-header">
    58. 

  58.     <h1>SQLAlchemy 0.7 Documentation</h1>
    59. 

  59. 

  60.     <div id="docs-search">
    61. 

  61.     Search:
    62. 

  62.     <form class="search" action="../search.html" method="get">
    63. 

  63.       <input type="text" name="q" size="18" /> <input type="submit" value="Search" />
    64. 

  64.       <input type="hidden" name="check_keywords" value="yes" />
    65. 

  65.       <input type="hidden" name="area" value="default" />
    66. 

  66.     </form>
    67. 

  67.     </div>
    68. 

  68. 

  69.     <div id="docs-version-header">
    70. 

  70.         Release: <span class="version-num">0.7.8</span> | Release Date: June 16, 2012
    71. 

  71. 

  72. 

  73.     </div>
    74. 

  74. 

  75. </div>
    76. 

  76. 

  77. <div id="docs-top-navigation">
    78. 

  78.     <div id="docs-top-page-control" class="docs-navigation-links">
    79. 

  79.         <ul>
    80. 

  80.             <li>Prev:
    81. 

  81.             <a href="collections.html" title="previous chapter">Collection Configuration and Techniques</a>
    82. 

  82.             </li>
    83. 

  83.             <li>Next:
    84. 

  84.             <a href="session.html" title="next chapter">Using the Session</a>
    85. 

  85.             </li>
    86. 

  86. 

  87.         <li>
    88. 

  88.             <a href="../contents.html">Table of Contents</a> |
    89. 

  89.             <a href="../genindex.html">Index</a>
    90. 

  90.             | <a href="../_sources/orm/inheritance.txt">view source
    91. 

  91.         </li>
    92. 

  92.         </ul>
    93. 

  93.     </div>
    94. 

  94. 

  95.     <div id="docs-navigation-banner">
    96. 

  96.         <a href="../index.html">SQLAlchemy 0.7 Documentation</a>
    97. 

  97.                 ť <a href="index.html" title="SQLAlchemy ORM">SQLAlchemy ORM</a>
    98. 

  98.         ť 
    99. 

  99.                 Mapping Class Inheritance Hierarchies
    100. 

  100.              
    101. 

  101. 

  102.         <h2>
    103. 

  103.             
    104. 

  104.                 Mapping Class Inheritance Hierarchies
    105. 

  105.             
    106. 

  106.         </h2>
    107. 

  107.     </div>
    108. 

  108. 

  109. </div>
    110. 

  110. 

  111. <div id="docs-body-container">
    112. 

  112. 

  113.     <div id="docs-sidebar">
    114. 

  114.     <h3><a href="../index.html">Table of Contents</a></h3>
    115. 

  115.     <ul>
    116. 

  116. <li><a class="reference internal" href="#">Mapping Class Inheritance Hierarchies</a><ul>
    117. 

  117. <li><a class="reference internal" href="#joined-table-inheritance">Joined Table Inheritance</a><ul>
    118. 

  118. <li><a class="reference internal" href="#basic-control-of-which-tables-are-queried">Basic Control of Which Tables are Queried</a></li>
    119. 

  119. <li><a class="reference internal" href="#advanced-control-of-which-tables-are-queried">Advanced Control of Which Tables are Queried</a></li>
    120. 

  120. <li><a class="reference internal" href="#creating-joins-to-specific-subtypes">Creating Joins to Specific Subtypes</a></li>
    121. 

  121. </ul>
    122. 

  122. </li>
    123. 

  123. <li><a class="reference internal" href="#single-table-inheritance">Single Table Inheritance</a></li>
    124. 

  124. <li><a class="reference internal" href="#concrete-table-inheritance">Concrete Table Inheritance</a><ul>
    125. 

  125. <li><a class="reference internal" href="#concrete-inheritance-with-declarative">Concrete Inheritance with Declarative</a></li>
    126. 

  126. </ul>
    127. 

  127. </li>
    128. 

  128. <li><a class="reference internal" href="#using-relationships-with-inheritance">Using Relationships with Inheritance</a><ul>
    129. 

  129. <li><a class="reference internal" href="#relationships-with-concrete-inheritance">Relationships with Concrete Inheritance</a></li>
    130. 

  130. </ul>
    131. 

  131. </li>
    132. 

  132. <li><a class="reference internal" href="#using-inheritance-with-declarative">Using Inheritance with Declarative</a></li>
    133. 

  133. </ul>
    134. 

  134. </li>
    135. 

  135. </ul>
    136. 

  136. 

  137. 

  138.     <h4>Previous Topic</h4>
    139. 

  139.     <p>
    140. 

  140.     <a href="collections.html" title="previous chapter">Collection Configuration and Techniques</a>
    141. 

  141.     </p>
    142. 

  142.     <h4>Next Topic</h4>
    143. 

  143.     <p>
    144. 

  144.     <a href="session.html" title="next chapter">Using the Session</a>
    145. 

  145.     </p>
    146. 

  146. 

  147. 

  148.     <h4>Quick Search</h4>
    149. 

  149.     <p>
    150. 

  150.     <form class="search" action="../search.html" method="get">
    151. 

  151.       <input type="text" name="q" size="18" /> <input type="submit" value="Search" />
    152. 

  152.       <input type="hidden" name="check_keywords" value="yes" />
    153. 

  153.       <input type="hidden" name="area" value="default" />
    154. 

  154.     </form>
    155. 

  155.     </p>
    156. 

  156. 

  157.     </div>
    158. 

  158. 

  159.     <div id="docs-body" class="withsidebar" >
    160. 

  160.         
    161. 

  161. <div class="section" id="mapping-class-inheritance-hierarchies">
    162. 

  162. <span id="inheritance-toplevel"></span><h1>Mapping Class Inheritance Hierarchies<a class="headerlink" href="#mapping-class-inheritance-hierarchies" title="Permalink to this headline">ś</a></h1>
    163. 

  163. <p>SQLAlchemy supports three forms of inheritance: <em>single table inheritance</em>,
    164. 

  164. where several types of classes are stored in one table, <em>concrete table
    165. 

  165. inheritance</em>, where each type of class is stored in its own table, and <em>joined
    166. 

  166. table inheritance</em>, where the parent/child classes are stored in their own
    167. 

  167. tables that are joined together in a select. Whereas support for single and
    168. 

  168. joined table inheritance is strong, concrete table inheritance is a less
    169. 

  169. common scenario with some particular problems so is not quite as flexible.</p>
    170. 

  170. <p>When mappers are configured in an inheritance relationship, SQLAlchemy has the
    171. 

  171. ability to load elements &#8220;polymorphically&#8221;, meaning that a single query can
    172. 

  172. return objects of multiple types.</p>
    173. 

  173. <div class="admonition note">
    174. 

  174. <p class="first admonition-title">Note</p>
    175. 

  175. <p class="last">This section currently uses classical mappings to illustrate inheritance
    176. 

  176. configurations, and will soon be updated to standardize on Declarative.
    177. 

  177. Until then, please refer to <a class="reference internal" href="extensions/declarative.html#declarative-inheritance"><em>Inheritance Configuration</em></a> for information on
    178. 

  178. how common inheritance mappings are constructed declaratively.</p>
    179. 

  179. </div>
    180. 

  180. <p>For the following sections, assume this class relationship:</p>
    181. 

  181. <div class="highlight-python+sql"><div class="highlight"><pre><span class="k">class</span> <span class="nc">Employee</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
    182. 

  182.     <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">):</span>
    183. 

  183.         <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
    184. 

  184.     <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
    185. 

  185.         <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">name</span>
    186. 

  186. 

  187. <span class="k">class</span> <span class="nc">Manager</span><span class="p">(</span><span class="n">Employee</span><span class="p">):</span>
    188. 

  188.     <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">manager_data</span><span class="p">):</span>
    189. 

  189.         <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
    190. 

  190.         <span class="bp">self</span><span class="o">.</span><span class="n">manager_data</span> <span class="o">=</span> <span class="n">manager_data</span>
    191. 

  191.     <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
    192. 

  192.         <span class="k">return</span> <span class="p">(</span>
    193. 

  193.             <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span>
    194. 

  194.             <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span>  <span class="bp">self</span><span class="o">.</span><span class="n">manager_data</span>
    195. 

  195.         <span class="p">)</span>
    196. 

  196. 

  197. <span class="k">class</span> <span class="nc">Engineer</span><span class="p">(</span><span class="n">Employee</span><span class="p">):</span>
    198. 

  198.     <span class="k">def</span> <span class="nf">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">name</span><span class="p">,</span> <span class="n">engineer_info</span><span class="p">):</span>
    199. 

  199.         <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">=</span> <span class="n">name</span>
    200. 

  200.         <span class="bp">self</span><span class="o">.</span><span class="n">engineer_info</span> <span class="o">=</span> <span class="n">engineer_info</span>
    201. 

  201.     <span class="k">def</span> <span class="nf">__repr__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
    202. 

  202.         <span class="k">return</span> <span class="p">(</span>
    203. 

  203.             <span class="bp">self</span><span class="o">.</span><span class="n">__class__</span><span class="o">.</span><span class="n">__name__</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span>
    204. 

  204.             <span class="bp">self</span><span class="o">.</span><span class="n">name</span> <span class="o">+</span> <span class="s">&quot; &quot;</span> <span class="o">+</span>  <span class="bp">self</span><span class="o">.</span><span class="n">engineer_info</span>
    205. 

  205.         <span class="p">)</span></pre></div>
    206. 

  206. </div>
    207. 

  207. <div class="section" id="joined-table-inheritance">
    208. 

  208. <h2>Joined Table Inheritance<a class="headerlink" href="#joined-table-inheritance" title="Permalink to this headline">ś</a></h2>
    209. 

  209. <p>In joined table inheritance, each class along a particular classes&#8217; list of
    210. 

  210. parents is represented by a unique table. The total set of attributes for a
    211. 

  211. particular instance is represented as a join along all tables in its
    212. 

  212. inheritance path. Here, we first define a table to represent the <tt class="docutils literal"><span class="pre">Employee</span></tt>
    213. 

  213. class. This table will contain a primary key column (or columns), and a column
    214. 

  214. for each attribute that&#8217;s represented by <tt class="docutils literal"><span class="pre">Employee</span></tt>. In this case it&#8217;s just
    215. 

  215. <tt class="docutils literal"><span class="pre">name</span></tt>:</p>
    216. 

  216. <div class="highlight-python"><div class="highlight"><pre><span class="n">employees</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s">&#39;employees&#39;</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span>
    217. 

  217.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;employee_id&#39;</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>
    218. 

  218.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;name&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">)),</span>
    219. 

  219.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;type&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">30</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">)</span>
    220. 

  220. <span class="p">)</span></pre></div>
    221. 

  221. </div>
    222. 

  222. <p>The table also has a column called <tt class="docutils literal"><span class="pre">type</span></tt>. It is strongly advised in both
    223. 

  223. single- and joined- table inheritance scenarios that the root table contains a
    224. 

  224. column whose sole purpose is that of the <strong>discriminator</strong>; it stores a value
    225. 

  225. which indicates the type of object represented within the row. The column may
    226. 

  226. be of any desired datatype. While there are some &#8220;tricks&#8221; to work around the
    227. 

  227. requirement that there be a discriminator column, they are more complicated to
    228. 

  228. configure when one wishes to load polymorphically.</p>
    229. 

  229. <p>Next we define individual tables for each of <tt class="docutils literal"><span class="pre">Engineer</span></tt> and <tt class="docutils literal"><span class="pre">Manager</span></tt>,
    230. 

  230. which contain columns that represent the attributes unique to the subclass
    231. 

  231. they represent. Each table also must contain a primary key column (or
    232. 

  232. columns), and in most cases a foreign key reference to the parent table. It is
    233. 

  233. standard practice that the same column is used for both of these roles, and
    234. 

  234. that the column is also named the same as that of the parent table. However
    235. 

  235. this is optional in SQLAlchemy; separate columns may be used for primary key
    236. 

  236. and parent-relationship, the column may be named differently than that of the
    237. 

  237. parent, and even a custom join condition can be specified between parent and
    238. 

  238. child tables instead of using a foreign key:</p>
    239. 

  239. <div class="highlight-python"><div class="highlight"><pre><span class="n">engineers</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s">&#39;engineers&#39;</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span>
    240. 

  240.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;employee_id&#39;</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span>
    241. 

  241.                     <span class="n">ForeignKey</span><span class="p">(</span><span class="s">&#39;employees.employee_id&#39;</span><span class="p">),</span>
    242. 

  242.                     <span class="n">primary_key</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
    243. 

  243.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;engineer_info&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">)),</span>
    244. 

  244. <span class="p">)</span>
    245. 

  245. 

  246. <span class="n">managers</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s">&#39;managers&#39;</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span>
    247. 

  247.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;employee_id&#39;</span><span class="p">,</span> <span class="n">Integer</span><span class="p">,</span>
    248. 

  248.                     <span class="n">ForeignKey</span><span class="p">(</span><span class="s">&#39;employees.employee_id&#39;</span><span class="p">),</span>
    249. 

  249.                     <span class="n">primary_key</span><span class="o">=</span><span class="bp">True</span><span class="p">),</span>
    250. 

  250.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;manager_data&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">)),</span>
    251. 

  251. <span class="p">)</span></pre></div>
    252. 

  252. </div>
    253. 

  253. <p>One natural effect of the joined table inheritance configuration is that the
    254. 

  254. identity of any mapped object can be determined entirely from the base table.
    255. 

  255. This has obvious advantages, so SQLAlchemy always considers the primary key
    256. 

  256. columns of a joined inheritance class to be those of the base table only,
    257. 

  257. unless otherwise manually configured. In other words, the <tt class="docutils literal"><span class="pre">employee_id</span></tt>
    258. 

  258. column of both the <tt class="docutils literal"><span class="pre">engineers</span></tt> and <tt class="docutils literal"><span class="pre">managers</span></tt> table is not used to locate
    259. 

  259. the <tt class="docutils literal"><span class="pre">Engineer</span></tt> or <tt class="docutils literal"><span class="pre">Manager</span></tt> object itself - only the value in
    260. 

  260. <tt class="docutils literal"><span class="pre">employees.employee_id</span></tt> is considered, and the primary key in this case is
    261. 

  261. non-composite. <tt class="docutils literal"><span class="pre">engineers.employee_id</span></tt> and <tt class="docutils literal"><span class="pre">managers.employee_id</span></tt> are
    262. 

  262. still of course critical to the proper operation of the pattern overall as
    263. 

  263. they are used to locate the joined row, once the parent row has been
    264. 

  264. determined, either through a distinct SELECT statement or all at once within a
    265. 

  265. JOIN.</p>
    266. 

  266. <p>We then configure mappers as usual, except we use some additional arguments to
    267. 

  267. indicate the inheritance relationship, the polymorphic discriminator column,
    268. 

  268. and the <strong>polymorphic identity</strong> of each class; this is the value that will be
    269. 

  269. stored in the polymorphic discriminator column.</p>
    270. 

  270. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">mapper</span><span class="p">(</span><span class="n">Employee</span><span class="p">,</span> <span class="n">employees</span><span class="p">,</span> <span class="n">polymorphic_on</span><span class="o">=</span><span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">type</span><span class="p">,</span>
    271. 

  271.                             <span class="n">polymorphic_identity</span><span class="o">=</span><span class="s">&#39;employee&#39;</span><span class="p">)</span>
    272. 

  272. <span class="n">mapper</span><span class="p">(</span><span class="n">Engineer</span><span class="p">,</span> <span class="n">engineers</span><span class="p">,</span> <span class="n">inherits</span><span class="o">=</span><span class="n">Employee</span><span class="p">,</span>
    273. 

  273.                             <span class="n">polymorphic_identity</span><span class="o">=</span><span class="s">&#39;engineer&#39;</span><span class="p">)</span>
    274. 

  274. <span class="n">mapper</span><span class="p">(</span><span class="n">Manager</span><span class="p">,</span> <span class="n">managers</span><span class="p">,</span> <span class="n">inherits</span><span class="o">=</span><span class="n">Employee</span><span class="p">,</span>
    275. 

  275.                             <span class="n">polymorphic_identity</span><span class="o">=</span><span class="s">&#39;manager&#39;</span><span class="p">)</span></pre></div>
    276. 

  276. </div>
    277. 

  277. <p>And that&#8217;s it. Querying against <tt class="docutils literal"><span class="pre">Employee</span></tt> will return a combination of
    278. 

  278. <tt class="docutils literal"><span class="pre">Employee</span></tt>, <tt class="docutils literal"><span class="pre">Engineer</span></tt> and <tt class="docutils literal"><span class="pre">Manager</span></tt> objects. Newly saved <tt class="docutils literal"><span class="pre">Engineer</span></tt>,
    279. 

  279. <tt class="docutils literal"><span class="pre">Manager</span></tt>, and <tt class="docutils literal"><span class="pre">Employee</span></tt> objects will automatically populate the
    280. 

  280. <tt class="docutils literal"><span class="pre">employees.type</span></tt> column with <tt class="docutils literal"><span class="pre">engineer</span></tt>, <tt class="docutils literal"><span class="pre">manager</span></tt>, or <tt class="docutils literal"><span class="pre">employee</span></tt>, as
    281. 

  281. appropriate.</p>
    282. 

  282. <div class="section" id="basic-control-of-which-tables-are-queried">
    283. 

  283. <span id="with-polymorphic"></span><h3>Basic Control of Which Tables are Queried<a class="headerlink" href="#basic-control-of-which-tables-are-queried" title="Permalink to this headline">ś</a></h3>
    284. 

  284. <p>The <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.with_polymorphic" title="sqlalchemy.orm.query.Query.with_polymorphic"><tt class="xref py py-func docutils literal"><span class="pre">with_polymorphic()</span></tt></a> method of
    285. 

  285. <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query" title="sqlalchemy.orm.query.Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> affects the specific subclass tables
    286. 

  286. which the Query selects from. Normally, a query such as this:</p>
    287. 

  287. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Employee</span><span class="p">)</span><span class="o">.</span><span class="n">all</span><span class="p">()</span></pre></div>
    288. 

  288. </div>
    289. 

  289. <p>...selects only from the <tt class="docutils literal"><span class="pre">employees</span></tt> table. When loading fresh from the
    290. 

  290. database, our joined-table setup will query from the parent table only, using
    291. 

  291. SQL such as this:</p>
    292. 

  292. <div class="highlight-python+sql"><div class="highlight"><pre><div class='show_sql'>
    293. 

  293. SELECT employees.employee_id AS employees_employee_id,
    294. 

  294.     employees.name AS employees_name, employees.type AS employees_type
    295. 

  295. FROM employees
    296. 

  296. []</div></pre></div>
    297. 

  297. </div>
    298. 

  298. <p>As attributes are requested from those <tt class="docutils literal"><span class="pre">Employee</span></tt> objects which are
    299. 

  299. represented in either the <tt class="docutils literal"><span class="pre">engineers</span></tt> or <tt class="docutils literal"><span class="pre">managers</span></tt> child tables, a second
    300. 

  300. load is issued for the columns in that related row, if the data was not
    301. 

  301. already loaded. So above, after accessing the objects you&#8217;d see further SQL
    302. 

  302. issued along the lines of:</p>
    303. 

  303. <div class="highlight-python+sql"><div class="highlight"><pre><div class='show_sql'>
    304. 

  304. SELECT managers.employee_id AS managers_employee_id,
    305. 

  305.     managers.manager_data AS managers_manager_data
    306. 

  306. FROM managers
    307. 

  307. WHERE ? = managers.employee_id
    308. 

  308. [5]
    309. 

  309. SELECT engineers.employee_id AS engineers_employee_id,
    310. 

  310.     engineers.engineer_info AS engineers_engineer_info
    311. 

  311. FROM engineers
    312. 

  312. WHERE ? = engineers.employee_id
    313. 

  313. [2]</div></pre></div>
    314. 

  314. </div>
    315. 

  315. <p>This behavior works well when issuing searches for small numbers of items,
    316. 

  316. such as when using <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.get" title="sqlalchemy.orm.query.Query.get"><tt class="xref py py-meth docutils literal"><span class="pre">Query.get()</span></tt></a>, since the full range of joined tables are not
    317. 

  317. pulled in to the SQL statement unnecessarily. But when querying a larger span
    318. 

  318. of rows which are known to be of many types, you may want to actively join to
    319. 

  319. some or all of the joined tables. The <tt class="docutils literal"><span class="pre">with_polymorphic</span></tt> feature of
    320. 

  320. <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query" title="sqlalchemy.orm.query.Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> and <tt class="docutils literal"><span class="pre">mapper</span></tt> provides this.</p>
    321. 

  321. <p>Telling our query to polymorphically load <tt class="docutils literal"><span class="pre">Engineer</span></tt> and <tt class="docutils literal"><span class="pre">Manager</span></tt>
    322. 

  322. objects:</p>
    323. 

  323. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">query</span> <span class="o">=</span> <span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Employee</span><span class="p">)</span><span class="o">.</span><span class="n">with_polymorphic</span><span class="p">([</span><span class="n">Engineer</span><span class="p">,</span> <span class="n">Manager</span><span class="p">])</span></pre></div>
    324. 

  324. </div>
    325. 

  325. <p>produces a query which joins the <tt class="docutils literal"><span class="pre">employees</span></tt> table to both the <tt class="docutils literal"><span class="pre">engineers</span></tt> and <tt class="docutils literal"><span class="pre">managers</span></tt> tables like the following:</p>
    326. 

  326. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">query</span><span class="o">.</span><span class="n">all</span><span class="p">()</span>
    327. 

  327. <div class='show_sql'>
    328. 

  328. SELECT employees.employee_id AS employees_employee_id,
    329. 

  329.     engineers.employee_id AS engineers_employee_id,
    330. 

  330.     managers.employee_id AS managers_employee_id,
    331. 

  331.     employees.name AS employees_name,
    332. 

  332.     employees.type AS employees_type,
    333. 

  333.     engineers.engineer_info AS engineers_engineer_info,
    334. 

  334.     managers.manager_data AS managers_manager_data
    335. 

  335. FROM employees
    336. 

  336.     LEFT OUTER JOIN engineers
    337. 

  337.     ON employees.employee_id = engineers.employee_id
    338. 

  338.     LEFT OUTER JOIN managers
    339. 

  339.     ON employees.employee_id = managers.employee_id
    340. 

  340. []</div></pre></div>
    341. 

  341. </div>
    342. 

  342. <p><a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.with_polymorphic" title="sqlalchemy.orm.query.Query.with_polymorphic"><tt class="xref py py-func docutils literal"><span class="pre">with_polymorphic()</span></tt></a> accepts a single class or
    343. 

  343. mapper, a list of classes/mappers, or the string <tt class="docutils literal"><span class="pre">'*'</span></tt> to indicate all
    344. 

  344. subclasses:</p>
    345. 

  345. <div class="highlight-python+sql"><div class="highlight"><pre><span class="c"># join to the engineers table</span>
    346. 

  346. <span class="n">query</span><span class="o">.</span><span class="n">with_polymorphic</span><span class="p">(</span><span class="n">Engineer</span><span class="p">)</span>
    347. 

  347. 

  348. <span class="c"># join to the engineers and managers tables</span>
    349. 

  349. <span class="n">query</span><span class="o">.</span><span class="n">with_polymorphic</span><span class="p">([</span><span class="n">Engineer</span><span class="p">,</span> <span class="n">Manager</span><span class="p">])</span>
    350. 

  350. 

  351. <span class="c"># join to all subclass tables</span>
    352. 

  352. <span class="n">query</span><span class="o">.</span><span class="n">with_polymorphic</span><span class="p">(</span><span class="s">&#39;*&#39;</span><span class="p">)</span></pre></div>
    353. 

  353. </div>
    354. 

  354. <p>It also accepts a second argument <tt class="docutils literal"><span class="pre">selectable</span></tt> which replaces the automatic
    355. 

  355. join creation and instead selects directly from the selectable given. This
    356. 

  356. feature is normally used with &#8220;concrete&#8221; inheritance, described later, but can
    357. 

  357. be used with any kind of inheritance setup in the case that specialized SQL
    358. 

  358. should be used to load polymorphically:</p>
    359. 

  359. <div class="highlight-python+sql"><div class="highlight"><pre><span class="c"># custom selectable</span>
    360. 

  360. <span class="n">query</span><span class="o">.</span><span class="n">with_polymorphic</span><span class="p">(</span>
    361. 

  361.             <span class="p">[</span><span class="n">Engineer</span><span class="p">,</span> <span class="n">Manager</span><span class="p">],</span>
    362. 

  362.             <span class="n">employees</span><span class="o">.</span><span class="n">outerjoin</span><span class="p">(</span><span class="n">managers</span><span class="p">)</span><span class="o">.</span><span class="n">outerjoin</span><span class="p">(</span><span class="n">engineers</span><span class="p">)</span>
    363. 

  363.         <span class="p">)</span></pre></div>
    364. 

  364. </div>
    365. 

  365. <p><a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.with_polymorphic" title="sqlalchemy.orm.query.Query.with_polymorphic"><tt class="xref py py-func docutils literal"><span class="pre">with_polymorphic()</span></tt></a> is also needed
    366. 

  366. when you wish to add filter criteria that are specific to one or more
    367. 

  367. subclasses; it makes the subclasses&#8217; columns available to the WHERE clause:</p>
    368. 

  368. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Employee</span><span class="p">)</span><span class="o">.</span><span class="n">with_polymorphic</span><span class="p">([</span><span class="n">Engineer</span><span class="p">,</span> <span class="n">Manager</span><span class="p">])</span><span class="o">.</span>\
    369. 

  369.     <span class="nb">filter</span><span class="p">(</span><span class="n">or_</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;w&#39;</span><span class="p">,</span> <span class="n">Manager</span><span class="o">.</span><span class="n">manager_data</span><span class="o">==</span><span class="s">&#39;q&#39;</span><span class="p">))</span></pre></div>
    370. 

  370. </div>
    371. 

  371. <p>Note that if you only need to load a single subtype, such as just the
    372. 

  372. <tt class="docutils literal"><span class="pre">Engineer</span></tt> objects, <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.with_polymorphic" title="sqlalchemy.orm.query.Query.with_polymorphic"><tt class="xref py py-func docutils literal"><span class="pre">with_polymorphic()</span></tt></a> is
    373. 

  373. not needed since you would query against the <tt class="docutils literal"><span class="pre">Engineer</span></tt> class directly.</p>
    374. 

  374. <p>The mapper also accepts <tt class="docutils literal"><span class="pre">with_polymorphic</span></tt> as a configurational argument so
    375. 

  375. that the joined-style load will be issued automatically. This argument may be
    376. 

  376. the string <tt class="docutils literal"><span class="pre">'*'</span></tt>, a list of classes, or a tuple consisting of either,
    377. 

  377. followed by a selectable.</p>
    378. 

  378. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">mapper</span><span class="p">(</span><span class="n">Employee</span><span class="p">,</span> <span class="n">employees</span><span class="p">,</span> <span class="n">polymorphic_on</span><span class="o">=</span><span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">type</span><span class="p">,</span>
    379. 

  379.                             <span class="n">polymorphic_identity</span><span class="o">=</span><span class="s">&#39;employee&#39;</span><span class="p">,</span>
    380. 

  380.                             <span class="n">with_polymorphic</span><span class="o">=</span><span class="s">&#39;*&#39;</span><span class="p">)</span>
    381. 

  381. <span class="n">mapper</span><span class="p">(</span><span class="n">Engineer</span><span class="p">,</span> <span class="n">engineers</span><span class="p">,</span> <span class="n">inherits</span><span class="o">=</span><span class="n">Employee</span><span class="p">,</span>
    382. 

  382.                             <span class="n">polymorphic_identity</span><span class="o">=</span><span class="s">&#39;engineer&#39;</span><span class="p">)</span>
    383. 

  383. <span class="n">mapper</span><span class="p">(</span><span class="n">Manager</span><span class="p">,</span> <span class="n">managers</span><span class="p">,</span> <span class="n">inherits</span><span class="o">=</span><span class="n">Employee</span><span class="p">,</span>
    384. 

  384.                             <span class="n">polymorphic_identity</span><span class="o">=</span><span class="s">&#39;manager&#39;</span><span class="p">)</span></pre></div>
    385. 

  385. </div>
    386. 

  386. <p>The above mapping will produce a query similar to that of
    387. 

  387. <tt class="docutils literal"><span class="pre">with_polymorphic('*')</span></tt> for every query of <tt class="docutils literal"><span class="pre">Employee</span></tt> objects.</p>
    388. 

  388. <p>Using <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.with_polymorphic" title="sqlalchemy.orm.query.Query.with_polymorphic"><tt class="xref py py-func docutils literal"><span class="pre">with_polymorphic()</span></tt></a> with
    389. 

  389. <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query" title="sqlalchemy.orm.query.Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> will override the mapper-level
    390. 

  390. <tt class="docutils literal"><span class="pre">with_polymorphic</span></tt> setting.</p>
    391. 

  391. </div>
    392. 

  392. <div class="section" id="advanced-control-of-which-tables-are-queried">
    393. 

  393. <h3>Advanced Control of Which Tables are Queried<a class="headerlink" href="#advanced-control-of-which-tables-are-queried" title="Permalink to this headline">ś</a></h3>
    394. 

  394. <p>The <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.with_polymorphic" title="sqlalchemy.orm.query.Query.with_polymorphic"><tt class="xref py py-meth docutils literal"><span class="pre">Query.with_polymorphic()</span></tt></a> method and configuration works fine for
    395. 

  395. simplistic scenarios. However, it currently does not work with any
    396. 

  396. <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query" title="sqlalchemy.orm.query.Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> that selects against individual columns or against multiple
    397. 

  397. classes - it also has to be called at the outset of a query.</p>
    398. 

  398. <p>For total control of how <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query" title="sqlalchemy.orm.query.Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> joins along inheritance relationships,
    399. 

  399. use the <a class="reference internal" href="../core/schema.html#sqlalchemy.schema.Table" title="sqlalchemy.schema.Table"><tt class="xref py py-class docutils literal"><span class="pre">Table</span></tt></a> objects directly and construct joins manually.  For example, to
    400. 

  400. query the name of employees with particular criterion:</p>
    401. 

  401. <div class="highlight-python"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Employee</span><span class="o">.</span><span class="n">name</span><span class="p">)</span><span class="o">.</span>\
    402. 

  402.     <span class="n">outerjoin</span><span class="p">((</span><span class="n">engineer</span><span class="p">,</span> <span class="n">engineer</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">Employee</span><span class="o">.</span><span class="n">employee_id</span><span class="p">))</span><span class="o">.</span>\
    403. 

  403.     <span class="n">outerjoin</span><span class="p">((</span><span class="n">manager</span><span class="p">,</span> <span class="n">manager</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">Employee</span><span class="o">.</span><span class="n">employee_id</span><span class="p">))</span><span class="o">.</span>\
    404. 

  404.     <span class="nb">filter</span><span class="p">(</span><span class="n">or_</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;w&#39;</span><span class="p">,</span> <span class="n">Manager</span><span class="o">.</span><span class="n">manager_data</span><span class="o">==</span><span class="s">&#39;q&#39;</span><span class="p">))</span></pre></div>
    405. 

  405. </div>
    406. 

  406. <p>The base table, in this case the &#8220;employees&#8221; table, isn&#8217;t always necessary. A
    407. 

  407. SQL query is always more efficient with fewer joins. Here, if we wanted to
    408. 

  408. just load information specific to managers or engineers, we can instruct
    409. 

  409. <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query" title="sqlalchemy.orm.query.Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> to use only those tables. The <tt class="docutils literal"><span class="pre">FROM</span></tt> clause is determined by
    410. 

  410. what&#8217;s specified in the <a class="reference internal" href="session.html#sqlalchemy.orm.session.Session.query" title="sqlalchemy.orm.session.Session.query"><tt class="xref py py-meth docutils literal"><span class="pre">Session.query()</span></tt></a>, <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.filter" title="sqlalchemy.orm.query.Query.filter"><tt class="xref py py-meth docutils literal"><span class="pre">Query.filter()</span></tt></a>, or
    411. 

  411. <a class="reference internal" href="query.html#sqlalchemy.orm.query.Query.select_from" title="sqlalchemy.orm.query.Query.select_from"><tt class="xref py py-meth docutils literal"><span class="pre">Query.select_from()</span></tt></a> methods:</p>
    412. 

  412. <div class="highlight-python"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Manager</span><span class="o">.</span><span class="n">manager_data</span><span class="p">)</span><span class="o">.</span><span class="n">select_from</span><span class="p">(</span><span class="n">manager</span><span class="p">)</span>
    413. 

  413. 

  414. <span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">engineer</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">id</span><span class="p">)</span><span class="o">.</span>\
    415. 

  415.         <span class="nb">filter</span><span class="p">(</span><span class="n">engineer</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="n">manager</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">manager_data</span><span class="p">)</span></pre></div>
    416. 

  416. </div>
    417. 

  417. </div>
    418. 

  418. <div class="section" id="creating-joins-to-specific-subtypes">
    419. 

  419. <h3>Creating Joins to Specific Subtypes<a class="headerlink" href="#creating-joins-to-specific-subtypes" title="Permalink to this headline">ś</a></h3>
    420. 

  420. <p>The <a class="reference internal" href="internals.html#sqlalchemy.orm.interfaces.PropComparator.of_type" title="sqlalchemy.orm.interfaces.PropComparator.of_type"><tt class="xref py py-func docutils literal"><span class="pre">of_type()</span></tt></a> method is a
    421. 

  421. helper which allows the construction of joins along
    422. 

  422. <a class="reference internal" href="relationships.html#sqlalchemy.orm.relationship" title="sqlalchemy.orm.relationship"><tt class="xref py py-func docutils literal"><span class="pre">relationship()</span></tt></a> paths while narrowing the criterion to
    423. 

  423. specific subclasses. Suppose the <tt class="docutils literal"><span class="pre">employees</span></tt> table represents a collection
    424. 

  424. of employees which are associated with a <tt class="docutils literal"><span class="pre">Company</span></tt> object. We&#8217;ll add a
    425. 

  425. <tt class="docutils literal"><span class="pre">company_id</span></tt> column to the <tt class="docutils literal"><span class="pre">employees</span></tt> table and a new table
    426. 

  426. <tt class="docutils literal"><span class="pre">companies</span></tt>:</p>
    427. 

  427. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">companies</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s">&#39;companies&#39;</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span>
    428. 

  428.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;company_id&#39;</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>
    429. 

  429.    <span class="n">Column</span><span class="p">(</span><span class="s">&#39;name&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">))</span>
    430. 

  430.    <span class="p">)</span>
    431. 

  431. 

  432. <span class="n">employees</span> <span class="o">=</span> <span class="n">Table</span><span class="p">(</span><span class="s">&#39;employees&#39;</span><span class="p">,</span> <span class="n">metadata</span><span class="p">,</span>
    433. 

  433.   <span class="n">Column</span><span class="p">(</span><span class="s">&#39;employee_id&#39;</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>
    434. 

  434.   <span class="n">Column</span><span class="p">(</span><span class="s">&#39;name&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">50</span><span class="p">)),</span>
    435. 

  435.   <span class="n">Column</span><span class="p">(</span><span class="s">&#39;type&#39;</span><span class="p">,</span> <span class="n">String</span><span class="p">(</span><span class="mi">30</span><span class="p">),</span> <span class="n">nullable</span><span class="o">=</span><span class="bp">False</span><span class="p">),</span>
    436. 

  436.   <span class="n">Column</span><span class="p">(</span><span class="s">&#39;company_id&#39;</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="s">&#39;companies.company_id&#39;</span><span class="p">))</span>
    437. 

  437. <span class="p">)</span>
    438. 

  438. 

  439. <span class="k">class</span> <span class="nc">Company</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
    440. 

  440.     <span class="k">pass</span>
    441. 

  441. 

  442. <span class="n">mapper</span><span class="p">(</span><span class="n">Company</span><span class="p">,</span> <span class="n">companies</span><span class="p">,</span> <span class="n">properties</span><span class="o">=</span><span class="p">{</span>
    443. 

  443.     <span class="s">&#39;employees&#39;</span><span class="p">:</span> <span class="n">relationship</span><span class="p">(</span><span class="n">Employee</span><span class="p">)</span>
    444. 

  444. <span class="p">})</span></pre></div>
    445. 

  445. </div>
    446. 

  446. <p>When querying from <tt class="docutils literal"><span class="pre">Company</span></tt> onto the <tt class="docutils literal"><span class="pre">Employee</span></tt> relationship, the
    447. 

  447. <tt class="docutils literal"><span class="pre">join()</span></tt> method as well as the <tt class="docutils literal"><span class="pre">any()</span></tt> and <tt class="docutils literal"><span class="pre">has()</span></tt> operators will create
    448. 

  448. a join from <tt class="docutils literal"><span class="pre">companies</span></tt> to <tt class="docutils literal"><span class="pre">employees</span></tt>, without including <tt class="docutils literal"><span class="pre">engineers</span></tt> or
    449. 

  449. <tt class="docutils literal"><span class="pre">managers</span></tt> in the mix. If we wish to have criterion which is specifically
    450. 

  450. against the <tt class="docutils literal"><span class="pre">Engineer</span></tt> class, we can tell those methods to join or subquery
    451. 

  451. against the joined table representing the subclass using the
    452. 

  452. <a class="reference internal" href="internals.html#sqlalchemy.orm.interfaces.PropComparator.of_type" title="sqlalchemy.orm.interfaces.PropComparator.of_type"><tt class="xref py py-func docutils literal"><span class="pre">of_type()</span></tt></a> operator:</p>
    453. 

  453. <div class="highlight-python"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Company</span><span class="p">)</span><span class="o">.</span>\
    454. 

  454.     <span class="n">join</span><span class="p">(</span><span class="n">Company</span><span class="o">.</span><span class="n">employees</span><span class="o">.</span><span class="n">of_type</span><span class="p">(</span><span class="n">Engineer</span><span class="p">))</span><span class="o">.</span>\
    455. 

  455.     <span class="nb">filter</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;someinfo&#39;</span><span class="p">)</span></pre></div>
    456. 

  456. </div>
    457. 

  457. <p>A longhand version of this would involve spelling out the full target
    458. 

  458. selectable within a 2-tuple:</p>
    459. 

  459. <div class="highlight-python"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Company</span><span class="p">)</span><span class="o">.</span>\
    460. 

  460.     <span class="n">join</span><span class="p">((</span><span class="n">employees</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">engineers</span><span class="p">),</span> <span class="n">Company</span><span class="o">.</span><span class="n">employees</span><span class="p">))</span><span class="o">.</span>\
    461. 

  461.     <span class="nb">filter</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;someinfo&#39;</span><span class="p">)</span></pre></div>
    462. 

  462. </div>
    463. 

  463. <p>Currently, <a class="reference internal" href="internals.html#sqlalchemy.orm.interfaces.PropComparator.of_type" title="sqlalchemy.orm.interfaces.PropComparator.of_type"><tt class="xref py py-func docutils literal"><span class="pre">of_type()</span></tt></a> accepts a
    464. 

  464. single class argument. It may be expanded later on to accept multiple classes.
    465. 

  465. For now, to join to any group of subclasses, the longhand notation allows this
    466. 

  466. flexibility:</p>
    467. 

  467. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Company</span><span class="p">)</span><span class="o">.</span>\
    468. 

  468.     <span class="n">join</span><span class="p">(</span>
    469. 

  469.         <span class="p">(</span><span class="n">employees</span><span class="o">.</span><span class="n">outerjoin</span><span class="p">(</span><span class="n">engineers</span><span class="p">)</span><span class="o">.</span><span class="n">outerjoin</span><span class="p">(</span><span class="n">managers</span><span class="p">),</span>
    470. 

  470.         <span class="n">Company</span><span class="o">.</span><span class="n">employees</span><span class="p">)</span>
    471. 

  471.     <span class="p">)</span><span class="o">.</span>\
    472. 

  472.     <span class="nb">filter</span><span class="p">(</span>
    473. 

  473.         <span class="n">or_</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;someinfo&#39;</span><span class="p">,</span>
    474. 

  474.             <span class="n">Manager</span><span class="o">.</span><span class="n">manager_data</span><span class="o">==</span><span class="s">&#39;somedata&#39;</span><span class="p">)</span>
    475. 

  475.     <span class="p">)</span></pre></div>
    476. 

  476. </div>
    477. 

  477. <p>The <tt class="docutils literal"><span class="pre">any()</span></tt> and <tt class="docutils literal"><span class="pre">has()</span></tt> operators also can be used with
    478. 

  478. <a class="reference internal" href="internals.html#sqlalchemy.orm.interfaces.PropComparator.of_type" title="sqlalchemy.orm.interfaces.PropComparator.of_type"><tt class="xref py py-func docutils literal"><span class="pre">of_type()</span></tt></a> when the embedded
    479. 

  479. criterion is in terms of a subclass:</p>
    480. 

  480. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Company</span><span class="p">)</span><span class="o">.</span>\
    481. 

  481.         <span class="nb">filter</span><span class="p">(</span>
    482. 

  482.             <span class="n">Company</span><span class="o">.</span><span class="n">employees</span><span class="o">.</span><span class="n">of_type</span><span class="p">(</span><span class="n">Engineer</span><span class="p">)</span><span class="o">.</span>
    483. 

  483.                 <span class="nb">any</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;someinfo&#39;</span><span class="p">)</span>
    484. 

  484.             <span class="p">)</span><span class="o">.</span><span class="n">all</span><span class="p">()</span></pre></div>
    485. 

  485. </div>
    486. 

  486. <p>Note that the <tt class="docutils literal"><span class="pre">any()</span></tt> and <tt class="docutils literal"><span class="pre">has()</span></tt> are both shorthand for a correlated
    487. 

  487. EXISTS query. To build one by hand looks like:</p>
    488. 

  488. <div class="highlight-python+sql"><div class="highlight"><pre><span class="n">session</span><span class="o">.</span><span class="n">query</span><span class="p">(</span><span class="n">Company</span><span class="p">)</span><span class="o">.</span><span class="n">filter</span><span class="p">(</span>
    489. 

  489.     <span class="n">exists</span><span class="p">([</span><span class="mi">1</span><span class="p">],</span>
    490. 

  490.         <span class="n">and_</span><span class="p">(</span><span class="n">Engineer</span><span class="o">.</span><span class="n">engineer_info</span><span class="o">==</span><span class="s">&#39;someinfo&#39;</span><span class="p">,</span>
    491. 

  491.             <span class="n">employees</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">company_id</span><span class="o">==</span><span class="n">companies</span><span class="o">.</span><span class="n">c</span><span class="o">.</span><span class="n">company_id</span><span class="p">),</span>
    492. 

  492.         <span class="n">from_obj</span><span class="o">=</span><span class="n">em…
    493.

Large files files are truncated, but you can click here to view the full file