codekingpro/portable-devtools
115k
1<?xml version="1.0" encoding="UTF-8" standalone="no"?>2<!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>8.16. Composite Types</title><link rel="stylesheet" type="text/css" href="stylesheet.css" /><link rev="made" href="pgsql-docs@lists.postgresql.org" /><meta name="generator" content="DocBook XSL Stylesheets Vsnapshot" /><link rel="prev" href="arrays.html" title="8.15. Arrays" /><link rel="next" href="rangetypes.html" title="8.17. Range Types" /></head><body id="docContent" class="container-fluid col-10"><div class="navheader"><table width="100%" summary="Navigation header"><tr><th colspan="5" align="center">8.16. Composite Types</th></tr><tr><td width="10%" align="left"><a accesskey="p" href="arrays.html" title="8.15. Arrays">Prev</a> </td><td width="10%" align="left"><a accesskey="u" href="datatype.html" title="Chapter 8. Data Types">Up</a></td><th width="60%" align="center">Chapter 8. Data Types</th><td width="10%" align="right"><a accesskey="h" href="index.html" title="PostgreSQL 16.3 Documentation">Home</a></td><td width="10%" align="right"> <a accesskey="n" href="rangetypes.html" title="8.17. Range Types">Next</a></td></tr></table><hr /></div><div class="sect1" id="ROWTYPES"><div class="titlepage"><div><div><h2 class="title" style="clear: both">8.16. Composite Types <a href="#ROWTYPES" class="id_link">#</a></h2></div></div></div><div class="toc"><dl class="toc"><dt><span class="sect2"><a href="rowtypes.html#ROWTYPES-DECLARING">8.16.1. Declaration of Composite Types</a></span></dt><dt><span class="sect2"><a href="rowtypes.html#ROWTYPES-CONSTRUCTING">8.16.2. Constructing Composite Values</a></span></dt><dt><span class="sect2"><a href="rowtypes.html#ROWTYPES-ACCESSING">8.16.3. Accessing Composite Types</a></span></dt><dt><span class="sect2"><a href="rowtypes.html#ROWTYPES-MODIFYING">8.16.4. Modifying Composite Types</a></span></dt><dt><span class="sect2"><a href="rowtypes.html#ROWTYPES-USAGE">8.16.5. Using Composite Types in Queries</a></span></dt><dt><span class="sect2"><a href="rowtypes.html#ROWTYPES-IO-SYNTAX">8.16.6. Composite Type Input and Output Syntax</a></span></dt></dl></div><a id="id-1.5.7.24.2" class="indexterm"></a><a id="id-1.5.7.24.3" class="indexterm"></a><p>3 A <em class="firstterm">composite type</em> represents the structure of a row or record;4 it is essentially just a list of field names and their data types.5 <span class="productname">PostgreSQL</span> allows composite types to be6 used in many of the same ways that simple types can be used. For example, a7 column of a table can be declared to be of a composite type.8 </p><div class="sect2" id="ROWTYPES-DECLARING"><div class="titlepage"><div><div><h3 class="title">8.16.1. Declaration of Composite Types <a href="#ROWTYPES-DECLARING" class="id_link">#</a></h3></div></div></div><p>9 Here are two simple examples of defining composite types:10</p><pre class="programlisting">11CREATE TYPE complex AS (12 r double precision,13 i double precision14);15 16CREATE TYPE inventory_item AS (17 name text,18 supplier_id integer,19 price numeric20);21</pre><p>22 The syntax is comparable to <code class="command">CREATE TABLE</code>, except that only23 field names and types can be specified; no constraints (such as <code class="literal">NOT24 NULL</code>) can presently be included. Note that the <code class="literal">AS</code> keyword25 is essential; without it, the system will think a different kind26 of <code class="command">CREATE TYPE</code> command is meant, and you will get odd syntax27 errors.28 </p><p>29 Having defined the types, we can use them to create tables:30 31</p><pre class="programlisting">32CREATE TABLE on_hand (33 item inventory_item,34 count integer35);36 37INSERT INTO on_hand VALUES (ROW('fuzzy dice', 42, 1.99), 1000);38</pre><p>39 40 or functions:41 42</p><pre class="programlisting">43CREATE FUNCTION price_extension(inventory_item, integer) RETURNS numeric44AS 'SELECT $1.price * $2' LANGUAGE SQL;45 46SELECT price_extension(item, 10) FROM on_hand;47</pre><p>48 49 </p><p>50 Whenever you create a table, a composite type is also automatically51 created, with the same name as the table, to represent the table's52 row type. For example, had we said:53</p><pre class="programlisting">54CREATE TABLE inventory_item (55 name text,56 supplier_id integer REFERENCES suppliers,57 price numeric CHECK (price > 0)58);59</pre><p>60 then the same <code class="literal">inventory_item</code> composite type shown above would61 come into being as a62 byproduct, and could be used just as above. Note however an important63 restriction of the current implementation: since no constraints are64 associated with a composite type, the constraints shown in the table65 definition <span class="emphasis"><em>do not apply</em></span> to values of the composite type66 outside the table. (To work around this, create a67 <a class="glossterm" href="glossary.html#GLOSSARY-DOMAIN"><em class="glossterm"><a class="glossterm" href="glossary.html#GLOSSARY-DOMAIN" title="Domain">domain</a></em></a> over the composite68 type, and apply the desired constraints as <code class="literal">CHECK</code>69 constraints of the domain.)70 </p></div><div class="sect2" id="ROWTYPES-CONSTRUCTING"><div class="titlepage"><div><div><h3 class="title">8.16.2. Constructing Composite Values <a href="#ROWTYPES-CONSTRUCTING" class="id_link">#</a></h3></div></div></div><a id="id-1.5.7.24.6.2" class="indexterm"></a><p>71 To write a composite value as a literal constant, enclose the field72 values within parentheses and separate them by commas. You can put double73 quotes around any field value, and must do so if it contains commas or74 parentheses. (More details appear <a class="link" href="rowtypes.html#ROWTYPES-IO-SYNTAX" title="8.16.6. Composite Type Input and Output Syntax">below</a>.) Thus, the general format of75 a composite constant is the following:76</p><pre class="synopsis">77'( <em class="replaceable"><code>val1</code></em> , <em class="replaceable"><code>val2</code></em> , ... )'78</pre><p>79 An example is:80</p><pre class="programlisting">81'("fuzzy dice",42,1.99)'82</pre><p>83 which would be a valid value of the <code class="literal">inventory_item</code> type84 defined above. To make a field be NULL, write no characters at all85 in its position in the list. For example, this constant specifies86 a NULL third field:87</p><pre class="programlisting">88'("fuzzy dice",42,)'89</pre><p>90 If you want an empty string rather than NULL, write double quotes:91</p><pre class="programlisting">92'("",42,)'93</pre><p>94 Here the first field is a non-NULL empty string, the third is NULL.95 </p><p>96 (These constants are actually only a special case of97 the generic type constants discussed in <a class="xref" href="sql-syntax-lexical.html#SQL-SYNTAX-CONSTANTS-GENERIC" title="4.1.2.7. Constants of Other Types">Section 4.1.2.7</a>. The constant is initially98 treated as a string and passed to the composite-type input conversion99 routine. An explicit type specification might be necessary to tell100 which type to convert the constant to.)101 </p><p>102 The <code class="literal">ROW</code> expression syntax can also be used to103 construct composite values. In most cases this is considerably104 simpler to use than the string-literal syntax since you don't have105 to worry about multiple layers of quoting. We already used this106 method above:107</p><pre class="programlisting">108ROW('fuzzy dice', 42, 1.99)109ROW('', 42, NULL)110</pre><p>111 The ROW keyword is actually optional as long as you have more than one112 field in the expression, so these can be simplified to:113</p><pre class="programlisting">114('fuzzy dice', 42, 1.99)115('', 42, NULL)116</pre><p>117 The <code class="literal">ROW</code> expression syntax is discussed in more detail in <a class="xref" href="sql-expressions.html#SQL-SYNTAX-ROW-CONSTRUCTORS" title="4.2.13. Row Constructors">Section 4.2.13</a>.118 </p></div><div class="sect2" id="ROWTYPES-ACCESSING"><div class="titlepage"><div><div><h3 class="title">8.16.3. Accessing Composite Types <a href="#ROWTYPES-ACCESSING" class="id_link">#</a></h3></div></div></div><p>119 To access a field of a composite column, one writes a dot and the field120 name, much like selecting a field from a table name. In fact, it's so121 much like selecting from a table name that you often have to use parentheses122 to keep from confusing the parser. For example, you might try to select123 some subfields from our <code class="literal">on_hand</code> example table with something124 like:125 126</p><pre class="programlisting">127SELECT item.name FROM on_hand WHERE item.price > 9.99;128</pre><p>129 130 This will not work since the name <code class="literal">item</code> is taken to be a table131 name, not a column name of <code class="literal">on_hand</code>, per SQL syntax rules.132 You must write it like this:133 134</p><pre class="programlisting">135SELECT (item).name FROM on_hand WHERE (item).price > 9.99;136</pre><p>137 138 or if you need to use the table name as well (for instance in a multitable139 query), like this:140 141</p><pre class="programlisting">142SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;143</pre><p>144 145 Now the parenthesized object is correctly interpreted as a reference to146 the <code class="literal">item</code> column, and then the subfield can be selected from it.147 </p><p>148 Similar syntactic issues apply whenever you select a field from a composite149 value. For instance, to select just one field from the result of a function150 that returns a composite value, you'd need to write something like:151 152</p><pre class="programlisting">153SELECT (my_func(...)).field FROM ...154</pre><p>155 156 Without the extra parentheses, this will generate a syntax error.157 </p><p>158 The special field name <code class="literal">*</code> means <span class="quote">“<span class="quote">all fields</span>”</span>, as159 further explained in <a class="xref" href="rowtypes.html#ROWTYPES-USAGE" title="8.16.5. Using Composite Types in Queries">Section 8.16.5</a>.160 </p></div><div class="sect2" id="ROWTYPES-MODIFYING"><div class="titlepage"><div><div><h3 class="title">8.16.4. Modifying Composite Types <a href="#ROWTYPES-MODIFYING" class="id_link">#</a></h3></div></div></div><p>161 Here are some examples of the proper syntax for inserting and updating162 composite columns.163 First, inserting or updating a whole column:164 165</p><pre class="programlisting">166INSERT INTO mytab (complex_col) VALUES((1.1,2.2));167 168UPDATE mytab SET complex_col = ROW(1.1,2.2) WHERE ...;169</pre><p>170 171 The first example omits <code class="literal">ROW</code>, the second uses it; we172 could have done it either way.173 </p><p>174 We can update an individual subfield of a composite column:175 176</p><pre class="programlisting">177UPDATE mytab SET complex_col.r = (complex_col).r + 1 WHERE ...;178</pre><p>179 180 Notice here that we don't need to (and indeed cannot)181 put parentheses around the column name appearing just after182 <code class="literal">SET</code>, but we do need parentheses when referencing the same183 column in the expression to the right of the equal sign.184 </p><p>185 And we can specify subfields as targets for <code class="command">INSERT</code>, too:186 187</p><pre class="programlisting">188INSERT INTO mytab (complex_col.r, complex_col.i) VALUES(1.1, 2.2);189</pre><p>190 191 Had we not supplied values for all the subfields of the column, the192 remaining subfields would have been filled with null values.193 </p></div><div class="sect2" id="ROWTYPES-USAGE"><div class="titlepage"><div><div><h3 class="title">8.16.5. Using Composite Types in Queries <a href="#ROWTYPES-USAGE" class="id_link">#</a></h3></div></div></div><p>194 There are various special syntax rules and behaviors associated with195 composite types in queries. These rules provide useful shortcuts,196 but can be confusing if you don't know the logic behind them.197 </p><p>198 In <span class="productname">PostgreSQL</span>, a reference to a table name (or alias)199 in a query is effectively a reference to the composite value of the200 table's current row. For example, if we had a table201 <code class="structname">inventory_item</code> as shown202 <a class="link" href="rowtypes.html#ROWTYPES-DECLARING" title="8.16.1. Declaration of Composite Types">above</a>, we could write:203</p><pre class="programlisting">204SELECT c FROM inventory_item c;205</pre><p>206 This query produces a single composite-valued column, so we might get207 output like:208</p><pre class="programlisting">209 c210------------------------211 ("fuzzy dice",42,1.99)212(1 row)213</pre><p>214 Note however that simple names are matched to column names before table215 names, so this example works only because there is no column216 named <code class="structfield">c</code> in the query's tables.217 </p><p>218 The ordinary qualified-column-name219 syntax <em class="replaceable"><code>table_name</code></em><code class="literal">.</code><em class="replaceable"><code>column_name</code></em>220 can be understood as applying <a class="link" href="sql-expressions.html#FIELD-SELECTION" title="4.2.4. Field Selection">field221 selection</a> to the composite value of the table's current row.222 (For efficiency reasons, it's not actually implemented that way.)223 </p><p>224 When we write225</p><pre class="programlisting">226SELECT c.* FROM inventory_item c;227</pre><p>228 then, according to the SQL standard, we should get the contents of the229 table expanded into separate columns:230</p><pre class="programlisting">231 name | supplier_id | price232------------+-------------+-------233 fuzzy dice | 42 | 1.99234(1 row)235</pre><p>236 as if the query were237</p><pre class="programlisting">238SELECT c.name, c.supplier_id, c.price FROM inventory_item c;239</pre><p>240 <span class="productname">PostgreSQL</span> will apply this expansion behavior to241 any composite-valued expression, although as shown <a class="link" href="rowtypes.html#ROWTYPES-ACCESSING" title="8.16.3. Accessing Composite Types">above</a>, you need to write parentheses242 around the value that <code class="literal">.*</code> is applied to whenever it's not a243 simple table name. For example, if <code class="function">myfunc()</code> is a function244 returning a composite type with columns <code class="structfield">a</code>,245 <code class="structfield">b</code>, and <code class="structfield">c</code>, then these two queries have the246 same result:247</p><pre class="programlisting">248SELECT (myfunc(x)).* FROM some_table;249SELECT (myfunc(x)).a, (myfunc(x)).b, (myfunc(x)).c FROM some_table;250</pre><p>251 </p><div class="tip"><h3 class="title">Tip</h3><p>252 <span class="productname">PostgreSQL</span> handles column expansion by253 actually transforming the first form into the second. So, in this254 example, <code class="function">myfunc()</code> would get invoked three times per row255 with either syntax. If it's an expensive function you may wish to256 avoid that, which you can do with a query like:257</p><pre class="programlisting">258SELECT m.* FROM some_table, LATERAL myfunc(x) AS m;259</pre><p>260 Placing the function in261 a <code class="literal">LATERAL</code> <code class="literal">FROM</code> item keeps it from262 being invoked more than once per row. <code class="literal">m.*</code> is still263 expanded into <code class="literal">m.a, m.b, m.c</code>, but now those variables264 are just references to the output of the <code class="literal">FROM</code> item.265 (The <code class="literal">LATERAL</code> keyword is optional here, but we show it266 to clarify that the function is getting <code class="structfield">x</code>267 from <code class="structname">some_table</code>.)268 </p></div><p>269 The <em class="replaceable"><code>composite_value</code></em><code class="literal">.*</code> syntax results in270 column expansion of this kind when it appears at the top level of271 a <a class="link" href="queries-select-lists.html" title="7.3. Select Lists"><code class="command">SELECT</code> output272 list</a>, a <a class="link" href="dml-returning.html" title="6.4. Returning Data from Modified Rows"><code class="literal">RETURNING</code>273 list</a> in <code class="command">INSERT</code>/<code class="command">UPDATE</code>/<code class="command">DELETE</code>,274 a <a class="link" href="queries-values.html" title="7.7. VALUES Lists"><code class="literal">VALUES</code> clause</a>, or275 a <a class="link" href="sql-expressions.html#SQL-SYNTAX-ROW-CONSTRUCTORS" title="4.2.13. Row Constructors">row constructor</a>.276 In all other contexts (including when nested inside one of those277 constructs), attaching <code class="literal">.*</code> to a composite value does not278 change the value, since it means <span class="quote">“<span class="quote">all columns</span>”</span> and so the279 same composite value is produced again. For example,280 if <code class="function">somefunc()</code> accepts a composite-valued argument,281 these queries are the same:282 283</p><pre class="programlisting">284SELECT somefunc(c.*) FROM inventory_item c;285SELECT somefunc(c) FROM inventory_item c;286</pre><p>287 288 In both cases, the current row of <code class="structname">inventory_item</code> is289 passed to the function as a single composite-valued argument.290 Even though <code class="literal">.*</code> does nothing in such cases, using it is good291 style, since it makes clear that a composite value is intended. In292 particular, the parser will consider <code class="literal">c</code> in <code class="literal">c.*</code> to293 refer to a table name or alias, not to a column name, so that there is294 no ambiguity; whereas without <code class="literal">.*</code>, it is not clear295 whether <code class="literal">c</code> means a table name or a column name, and in fact296 the column-name interpretation will be preferred if there is a column297 named <code class="literal">c</code>.298 </p><p>299 Another example demonstrating these concepts is that all these queries300 mean the same thing:301</p><pre class="programlisting">302SELECT * FROM inventory_item c ORDER BY c;303SELECT * FROM inventory_item c ORDER BY c.*;304SELECT * FROM inventory_item c ORDER BY ROW(c.*);305</pre><p>306 All of these <code class="literal">ORDER BY</code> clauses specify the row's composite307 value, resulting in sorting the rows according to the rules described308 in <a class="xref" href="functions-comparisons.html#COMPOSITE-TYPE-COMPARISON" title="9.24.6. Composite Type Comparison">Section 9.24.6</a>. However,309 if <code class="structname">inventory_item</code> contained a column310 named <code class="structfield">c</code>, the first case would be different from the311 others, as it would mean to sort by that column only. Given the column312 names previously shown, these queries are also equivalent to those above:313</p><pre class="programlisting">314SELECT * FROM inventory_item c ORDER BY ROW(c.name, c.supplier_id, c.price);315SELECT * FROM inventory_item c ORDER BY (c.name, c.supplier_id, c.price);316</pre><p>317 (The last case uses a row constructor with the key word <code class="literal">ROW</code>318 omitted.)319 </p><p>320 Another special syntactical behavior associated with composite values is321 that we can use <em class="firstterm">functional notation</em> for extracting a field322 of a composite value. The simple way to explain this is that323 the notations <code class="literal"><em class="replaceable"><code>field</code></em>(<em class="replaceable"><code>table</code></em>)</code>324 and <code class="literal"><em class="replaceable"><code>table</code></em>.<em class="replaceable"><code>field</code></em></code>325 are interchangeable. For example, these queries are equivalent:326 327</p><pre class="programlisting">328SELECT c.name FROM inventory_item c WHERE c.price > 1000;329SELECT name(c) FROM inventory_item c WHERE price(c) > 1000;330</pre><p>331 332 Moreover, if we have a function that accepts a single argument of a333 composite type, we can call it with either notation. These queries are334 all equivalent:335 336</p><pre class="programlisting">337SELECT somefunc(c) FROM inventory_item c;338SELECT somefunc(c.*) FROM inventory_item c;339SELECT c.somefunc FROM inventory_item c;340</pre><p>341 </p><p>342 This equivalence between functional notation and field notation343 makes it possible to use functions on composite types to implement344 <span class="quote">“<span class="quote">computed fields</span>”</span>.345 <a id="id-1.5.7.24.9.10.2" class="indexterm"></a>346 <a id="id-1.5.7.24.9.10.3" class="indexterm"></a>347 An application using the last query above wouldn't need to be directly348 aware that <code class="literal">somefunc</code> isn't a real column of the table.349 </p><div class="tip"><h3 class="title">Tip</h3><p>350 Because of this behavior, it's unwise to give a function that takes a351 single composite-type argument the same name as any of the fields of352 that composite type. If there is ambiguity, the field-name353 interpretation will be chosen if field-name syntax is used, while the354 function will be chosen if function-call syntax is used. However,355 <span class="productname">PostgreSQL</span> versions before 11 always chose the356 field-name interpretation, unless the syntax of the call required it to357 be a function call. One way to force the function interpretation in358 older versions is to schema-qualify the function name, that is, write359 <code class="literal"><em class="replaceable"><code>schema</code></em>.<em class="replaceable"><code>func</code></em>(<em class="replaceable"><code>compositevalue</code></em>)</code>.360 </p></div></div><div class="sect2" id="ROWTYPES-IO-SYNTAX"><div class="titlepage"><div><div><h3 class="title">8.16.6. Composite Type Input and Output Syntax <a href="#ROWTYPES-IO-SYNTAX" class="id_link">#</a></h3></div></div></div><p>361 The external text representation of a composite value consists of items that362 are interpreted according to the I/O conversion rules for the individual363 field types, plus decoration that indicates the composite structure.364 The decoration consists of parentheses (<code class="literal">(</code> and <code class="literal">)</code>)365 around the whole value, plus commas (<code class="literal">,</code>) between adjacent366 items. Whitespace outside the parentheses is ignored, but within the367 parentheses it is considered part of the field value, and might or might not be368 significant depending on the input conversion rules for the field data type.369 For example, in:370</p><pre class="programlisting">371'( 42)'372</pre><p>373 the whitespace will be ignored if the field type is integer, but not if374 it is text.375 </p><p>376 As shown previously, when writing a composite value you can write double377 quotes around any individual field value.378 You <span class="emphasis"><em>must</em></span> do so if the field value would otherwise379 confuse the composite-value parser. In particular, fields containing380 parentheses, commas, double quotes, or backslashes must be double-quoted.381 To put a double quote or backslash in a quoted composite field value,382 precede it with a backslash. (Also, a pair of double quotes within a383 double-quoted field value is taken to represent a double quote character,384 analogously to the rules for single quotes in SQL literal strings.)385 Alternatively, you can avoid quoting and use backslash-escaping to386 protect all data characters387 that would otherwise be taken as composite syntax.388 </p><p>389 A completely empty field value (no characters at all between the commas390 or parentheses) represents a NULL. To write a value that is an empty391 string rather than NULL, write <code class="literal">""</code>.392 </p><p>393 The composite output routine will put double quotes around field values394 if they are empty strings or contain parentheses, commas,395 double quotes, backslashes, or white space. (Doing so for white space396 is not essential, but aids legibility.) Double quotes and backslashes397 embedded in field values will be doubled.398 </p><div class="note"><h3 class="title">Note</h3><p>399 Remember that what you write in an SQL command will first be interpreted400 as a string literal, and then as a composite. This doubles the number of401 backslashes you need (assuming escape string syntax is used).402 For example, to insert a <code class="type">text</code> field403 containing a double quote and a backslash in a composite404 value, you'd need to write:405</p><pre class="programlisting">406INSERT ... VALUES ('("\"\\")');407</pre><p>408 The string-literal processor removes one level of backslashes, so that409 what arrives at the composite-value parser looks like410 <code class="literal">("\"\\")</code>. In turn, the string411 fed to the <code class="type">text</code> data type's input routine412 becomes <code class="literal">"\</code>. (If we were working413 with a data type whose input routine also treated backslashes specially,414 <code class="type">bytea</code> for example, we might need as many as eight backslashes415 in the command to get one backslash into the stored composite field.)416 Dollar quoting (see <a class="xref" href="sql-syntax-lexical.html#SQL-SYNTAX-DOLLAR-QUOTING" title="4.1.2.4. Dollar-Quoted String Constants">Section 4.1.2.4</a>) can be417 used to avoid the need to double backslashes.418 </p></div><div class="tip"><h3 class="title">Tip</h3><p>419 The <code class="literal">ROW</code> constructor syntax is usually easier to work with420 than the composite-literal syntax when writing composite values in SQL421 commands.422 In <code class="literal">ROW</code>, individual field values are written the same way423 they would be written when not members of a composite.424 </p></div></div></div><div class="navfooter"><hr /><table width="100%" summary="Navigation footer"><tr><td width="40%" align="left"><a accesskey="p" href="arrays.html" title="8.15. Arrays">Prev</a> </td><td width="20%" align="center"><a accesskey="u" href="datatype.html" title="Chapter 8. Data Types">Up</a></td><td width="40%" align="right"> <a accesskey="n" href="rangetypes.html" title="8.17. Range Types">Next</a></td></tr><tr><td width="40%" align="left" valign="top">8.15. Arrays </td><td width="20%" align="center"><a accesskey="h" href="index.html" title="PostgreSQL 16.3 Documentation">Home</a></td><td width="40%" align="right" valign="top"> 8.17. Range Types</td></tr></table></div></body></html>