Modified: tajo/site/docs/devel/sql_language/alter_table.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/alter_table.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/alter_table.html (original)
+++ tajo/site/docs/devel/sql_language/alter_table.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -262,12 +264,12 @@ ALTER TABLE table1 ADD PARTITION (col1 =
 ALTER TABLE table1 ADD PARTITION (col1 = 1 , col2 = 2) LOCATION 
&#39;hdfs://xxx.com/warehouse/table1/col1=1/col2=2&#39;
 </pre></div>
 </div>
-<p>You can use <code class="docutils literal"><span class="pre">ALTER</span> 
<span class="pre">TABLE</span> <span class="pre">ADD</span> <span 
class="pre">PARTITION</span></code> to add partitions to a table. The location 
must be a directory inside of which data files reside. If the location 
doesn&#8217;t exist on the file system, Tajo will make the location by force. 
<code class="docutils literal"><span class="pre">ADD</span> <span 
class="pre">PARTITION</span></code> changes the table metadata, but does not 
load data. If the data does not exist in the partition&#8217;s location, 
queries will not return any results.</p>
+<p>You can use <tt class="docutils literal"><span class="pre">ALTER</span> 
<span class="pre">TABLE</span> <span class="pre">ADD</span> <span 
class="pre">PARTITION</span></tt> to add partitions to a table. The location 
must be a directory inside of which data files reside. If the location 
doesn&#8217;t exist on the file system, Tajo will make the location by force. 
<tt class="docutils literal"><span class="pre">ADD</span> <span 
class="pre">PARTITION</span></tt> changes the table metadata, but does not load 
data. If the data does not exist in the partition&#8217;s location, queries 
will not return any results. An error is thrown if the partition for the table 
already exists. You can use <tt class="docutils literal"><span 
class="pre">IF</span> <span class="pre">NOT</span> <span 
class="pre">EXISTS</span></tt> to skip the error.</p>
 </div>
 <div class="section" id="drop-partition">
 <h2>DROP PARTITION<a class="headerlink" href="#drop-partition" 
title="Permalink to this headline">¶</a></h2>
 <p><em>Synopsis</em></p>
-<div class="highlight-sql"><div class="highlight"><pre><span 
class="k">ALTER</span> <span class="k">TABLE</span> <span 
class="o">&lt;</span><span class="k">table_name</span><span 
class="o">&gt;</span> <span class="p">[</span><span class="n">IF</span> <span 
class="k">NOT</span> <span class="k">EXISTS</span><span class="p">]</span> 
<span class="k">DROP</span> <span class="n">PARTITION</span> <span 
class="p">(</span><span class="o">&lt;</span><span class="n">partition</span> 
<span class="k">column</span><span class="o">&gt;</span> <span 
class="o">=</span> <span class="o">&lt;</span><span class="n">partition</span> 
<span class="n">value</span><span class="o">&gt;</span><span class="p">,</span> 
<span class="p">...)</span> <span class="p">[</span><span 
class="n">PURGE</span><span class="p">]</span>
+<div class="highlight-sql"><div class="highlight"><pre><span 
class="k">ALTER</span> <span class="k">TABLE</span> <span 
class="o">&lt;</span><span class="k">table_name</span><span 
class="o">&gt;</span> <span class="p">[</span><span class="n">IF</span> <span 
class="k">EXISTS</span><span class="p">]</span> <span class="k">DROP</span> 
<span class="n">PARTITION</span> <span class="p">(</span><span 
class="o">&lt;</span><span class="n">partition</span> <span 
class="k">column</span><span class="o">&gt;</span> <span class="o">=</span> 
<span class="o">&lt;</span><span class="n">partition</span> <span 
class="n">value</span><span class="o">&gt;</span><span class="p">,</span> <span 
class="p">...)</span> <span class="p">[</span><span class="n">PURGE</span><span 
class="p">]</span>
 
 <span class="k">For</span> <span class="n">example</span><span 
class="p">:</span>
 <span class="k">ALTER</span> <span class="k">TABLE</span> <span 
class="n">table1</span> <span class="k">DROP</span> <span 
class="n">PARTITION</span> <span class="p">(</span><span class="n">col1</span> 
<span class="o">=</span> <span class="mi">1</span> <span class="p">,</span> 
<span class="n">col2</span> <span class="o">=</span> <span 
class="mi">2</span><span class="p">)</span>
@@ -275,10 +277,7 @@ ALTER TABLE table1 ADD PARTITION (col1 =
 <span class="k">ALTER</span> <span class="k">TABLE</span> <span 
class="n">table1</span> <span class="k">DROP</span> <span 
class="n">PARTITION</span> <span class="p">(</span><span class="n">col1</span> 
<span class="o">=</span> <span class="s1">&#39;TAJO&#39;</span> <span 
class="p">)</span> <span class="n">PURGE</span>
 </pre></div>
 </div>
-<dl class="docutils">
-<dt>You can use <code class="docutils literal"><span class="pre">ALTER</span> 
<span class="pre">TABLE</span> <span class="pre">DROP</span> <span 
class="pre">PARTITION</span></code> to drop a partition for a table. This 
removes the data for a managed table</dt>
-<dd>and this doesn&#8217;t remove the data for an external table. But if <code 
class="docutils literal"><span class="pre">PURGE</span></code> is specified for 
an external table, the partition data will be removed. The metadata is 
completely lost in all cases.</dd>
-</dl>
+<p>You can use <tt class="docutils literal"><span class="pre">ALTER</span> 
<span class="pre">TABLE</span> <span class="pre">DROP</span> <span 
class="pre">PARTITION</span></tt> to drop a partition for a table. This removes 
the data for a managed table and this doesn&#8217;t remove the data for an 
external table. But if <tt class="docutils literal"><span 
class="pre">PURGE</span></tt> is specified for an external table, the partition 
data will be removed. The metadata is completely lost in all cases. An error is 
thrown if the partition for the table doesn&#8217;t exists. You can use <tt 
class="docutils literal"><span class="pre">IF</span> <span 
class="pre">EXISTS</span></tt> to skip the error.</p>
 </div>
 </div>
 

Modified: tajo/site/docs/devel/sql_language/data_model.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/data_model.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/data_model.html (original)
+++ tajo/site/docs/devel/sql_language/data_model.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>

Modified: tajo/site/docs/devel/sql_language/ddl.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/ddl.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/ddl.html (original)
+++ tajo/site/docs/devel/sql_language/ddl.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -212,7 +214,7 @@
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">CREATE</span> <span class="k">DATABASE</span> <span 
class="p">[</span><span class="n">IF</span> <span class="k">NOT</span> <span 
class="k">EXISTS</span><span class="p">]</span> <span 
class="o">&lt;</span><span class="n">database_name</span><span 
class="o">&gt;</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">IF</span> <span 
class="pre">NOT</span> <span class="pre">EXISTS</span></code> allows <code 
class="docutils literal"><span class="pre">CREATE</span> <span 
class="pre">DATABASE</span></code> statement to avoid an error which occurs 
when the database exists.</p>
+<p><tt class="docutils literal"><span class="pre">IF</span> <span 
class="pre">NOT</span> <span class="pre">EXISTS</span></tt> allows <tt 
class="docutils literal"><span class="pre">CREATE</span> <span 
class="pre">DATABASE</span></tt> statement to avoid an error which occurs when 
the database exists.</p>
 </div>
 <div class="section" id="drop-database">
 <h2>DROP DATABASE<a class="headerlink" href="#drop-database" title="Permalink 
to this headline">¶</a></h2>
@@ -220,7 +222,7 @@
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">DROP</span> <span class="k">DATABASE</span> <span 
class="p">[</span><span class="n">IF</span> <span class="k">EXISTS</span><span 
class="p">]</span> <span class="o">&lt;</span><span 
class="n">database_name</span><span class="o">&gt;</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">IF</span> <span 
class="pre">EXISTS</span></code> allows <code class="docutils literal"><span 
class="pre">DROP</span> <span class="pre">DATABASE</span></code> statement to 
avoid an error which occurs when the database does not exist.</p>
+<p><tt class="docutils literal"><span class="pre">IF</span> <span 
class="pre">EXISTS</span></tt> allows <tt class="docutils literal"><span 
class="pre">DROP</span> <span class="pre">DATABASE</span></tt> statement to 
avoid an error which occurs when the database does not exist.</p>
 </div>
 <div class="section" id="create-table">
 <h2>CREATE TABLE<a class="headerlink" href="#create-table" title="Permalink to 
this headline">¶</a></h2>
@@ -232,7 +234,7 @@
 <span class="k">using</span> <span class="o">&lt;</span><span 
class="n">storage_type</span><span class="o">&gt;</span> <span 
class="p">[</span><span class="k">with</span> <span class="p">(</span><span 
class="o">&lt;</span><span class="k">key</span><span class="o">&gt;</span> 
<span class="o">=</span> <span class="o">&lt;</span><span 
class="n">value</span><span class="o">&gt;</span><span class="p">,</span> <span 
class="p">...)]</span> <span class="k">LOCATION</span> <span 
class="s1">&#39;&lt;path&gt;&#39;</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">IF</span> <span 
class="pre">NOT</span> <span class="pre">EXISTS</span></code> allows <code 
class="docutils literal"><span class="pre">CREATE</span> <span 
class="pre">[EXTERNAL]</span> <span class="pre">TABLE</span></code> statement 
to avoid an error which occurs when the table does not exist.</p>
+<p><tt class="docutils literal"><span class="pre">IF</span> <span 
class="pre">NOT</span> <span class="pre">EXISTS</span></tt> allows <tt 
class="docutils literal"><span class="pre">CREATE</span> <span 
class="pre">[EXTERNAL]</span> <span class="pre">TABLE</span></tt> statement to 
avoid an error which occurs when the table does not exist.</p>
 <div class="section" id="compression">
 <h3>Compression<a class="headerlink" href="#compression" title="Permalink to 
this headline">¶</a></h3>
 <p>If you want to add an external table that contains compressed data, you 
should give &#8216;compression.code&#8217; parameter to CREATE TABLE 
statement.</p>
@@ -264,7 +266,7 @@
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">DROP</span> <span class="k">TABLE</span> <span 
class="p">[</span><span class="n">IF</span> <span class="k">EXISTS</span><span 
class="p">]</span> <span class="o">&lt;</span><span 
class="k">table_name</span><span class="o">&gt;</span> <span 
class="p">[</span><span class="n">PURGE</span><span class="p">]</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">IF</span> <span 
class="pre">EXISTS</span></code> allows <code class="docutils literal"><span 
class="pre">DROP</span> <span class="pre">DATABASE</span></code> statement to 
avoid an error which occurs when the database does not exist. <code 
class="docutils literal"><span class="pre">DROP</span> <span 
class="pre">TABLE</span></code> statement removes a table from Tajo catalog, 
but it does not remove the contents. If <code class="docutils literal"><span 
class="pre">PURGE</span></code> option is given, <code class="docutils 
literal"><span class="pre">DROP</span> <span class="pre">TABLE</span></code> 
statement will eliminate the entry in the catalog as well as the contents.</p>
+<p><tt class="docutils literal"><span class="pre">IF</span> <span 
class="pre">EXISTS</span></tt> allows <tt class="docutils literal"><span 
class="pre">DROP</span> <span class="pre">DATABASE</span></tt> statement to 
avoid an error which occurs when the database does not exist. <tt 
class="docutils literal"><span class="pre">DROP</span> <span 
class="pre">TABLE</span></tt> statement removes a table from Tajo catalog, but 
it does not remove the contents. If <tt class="docutils literal"><span 
class="pre">PURGE</span></tt> option is given, <tt class="docutils 
literal"><span class="pre">DROP</span> <span class="pre">TABLE</span></tt> 
statement will eliminate the entry in the catalog as well as the contents.</p>
 </div>
 <div class="section" id="create-index">
 <h2>CREATE INDEX<a class="headerlink" href="#create-index" title="Permalink to 
this headline">¶</a></h2>

Modified: tajo/site/docs/devel/sql_language/insert.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/insert.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/insert.html (original)
+++ tajo/site/docs/devel/sql_language/insert.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -206,7 +208,7 @@
             
   <div class="section" id="insert-overwrite-into">
 <h1>INSERT (OVERWRITE) INTO<a class="headerlink" href="#insert-overwrite-into" 
title="Permalink to this headline">¶</a></h1>
-<p>INSERT OVERWRITE statement overwrites a table data of an existing table or 
a data in a given directory. Tajo&#8217;s INSERT OVERWRITE statement follows 
<code class="docutils literal"><span class="pre">INSERT</span> <span 
class="pre">INTO</span> <span class="pre">SELECT</span></code> statement of 
SQL. The examples are as follows:</p>
+<p>INSERT OVERWRITE statement overwrites a table data of an existing table or 
a data in a given directory. Tajo&#8217;s INSERT OVERWRITE statement follows 
<tt class="docutils literal"><span class="pre">INSERT</span> <span 
class="pre">INTO</span> <span class="pre">SELECT</span></tt> statement of SQL. 
The examples are as follows:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">create</span> <span class="k">table</span> <span class="n">t1</span> 
<span class="p">(</span><span class="n">col1</span> <span 
class="nb">int8</span><span class="p">,</span> <span class="n">col2</span> 
<span class="n">int4</span><span class="p">,</span> <span class="n">col3</span> 
<span class="n">float8</span><span class="p">);</span>
 
 <span class="c1">-- when a target table schema and output schema are 
equivalent to each other</span>

Modified: tajo/site/docs/devel/sql_language/joins.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/joins.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/joins.html (original)
+++ tajo/site/docs/devel/sql_language/joins.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -210,21 +212,21 @@
 <h2>Overview<a class="headerlink" href="#overview" title="Permalink to this 
headline">¶</a></h2>
 <p>In Tajo, a single query can accesses multiple rows of the same or different 
relations at one time. This query is called <em>join</em>.
 Currently, Tajo supports cross, inner, and outer joins.</p>
-<p>A join query can involve multiple relations in the <code class="docutils 
literal"><span class="pre">FROM</span></code> clause according to the following 
rule.</p>
+<p>A join query can involve multiple relations in the <tt class="docutils 
literal"><span class="pre">FROM</span></tt> clause according to the following 
rule.</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">FROM</span> <span class="n">joined_table</span> <span 
class="p">[,</span> <span class="n">joined_table</span> <span 
class="p">[,</span> <span class="p">...]</span> <span class="p">]</span>
 </pre></div>
 </div>
-<p>, where <code class="docutils literal"><span 
class="pre">joined_table</span></code> is:</p>
+<p>, where <tt class="docutils literal"><span 
class="pre">joined_table</span></tt> is:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="n">table_reference</span> <span class="n">join_type</span> <span 
class="n">table_reference</span> <span class="p">[</span> <span 
class="k">ON</span> <span class="n">join_condition</span> <span 
class="p">]</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">join_type</span></code> 
can be one of the followings.</p>
+<p><tt class="docutils literal"><span class="pre">join_type</span></tt> can be 
one of the followings.</p>
 <div class="highlight-sql"><div class="highlight"><pre>CROSS JOIN
 [ NATURAL ] [ INNER ] JOIN
 { LEFT | RIGHT | FULL } OUTER JOIN
 </pre></div>
 </div>
-<p><code class="docutils literal"><span 
class="pre">join_condition</span></code> can be specified in the <code 
class="docutils literal"><span class="pre">WHERE</span></code> clause as well 
as the <code class="docutils literal"><span class="pre">ON</span></code> 
clause.</p>
+<p><tt class="docutils literal"><span class="pre">join_condition</span></tt> 
can be specified in the <tt class="docutils literal"><span 
class="pre">WHERE</span></tt> clause as well as the <tt class="docutils 
literal"><span class="pre">ON</span></tt> clause.</p>
 <p>For more information, please refer to <a class="reference internal" 
href="predicates.html"><em>Predicates</em></a>.</p>
 <div class="admonition note">
 <p class="first admonition-title">Note</p>
@@ -259,7 +261,7 @@ Currently, Tajo supports cross, inner, a
 <span class="k">SELECT</span> <span class="n">a</span><span 
class="p">.</span><span class="o">*</span> <span class="k">FROM</span> <span 
class="n">a</span> <span class="k">INNER</span> <span class="k">JOIN</span> 
<span class="n">b</span> <span class="k">ON</span> <span 
class="n">a</span><span class="p">.</span><span class="n">id</span> <span 
class="o">=</span> <span class="n">b</span><span class="p">.</span><span 
class="n">id</span> <span class="k">FULL</span> <span class="k">OUTER</span> 
<span class="k">JOIN</span> <span class="k">c</span> <span class="k">ON</span> 
<span class="n">b</span><span class="p">.</span><span class="n">id2</span> 
<span class="o">=</span> <span class="k">c</span><span class="p">.</span><span 
class="n">id2</span>
 </pre></div>
 </div>
-<p>When a query involves three or more tables, there may be a lot of possible 
join orders. Tajo automatically finds the best join order regardless of the 
input order. For example, suppose that relation <code class="docutils 
literal"><span class="pre">b</span></code> is larger than relation <code 
class="docutils literal"><span class="pre">a</span></code>, and in turn, the 
relation <code class="docutils literal"><span class="pre">c</span></code> is 
larger than relation <code class="docutils literal"><span 
class="pre">b</span></code>. The query</p>
+<p>When a query involves three or more tables, there may be a lot of possible 
join orders. Tajo automatically finds the best join order regardless of the 
input order. For example, suppose that relation <tt class="docutils 
literal"><span class="pre">b</span></tt> is larger than relation <tt 
class="docutils literal"><span class="pre">a</span></tt>, and in turn, the 
relation <tt class="docutils literal"><span class="pre">c</span></tt> is larger 
than relation <tt class="docutils literal"><span class="pre">b</span></tt>. The 
query</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">a</span><span class="p">.</span><span 
class="o">*</span> <span class="k">FROM</span> <span class="k">c</span> <span 
class="k">INNER</span> <span class="k">JOIN</span> <span class="n">b</span> 
<span class="k">ON</span> <span class="n">b</span><span class="p">.</span><span 
class="n">id2</span> <span class="o">=</span> <span class="k">c</span><span 
class="p">.</span><span class="n">id2</span> <span class="k">INNER</span> <span 
class="k">JOIN</span> <span class="n">a</span> <span class="k">ON</span> <span 
class="n">a</span><span class="p">.</span><span class="n">id</span> <span 
class="o">=</span> <span class="n">b</span><span class="p">.</span><span 
class="n">id</span>
 </pre></div>
 </div>
@@ -289,7 +291,7 @@ Tajo adopts several optimization techniq
 Basically, joining multiple relations is left-associative. However, query 
performance can be significantly changed according to which order is chosen for 
the join execution.</p>
 <p>To find the best join order, Tajo&#8217;s cost-based optimizer considers 
join conditions, join types, and the size of input relations.
 In addition, it considers the computation cost of consecutive joins so that 
the shape of query plan forms a bushy tree.</p>
-<p>For example, suppose that there are 4 relations <code class="docutils 
literal"><span class="pre">a</span></code> (10), <code class="docutils 
literal"><span class="pre">b</span></code> (20), <code class="docutils 
literal"><span class="pre">c</span></code> (30), and <a href="#id1"><span 
class="problematic" id="id2">``</span></a>d``(40) where the numbers within 
brackets represent the relation size.
+<p>For example, suppose that there are 4 relations <tt class="docutils 
literal"><span class="pre">a</span></tt> (10), <tt class="docutils 
literal"><span class="pre">b</span></tt> (20), <tt class="docutils 
literal"><span class="pre">c</span></tt> (30), and <tt class="docutils 
literal"><span class="pre">d</span></tt> (40) where the numbers within brackets 
represent the relation size.
 The following query</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span>
   <span class="o">*</span>
@@ -322,9 +324,9 @@ Here, the cost of shuffle is expensive e
 Thus, they can perform join without expensive data shuffle.</p>
 <p>Tajo provides a session variable for broadcast join configuration. (For 
more detailed information of session variables, please refer to <a 
class="reference internal" href="../tsql/variables.html"><em>Session 
Variables</em></a>.)</p>
 <ul class="simple">
-<li><code class="docutils literal"><span 
class="pre">DIST_QUERY_BROADCAST_JOIN_THRESHOLD</span></code> is a threshold 
for broadcast join. Only the relations who are larger than this value can be 
broadcasted.</li>
+<li><tt class="docutils literal"><span 
class="pre">DIST_QUERY_BROADCAST_JOIN_THRESHOLD</span></tt> is a threshold for 
broadcast join. Only the relations who are larger than this value can be 
broadcasted.</li>
 </ul>
-<p>You can also apply this configuration system widely by setting <code 
class="docutils literal"><span 
class="pre">tajo.dist-query.join.broadcast.threshold-bytes</span></code> in 
<code class="docutils literal"><span 
class="pre">${TAJO_HOME}/conf/tajo-site.xml</span></code>.</p>
+<p>You can also apply this configuration system widely by setting <tt 
class="docutils literal"><span 
class="pre">tajo.dist-query.join.broadcast.threshold-bytes</span></tt> in <tt 
class="docutils literal"><span 
class="pre">${TAJO_HOME}/conf/tajo-site.xml</span></tt>.</p>
 </div>
 </div>
 </div>

Modified: tajo/site/docs/devel/sql_language/predicates.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/predicates.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/predicates.html (original)
+++ tajo/site/docs/devel/sql_language/predicates.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -256,7 +258,7 @@
 <span class="n">string</span> <span class="k">NOT</span> <span 
class="k">SIMILAR</span> <span class="k">TO</span> <span 
class="n">pattern</span>
 </pre></div>
 </div>
-<p>It returns true or false depending on whether its pattern matches the given 
string. Also like LIKE, <code class="docutils literal"><span 
class="pre">SIMILAR</span> <span class="pre">TO</span></code> uses <code 
class="docutils literal"><span class="pre">_</span></code> and <code 
class="docutils literal"><span class="pre">%</span></code> as metacharacters 
denoting any single character and any string, respectively.</p>
+<p>It returns true or false depending on whether its pattern matches the given 
string. Also like LIKE, <tt class="docutils literal"><span 
class="pre">SIMILAR</span> <span class="pre">TO</span></tt> uses <tt 
class="docutils literal"><span class="pre">_</span></tt> and <tt 
class="docutils literal"><span class="pre">%</span></tt> as metacharacters 
denoting any single character and any string, respectively.</p>
 <p>In addition to these metacharacters borrowed from LIKE, &#8216;SIMILAR 
TO&#8217; supports more powerful pattern-matching metacharacters borrowed from 
regular expressions:</p>
 <table border="1" class="docutils">
 <colgroup>
@@ -304,7 +306,7 @@
 </tr>
 </tbody>
 </table>
-<p>Note that <cite>.`</cite> is not used as a metacharacter in <code 
class="docutils literal"><span class="pre">SIMILAR</span> <span 
class="pre">TO</span></code> operator.</p>
+<p>Note that <cite>.`</cite> is not used as a metacharacter in <tt 
class="docutils literal"><span class="pre">SIMILAR</span> <span 
class="pre">TO</span></tt> operator.</p>
 </div>
 <div class="section" id="regular-expressions">
 <h3>Regular expressions<a class="headerlink" href="#regular-expressions" 
title="Permalink to this headline">¶</a></h3>

Modified: tajo/site/docs/devel/sql_language/queries.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/queries.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/queries.html (original)
+++ tajo/site/docs/devel/sql_language/queries.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -224,13 +226,13 @@
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="p">[</span><span class="k">FROM</span> <span class="o">&lt;</span><span 
class="k">table</span> <span class="n">reference</span><span 
class="o">&gt;</span> <span class="p">[[</span><span class="k">AS</span><span 
class="p">]</span> <span class="o">&lt;</span><span class="k">table</span> 
<span class="k">alias</span> <span class="n">name</span><span 
class="o">&gt;</span><span class="p">]</span> <span class="p">[,</span> <span 
class="p">...]]</span>
 </pre></div>
 </div>
-<p>The <code class="docutils literal"><span class="pre">FROM</span></code> 
clause specifies one or more other tables given in a comma-separated table 
reference list.
+<p>The <tt class="docutils literal"><span class="pre">FROM</span></tt> clause 
specifies one or more other tables given in a comma-separated table reference 
list.
 A table reference can be a relation name , or a subquery, a table join, or 
complex combinations of them.</p>
 <div class="section" id="table-and-table-aliases">
 <h3>Table and Table Aliases<a class="headerlink" 
href="#table-and-table-aliases" title="Permalink to this headline">¶</a></h3>
 <p>A temporary name can be given to tables and complex table references to be 
used
 for references to the derived table in the rest of the query. This is called a 
table alias.</p>
-<p>To create a a table alias, please use <code class="docutils literal"><span 
class="pre">AS</span></code>:</p>
+<p>To create a a table alias, please use <tt class="docutils literal"><span 
class="pre">AS</span></tt>:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">FROM</span> <span class="n">table_reference</span> <span 
class="k">AS</span> <span class="k">alias</span>
 </pre></div>
 </div>
@@ -238,7 +240,7 @@ for references to the derived table in t
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">FROM</span> <span class="n">table_reference</span> <span 
class="k">alias</span>
 </pre></div>
 </div>
-<p>The <code class="docutils literal"><span class="pre">AS</span></code> 
keyword can be omitted, and <em>Alias</em> can be any identifier.</p>
+<p>The <tt class="docutils literal"><span class="pre">AS</span></tt> keyword 
can be omitted, and <em>Alias</em> can be any identifier.</p>
 <p>A typical application of table aliases is to give short names to long table 
references. For example:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="o">*</span> <span class="k">FROM</span> 
<span class="n">long_table_name_1234</span> <span class="n">s</span> <span 
class="k">JOIN</span> <span class="n">another_long_table_name_5678</span> <span 
class="n">a</span> <span class="k">ON</span> <span class="n">s</span><span 
class="p">.</span><span class="n">id</span> <span class="o">=</span> <span 
class="n">a</span><span class="p">.</span><span class="n">num</span><span 
class="p">;</span>
 </pre></div>
@@ -255,25 +257,25 @@ for references to the derived table in t
 </pre></div>
 </div>
 <p>Cross join, also called <em>Cartesian product</em>, results in every 
possible combination of rows from T1 and T2.</p>
-<p><code class="docutils literal"><span class="pre">FROM</span> <span 
class="pre">T1</span> <span class="pre">CROSS</span> <span 
class="pre">JOIN</span> <span class="pre">T2</span></code> is equivalent to 
<code class="docutils literal"><span class="pre">FROM</span> <span 
class="pre">T1,</span> <span class="pre">T2</span></code>.</p>
+<p><tt class="docutils literal"><span class="pre">FROM</span> <span 
class="pre">T1</span> <span class="pre">CROSS</span> <span 
class="pre">JOIN</span> <span class="pre">T2</span></tt> is equivalent to <tt 
class="docutils literal"><span class="pre">FROM</span> <span 
class="pre">T1,</span> <span class="pre">T2</span></tt>.</p>
 </div>
 <div class="section" id="qualified-joins">
 <h5>Qualified joins<a class="headerlink" href="#qualified-joins" 
title="Permalink to this headline">¶</a></h5>
 <p>Qualified joins implicitly or explicitly have join conditions. 
Inner/Outer/Natural Joins all are qualified joins.
-Except for natural join, <code class="docutils literal"><span 
class="pre">ON</span></code> or <code class="docutils literal"><span 
class="pre">USING</span></code> clause in each join is used to specify a join 
condition.
+Except for natural join, <tt class="docutils literal"><span 
class="pre">ON</span></tt> or <tt class="docutils literal"><span 
class="pre">USING</span></tt> clause in each join is used to specify a join 
condition.
 A join condition must include at least one boolean expression, and it can also 
include just filter conditions.</p>
 <p><strong>Inner Join</strong></p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="n">T1</span> <span class="p">[</span><span class="k">INNER</span><span 
class="p">]</span> <span class="k">JOIN</span> <span class="n">T2</span> <span 
class="k">ON</span> <span class="n">boolean_expression</span>
 <span class="n">T1</span> <span class="p">[</span><span 
class="k">INNER</span><span class="p">]</span> <span class="k">JOIN</span> 
<span class="n">T2</span> <span class="k">USING</span> <span 
class="p">(</span><span class="k">join</span> <span class="k">column</span> 
<span class="n">list</span><span class="p">)</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">INNER</span></code> 
keyword is the default, and so <code class="docutils literal"><span 
class="pre">INNER</span></code> can be omitted when you use inner join.</p>
+<p><tt class="docutils literal"><span class="pre">INNER</span></tt> keyword is 
the default, and so <tt class="docutils literal"><span 
class="pre">INNER</span></tt> can be omitted when you use inner join.</p>
 <p><strong>Outer Join</strong></p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="n">T1</span> <span class="p">(</span><span class="k">LEFT</span><span 
class="o">|</span><span class="k">RIGHT</span><span class="o">|</span><span 
class="k">FULL</span><span class="p">)</span> <span class="k">OUTER</span> 
<span class="k">JOIN</span> <span class="n">T2</span> <span class="k">ON</span> 
<span class="n">boolean_expression</span>
 <span class="n">T1</span> <span class="p">(</span><span 
class="k">LEFT</span><span class="o">|</span><span class="k">RIGHT</span><span 
class="o">|</span><span class="k">FULL</span><span class="p">)</span> <span 
class="k">OUTER</span> <span class="k">JOIN</span> <span class="n">T2</span> 
<span class="k">USING</span> <span class="p">(</span><span 
class="k">join</span> <span class="k">column</span> <span 
class="n">list</span><span class="p">)</span>
 </pre></div>
 </div>
-<p>One of <code class="docutils literal"><span class="pre">LEFT</span></code>, 
<code class="docutils literal"><span class="pre">RIGHT</span></code>, or <code 
class="docutils literal"><span class="pre">FULL</span></code> must be specified 
for outer joins.
+<p>One of <tt class="docutils literal"><span class="pre">LEFT</span></tt>, <tt 
class="docutils literal"><span class="pre">RIGHT</span></tt>, or <tt 
class="docutils literal"><span class="pre">FULL</span></tt> must be specified 
for outer joins.
 Join conditions in outer join will have different behavior according to 
corresponding table references of join conditions.
 To know outer join behavior in more detail, please refer to
 <a class="reference external" 
href="http://www.ibm.com/developerworks/data/library/techarticle/purcell/0201purcell.html";>Advanced
 outer join constructs</a>.</p>
@@ -281,9 +283,9 @@ To know outer join behavior in more deta
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="n">T1</span> <span class="k">NATURAL</span> <span class="k">JOIN</span> 
<span class="n">T2</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">NATURAL</span></code> is a 
short form of <code class="docutils literal"><span 
class="pre">USING</span></code>. It forms a <code class="docutils 
literal"><span class="pre">USING</span></code> list consisting of all common 
column names that appear in
+<p><tt class="docutils literal"><span class="pre">NATURAL</span></tt> is a 
short form of <tt class="docutils literal"><span class="pre">USING</span></tt>. 
It forms a <tt class="docutils literal"><span class="pre">USING</span></tt> 
list consisting of all common column names that appear in
 both join tables. These common columns appear only once in the output table. 
If there are no common columns,
-<code class="docutils literal"><span class="pre">NATURAL</span></code> behaves 
like <code class="docutils literal"><span class="pre">CROSS</span> <span 
class="pre">JOIN</span></code>.</p>
+<tt class="docutils literal"><span class="pre">NATURAL</span></tt> behaves 
like <tt class="docutils literal"><span class="pre">CROSS</span> <span 
class="pre">JOIN</span></tt>.</p>
 <p><strong>Subqueries</strong></p>
 <p>Subqueries allow users to specify a derived table. It requires enclosing a 
SQL statement in parentheses and an alias name.
 For example:</p>
@@ -302,7 +304,7 @@ For example:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">WHERE</span> <span class="n">search_condition</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span 
class="pre">search_condition</span></code> can be any boolean expression.
+<p><tt class="docutils literal"><span class="pre">search_condition</span></tt> 
can be any boolean expression.
 In order to know additional predicates, please refer to <a class="reference 
internal" href="predicates.html"><em>Predicates</em></a>.</p>
 </div>
 <div class="section" id="groupby-and-having-clauses">
@@ -315,19 +317,19 @@ In order to know additional predicates,
     <span class="p">[</span><span class="k">HAVING</span> <span 
class="n">boolean_expression</span><span class="p">]</span>
 </pre></div>
 </div>
-<p>The rows which passes <code class="docutils literal"><span 
class="pre">WHERE</span></code> filter may be subject to grouping, specified by 
<code class="docutils literal"><span class="pre">GROUP</span> <span 
class="pre">BY</span></code> clause.
-Grouping combines a set of rows having common values into one group, and then 
computes rows in the group with aggregation functions. <code class="docutils 
literal"><span class="pre">HAVING</span></code> clause can be used with only 
<code class="docutils literal"><span class="pre">GROUP</span> <span 
class="pre">BY</span></code> clause. It eliminates the unqualified result rows 
of grouping.</p>
-<p><code class="docutils literal"><span 
class="pre">grouping_column_reference</span></code> can be a column reference, 
a complex expression including scalar functions and arithmetic operations.</p>
+<p>The rows which passes <tt class="docutils literal"><span 
class="pre">WHERE</span></tt> filter may be subject to grouping, specified by 
<tt class="docutils literal"><span class="pre">GROUP</span> <span 
class="pre">BY</span></tt> clause.
+Grouping combines a set of rows having common values into one group, and then 
computes rows in the group with aggregation functions. <tt class="docutils 
literal"><span class="pre">HAVING</span></tt> clause can be used with only <tt 
class="docutils literal"><span class="pre">GROUP</span> <span 
class="pre">BY</span></tt> clause. It eliminates the unqualified result rows of 
grouping.</p>
+<p><tt class="docutils literal"><span 
class="pre">grouping_column_reference</span></tt> can be a column reference, a 
complex expression including scalar functions and arithmetic operations.</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">l_orderkey</span><span 
class="p">,</span> <span class="k">SUM</span><span class="p">(</span><span 
class="n">l_quantity</span><span class="p">)</span> <span class="k">AS</span> 
<span class="n">quantity</span> <span class="k">FROM</span> <span 
class="n">lineitem</span> <span class="k">GROUP</span> <span 
class="k">BY</span> <span class="n">l_orderkey</span><span class="p">;</span>
 
 <span class="k">SELECT</span> <span class="n">substr</span><span 
class="p">(</span><span class="n">l_shipdate</span><span 
class="p">,</span><span class="mi">1</span><span class="p">,</span><span 
class="mi">4</span><span class="p">)</span> <span class="k">as</span> <span 
class="k">year</span><span class="p">,</span> <span class="k">SUM</span><span 
class="p">(</span><span class="n">l_orderkey</span><span class="p">)</span> 
<span class="k">AS</span> <span class="n">total2</span> <span 
class="k">FROM</span> <span class="n">lineitem</span> <span 
class="k">GROUP</span> <span class="k">BY</span> <span 
class="n">substr</span><span class="p">(</span><span 
class="n">l_shipdate</span><span class="p">,</span><span 
class="mi">1</span><span class="p">,</span><span class="mi">4</span><span 
class="p">);</span>
 </pre></div>
 </div>
-<p>If a SQL statement includes <code class="docutils literal"><span 
class="pre">GROUP</span> <span class="pre">BY</span></code> clause, expressions 
in select list must be either grouping_column_reference or aggregation 
function. For example, the following example query is not allowed because <code 
class="docutils literal"><span class="pre">l_orderkey</span></code> does not 
occur in <code class="docutils literal"><span class="pre">GROUP</span> <span 
class="pre">BY</span></code> clause.</p>
+<p>If a SQL statement includes <tt class="docutils literal"><span 
class="pre">GROUP</span> <span class="pre">BY</span></tt> clause, expressions 
in select list must be either grouping_column_reference or aggregation 
function. For example, the following example query is not allowed because <tt 
class="docutils literal"><span class="pre">l_orderkey</span></tt> does not 
occur in <tt class="docutils literal"><span class="pre">GROUP</span> <span 
class="pre">BY</span></tt> clause.</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">l_orderkey</span><span 
class="p">,</span> <span class="n">l_partkey</span><span class="p">,</span> 
<span class="k">SUM</span><span class="p">(</span><span 
class="n">l_orderkey</span><span class="p">)</span> <span class="k">AS</span> 
<span class="n">total</span> <span class="k">FROM</span> <span 
class="n">lineitem</span> <span class="k">GROUP</span> <span 
class="k">BY</span> <span class="n">l_partkey</span><span class="p">;</span>
 </pre></div>
 </div>
-<p>Aggregation functions can be used with <code class="docutils literal"><span 
class="pre">DISTINCT</span></code> keywords. It forces an individual aggregate 
function to take only distinct values of the argument expression. <code 
class="docutils literal"><span class="pre">DISTINCT</span></code> keyword is 
used as follows:</p>
+<p>Aggregation functions can be used with <tt class="docutils literal"><span 
class="pre">DISTINCT</span></tt> keywords. It forces an individual aggregate 
function to take only distinct values of the argument expression. <tt 
class="docutils literal"><span class="pre">DISTINCT</span></tt> keyword is used 
as follows:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">l_partkey</span><span 
class="p">,</span> <span class="k">COUNT</span><span class="p">(</span><span 
class="k">distinct</span> <span class="n">l_quantity</span><span 
class="p">),</span> <span class="k">SUM</span><span class="p">(</span><span 
class="k">distinct</span> <span class="n">l_extendedprice</span><span 
class="p">)</span> <span class="k">AS</span> <span class="n">total</span> <span 
class="k">FROM</span> <span class="n">lineitem</span> <span 
class="k">GROUP</span> <span class="k">BY</span> <span 
class="n">l_partkey</span><span class="p">;</span>
 </pre></div>
 </div>
@@ -338,12 +340,12 @@ Grouping combines a set of rows having c
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">FROM</span> <span class="p">...</span> <span class="k">ORDER</span> 
<span class="k">BY</span> <span class="o">&lt;</span><span 
class="n">sort_expr</span><span class="o">&gt;</span> <span 
class="p">[(</span><span class="k">ASC</span><span class="o">|</span><span 
class="k">DESC</span><span class="p">)]</span> <span class="p">[</span><span 
class="k">NULL</span> <span class="p">(</span><span class="k">FIRST</span><span 
class="o">|</span><span class="k">LAST</span><span class="p">)</span> <span 
class="p">[,...]</span>
 </pre></div>
 </div>
-<p><code class="docutils literal"><span class="pre">sort_expr</span></code> 
can be a column reference, aliased column reference, or a complex expression.
-<code class="docutils literal"><span class="pre">ASC</span></code> indicates 
an ascending order of <code class="docutils literal"><span 
class="pre">sort_expr</span></code> values. <code class="docutils 
literal"><span class="pre">DESC</span></code> indicates a descending order of 
<code class="docutils literal"><span class="pre">sort_expr</span></code> values.
-<code class="docutils literal"><span class="pre">ASC</span></code> is the 
default order.</p>
-<p><code class="docutils literal"><span class="pre">NULLS</span> <span 
class="pre">FIRST</span></code> and <code class="docutils literal"><span 
class="pre">NULLS</span> <span class="pre">LAST</span></code> options can be 
used to determine whether nulls values appear
+<p><tt class="docutils literal"><span class="pre">sort_expr</span></tt> can be 
a column reference, aliased column reference, or a complex expression.
+<tt class="docutils literal"><span class="pre">ASC</span></tt> indicates an 
ascending order of <tt class="docutils literal"><span 
class="pre">sort_expr</span></tt> values. <tt class="docutils literal"><span 
class="pre">DESC</span></tt> indicates a descending order of <tt 
class="docutils literal"><span class="pre">sort_expr</span></tt> values.
+<tt class="docutils literal"><span class="pre">ASC</span></tt> is the default 
order.</p>
+<p><tt class="docutils literal"><span class="pre">NULLS</span> <span 
class="pre">FIRST</span></tt> and <tt class="docutils literal"><span 
class="pre">NULLS</span> <span class="pre">LAST</span></tt> options can be used 
to determine whether nulls values appear
 before or after non-null values in the sort ordering. By default, null values 
are dealt as if larger than any non-null value;
-that is, <code class="docutils literal"><span class="pre">NULLS</span> <span 
class="pre">FIRST</span></code> is the default for <code class="docutils 
literal"><span class="pre">DESC</span></code> order, and <code class="docutils 
literal"><span class="pre">NULLS</span> <span class="pre">LAST</span></code> 
otherwise.</p>
+that is, <tt class="docutils literal"><span class="pre">NULLS</span> <span 
class="pre">FIRST</span></tt> is the default for <tt class="docutils 
literal"><span class="pre">DESC</span></tt> order, and <tt class="docutils 
literal"><span class="pre">NULLS</span> <span class="pre">LAST</span></tt> 
otherwise.</p>
 </div>
 <div class="section" id="window-functions">
 <h2>Window Functions<a class="headerlink" href="#window-functions" 
title="Permalink to this headline">¶</a></h2>
@@ -362,15 +364,15 @@ the same partition as the current row.</
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">l_orderkey</span><span 
class="p">,</span> <span class="k">sum</span><span class="p">(</span><span 
class="n">l_discount</span><span class="p">)</span> <span class="n">OVER</span> 
<span class="p">(</span><span class="n">PARTITION</span> <span 
class="k">BY</span> <span class="n">l_orderkey</span><span class="p">),</span> 
<span class="k">sum</span><span class="p">(</span><span 
class="n">l_quantity</span><span class="p">)</span> <span class="n">OVER</span> 
<span class="p">(</span><span class="n">PARTITION</span> <span 
class="k">BY</span> <span class="n">l_orderkey</span><span class="p">)</span> 
<span class="k">FROM</span> <span class="n">LINEITEM</span><span 
class="p">;</span>
 </pre></div>
 </div>
-<p>If <code class="docutils literal"><span class="pre">OVER()</span></code> 
clause is empty as following, it makes all table rows into one window frame.</p>
+<p>If <tt class="docutils literal"><span class="pre">OVER()</span></tt> clause 
is empty as following, it makes all table rows into one window frame.</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">salary</span><span class="p">,</span> 
<span class="k">sum</span><span class="p">(</span><span 
class="n">salary</span><span class="p">)</span> <span class="n">OVER</span> 
<span class="p">()</span> <span class="k">FROM</span> <span 
class="n">empsalary</span><span class="p">;</span>
 </pre></div>
 </div>
-<p>Also, <code class="docutils literal"><span class="pre">ORDER</span> <span 
class="pre">BY</span></code> clause can be used without <code class="docutils 
literal"><span class="pre">PARTITION</span> <span class="pre">BY</span></code> 
clause as follows:</p>
+<p>Also, <tt class="docutils literal"><span class="pre">ORDER</span> <span 
class="pre">BY</span></tt> clause can be used without <tt class="docutils 
literal"><span class="pre">PARTITION</span> <span class="pre">BY</span></tt> 
clause as follows:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">SELECT</span> <span class="n">salary</span><span class="p">,</span> 
<span class="k">sum</span><span class="p">(</span><span 
class="n">salary</span><span class="p">)</span> <span class="n">OVER</span> 
<span class="p">(</span><span class="k">ORDER</span> <span class="k">BY</span> 
<span class="n">salary</span><span class="p">)</span> <span 
class="k">FROM</span> <span class="n">empsalary</span><span class="p">;</span>
 </pre></div>
 </div>
-<p>Also, all expressions and aggregation functions are allowed in <code 
class="docutils literal"><span class="pre">ORDER</span> <span 
class="pre">BY</span></code> clause as follows:</p>
+<p>Also, all expressions and aggregation functions are allowed in <tt 
class="docutils literal"><span class="pre">ORDER</span> <span 
class="pre">BY</span></tt> clause as follows:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">select</span>
   <span class="n">l_orderkey</span><span class="p">,</span>
   <span class="k">count</span><span class="p">(</span><span 
class="o">*</span><span class="p">)</span> <span class="k">as</span> <span 
class="n">cnt</span><span class="p">,</span>

Modified: tajo/site/docs/devel/sql_language/sql_expression.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/sql_language/sql_expression.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/sql_language/sql_expression.html (original)
+++ tajo/site/docs/devel/sql_language/sql_expression.html Tue Sep  1 06:42:40 
2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -216,15 +218,22 @@
 <span class="n">expression</span><span class="p">::</span><span 
class="k">type</span>
 </pre></div>
 </div>
+<p>In addition, several functions are provided for type conversion. Please 
refer to <cite>:doc:data_type_func_and_operators</cite> and 
<cite>:doc:datetime_func_and_operators</cite>.</p>
+</div>
+<div class="section" id="string-constants">
+<h2>String Constants<a class="headerlink" href="#string-constants" 
title="Permalink to this headline">¶</a></h2>
+<p>A string constant is an arbitrary sequence of characters bounded by single 
quotes (<tt class="docutils literal"><span class="pre">'</span></tt>):</p>
+<div class="highlight-sql"><div class="highlight"><pre><span 
class="s1">&#39;tajo&#39;</span>
+</pre></div>
 </div>
-<div class="section" id="string-expressions">
-<h2>String Expressions<a class="headerlink" href="#string-expressions" 
title="Permalink to this headline">¶</a></h2>
 </div>
 <div class="section" id="function-call">
 <h2>Function Call<a class="headerlink" href="#function-call" title="Permalink 
to this headline">¶</a></h2>
+<p>The syntax for a function call consists of the name of a function and its 
argument list enclosed in parentheses:</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="n">function_name</span> <span class="p">([</span><span 
class="n">expression</span> <span class="p">[,</span> <span 
class="n">expression</span> <span class="p">...</span> <span 
class="p">]]</span> <span class="p">)</span>
 </pre></div>
 </div>
+<p>For more information about functions, please refer to 
<cite>:doc:functions</cite>.</p>
 </div>
 </div>
 

Modified: tajo/site/docs/devel/storage_plugin.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/storage_plugin.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/storage_plugin.html (original)
+++ tajo/site/docs/devel/storage_plugin.html Tue Sep  1 06:42:40 2015
@@ -110,7 +110,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -209,12 +211,12 @@
 </div>
 <div class="section" id="register-custom-storage">
 <h2>Register custom storage<a class="headerlink" 
href="#register-custom-storage" title="Permalink to this headline">¶</a></h2>
-<p>First of all, your storage implementation should be packed as a jar file. 
Then, please copy the jar file into <code class="docutils literal"><span 
class="pre">tajo/extlib</span></code> directory. Next, you should copy <code 
class="docutils literal"><span 
class="pre">conf/storage-site.json.template</span></code> into <code 
class="docutils literal"><span class="pre">conf/storage-site.json</span></code> 
and modify the file like the below.</p>
+<p>First of all, your storage implementation should be packed as a jar file. 
Then, please copy the jar file into <tt class="docutils literal"><span 
class="pre">tajo/extlib</span></tt> directory. Next, you should copy <tt 
class="docutils literal"><span 
class="pre">conf/storage-site.json.template</span></tt> into <tt 
class="docutils literal"><span class="pre">conf/storage-site.json</span></tt> 
and modify the file like the below.</p>
 </div>
 <div class="section" id="configuration">
 <h2>Configuration<a class="headerlink" href="#configuration" title="Permalink 
to this headline">¶</a></h2>
 <p>Tajo has a default configuration for builtin storages, such as HDFS, local 
file system, and Amazon S3. it also allows users to add custom storage 
plugins</p>
-<p><code class="docutils literal"><span 
class="pre">conf/storage-site.json</span></code> file has the following 
struct:</p>
+<p><tt class="docutils literal"><span 
class="pre">conf/storage-site.json</span></tt> file has the following 
struct:</p>
 <div class="highlight-json"><div class="highlight"><pre><span 
class="p">{</span>
   <span class="nt">&quot;storages&quot;</span><span class="p">:</span> <span 
class="p">{</span>
     <span class="nt">&quot;${scheme}&quot;</span><span class="p">:</span> 
<span class="p">{</span>
@@ -224,8 +226,8 @@
 <span class="p">}</span>
 </pre></div>
 </div>
-<p>Each storage instance (i.e., <a class="reference internal" 
href="table_management/tablespaces.html"><em>Tablespaces</em></a>) is 
identified by an URI. The scheme of URI plays a role to identify storage type. 
For example, <code class="docutils literal"><span 
class="pre">hdfs://</span></code> is used for Hdfs storage, <code 
class="docutils literal"><span class="pre">jdbc://</span></code> is used for 
JDBC-based storage, and <code class="docutils literal"><span 
class="pre">hbase://</span></code> is used for HBase storage.</p>
-<p>You should substitute a scheme name without <code class="docutils 
literal"><span class="pre">://</span></code> for <code class="docutils 
literal"><span class="pre">${scheme}</span></code>.</p>
+<p>Each storage instance (i.e., <a class="reference internal" 
href="table_management/tablespaces.html"><em>Tablespaces</em></a>) is 
identified by an URI. The scheme of URI plays a role to identify storage type. 
For example, <tt class="docutils literal"><span class="pre">hdfs://</span></tt> 
is used for Hdfs storage, <tt class="docutils literal"><span 
class="pre">jdbc://</span></tt> is used for JDBC-based storage, and <tt 
class="docutils literal"><span class="pre">hbase://</span></tt> is used for 
HBase storage.</p>
+<p>You should substitute a scheme name without <tt class="docutils 
literal"><span class="pre">://</span></tt> for <tt class="docutils 
literal"><span class="pre">${scheme}</span></tt>.</p>
 <p>See an example for HBase storage.</p>
 <div class="highlight-json"><div class="highlight"><pre><span 
class="p">{</span>
   <span class="nt">&quot;storages&quot;</span><span class="p">:</span> <span 
class="p">{</span>

Modified: tajo/site/docs/devel/swift_integration.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/swift_integration.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/swift_integration.html (original)
+++ tajo/site/docs/devel/swift_integration.html Tue Sep  1 06:42:40 2015
@@ -110,7 +110,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -210,13 +212,13 @@ You will also need to configure Swift an
 <p>For details, please see the following sections.</p>
 <div class="section" id="swift-configuration">
 <h2>Swift configuration<a class="headerlink" href="#swift-configuration" 
title="Permalink to this headline">¶</a></h2>
-<p>This step is not mandatory, but is strongly recommended to configure the 
Swift&#8217;s proxy-server with <code class="docutils literal"><span 
class="pre">list_endpoints</span></code> for better performance.
+<p>This step is not mandatory, but is strongly recommended to configure the 
Swift&#8217;s proxy-server with <tt class="docutils literal"><span 
class="pre">list_endpoints</span></tt> for better performance.
 More information is available <a class="reference external" 
href="http://docs.openstack.org/developer/swift/middleware.html#module-swift.common.middleware.list_endpoints";>here</a>.</p>
 </div>
 <div class="section" id="hadoop-configurations">
 <h2>Hadoop configurations<a class="headerlink" href="#hadoop-configurations" 
title="Permalink to this headline">¶</a></h2>
 <p>You need to configure Hadoop to specify how to access Swift objects.
-Here is an example of <code class="docutils literal"><span 
class="pre">${HADOOP_HOME}/etc/hadoop/core-site.xml</span></code>.</p>
+Here is an example of <tt class="docutils literal"><span 
class="pre">${HADOOP_HOME}/etc/hadoop/core-site.xml</span></tt>.</p>
 <div class="section" id="common-configurations">
 <h3>Common configurations<a class="headerlink" href="#common-configurations" 
title="Permalink to this headline">¶</a></h3>
 <div class="highlight-xml"><div class="highlight"><pre><span 
class="nt">&lt;property&gt;</span>
@@ -278,7 +280,7 @@ Here is an example of <code class="docut
 </div>
 <div class="section" id="tajo-configuration">
 <h2>Tajo configuration<a class="headerlink" href="#tajo-configuration" 
title="Permalink to this headline">¶</a></h2>
-<p>Finally, you need to configure the classpath of Tajo by adding the 
following line to <code class="docutils literal"><span 
class="pre">${TAJO_HOME}/conf/tajo-evn.sh</span></code>.</p>
+<p>Finally, you need to configure the classpath of Tajo by adding the 
following line to <tt class="docutils literal"><span 
class="pre">${TAJO_HOME}/conf/tajo-evn.sh</span></tt>.</p>
 <div class="highlight-sh"><div class="highlight"><pre><span class="nb">export 
</span><span class="nv">TAJO_CLASSPATH</span><span class="o">=</span><span 
class="nv">$HADOOP_HOME</span>/share/hadoop/tools/lib/hadoop-openstack-x.x.x.jar
 </pre></div>
 </div>

Modified: tajo/site/docs/devel/table_management.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/table_management.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/table_management.html (original)
+++ tajo/site/docs/devel/table_management.html Tue Sep  1 06:42:40 2015
@@ -110,7 +110,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>

Modified: tajo/site/docs/devel/table_management/compression.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/table_management/compression.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/table_management/compression.html (original)
+++ tajo/site/docs/devel/table_management/compression.html Tue Sep  1 06:42:40 
2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>

Modified: tajo/site/docs/devel/table_management/file_formats.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/table_management/file_formats.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/table_management/file_formats.html (original)
+++ tajo/site/docs/devel/table_management/file_formats.html Tue Sep  1 06:42:40 
2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>

Modified: tajo/site/docs/devel/table_management/parquet.html
URL: 
http://svn.apache.org/viewvc/tajo/site/docs/devel/table_management/parquet.html?rev=1700399&r1=1700398&r2=1700399&view=diff
==============================================================================
--- tajo/site/docs/devel/table_management/parquet.html (original)
+++ tajo/site/docs/devel/table_management/parquet.html Tue Sep  1 06:42:40 2015
@@ -111,7 +111,9 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" 
href="../functions.html">Functions</a><ul>
-<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-functions">Built-in Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-scalar-functions">Built-in Scalar 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-aggregation-functions">Built-in Aggregation 
Functions</a></li>
+<li class="toctree-l2"><a class="reference internal" 
href="../functions.html#built-in-window-functions">Built-in Window 
Functions</a></li>
 <li class="toctree-l2"><a class="reference internal" 
href="../functions.html#user-defined-functions">User-defined Functions</a></li>
 </ul>
 </li>
@@ -214,8 +216,8 @@ regardless of the choice of data process
 For more details, please refer to <a class="reference external" 
href="http://parquet.io/";>Parquet File Format</a>.</p>
 <div class="section" id="how-to-create-a-parquet-table">
 <h2>How to Create a Parquet Table?<a class="headerlink" 
href="#how-to-create-a-parquet-table" title="Permalink to this 
headline">¶</a></h2>
-<p>If you are not familiar with <code class="docutils literal"><span 
class="pre">CREATE</span> <span class="pre">TABLE</span></code> statement, 
please refer to Data Definition Language <a class="reference internal" 
href="../sql_language/ddl.html"><em>Data Definition Language</em></a>.</p>
-<p>In order to specify a certain file format for your table, you need to use 
the <code class="docutils literal"><span class="pre">USING</span></code> clause 
in your <code class="docutils literal"><span class="pre">CREATE</span> <span 
class="pre">TABLE</span></code>
+<p>If you are not familiar with <tt class="docutils literal"><span 
class="pre">CREATE</span> <span class="pre">TABLE</span></tt> statement, please 
refer to Data Definition Language <a class="reference internal" 
href="../sql_language/ddl.html"><em>Data Definition Language</em></a>.</p>
+<p>In order to specify a certain file format for your table, you need to use 
the <tt class="docutils literal"><span class="pre">USING</span></tt> clause in 
your <tt class="docutils literal"><span class="pre">CREATE</span> <span 
class="pre">TABLE</span></tt>
 statement. Below is an example statement for creating a table using parquet 
files.</p>
 <div class="highlight-sql"><div class="highlight"><pre><span 
class="k">CREATE</span> <span class="k">TABLE</span> <span 
class="n">table1</span> <span class="p">(</span>
   <span class="n">id</span> <span class="nb">int</span><span class="p">,</span>
@@ -229,13 +231,13 @@ statement. Below is an example statement
 <div class="section" id="physical-properties">
 <h2>Physical Properties<a class="headerlink" href="#physical-properties" 
title="Permalink to this headline">¶</a></h2>
 <p>Some table storage formats provide parameters for enabling or disabling 
features and adjusting physical parameters.
-The <code class="docutils literal"><span class="pre">WITH</span></code> clause 
in the CREATE TABLE statement allows users to set those parameters.</p>
+The <tt class="docutils literal"><span class="pre">WITH</span></tt> clause in 
the CREATE TABLE statement allows users to set those parameters.</p>
 <p>Now, Parquet file provides the following physical properties.</p>
 <ul class="simple">
-<li><code class="docutils literal"><span 
class="pre">parquet.block.size</span></code>: The block size is the size of a 
row group being buffered in memory. This limits the memory usage when writing. 
Larger values will improve the I/O when reading but consume more memory when 
writing. Default size is 134217728 bytes (= 128 * 1024 * 1024).</li>
-<li><code class="docutils literal"><span 
class="pre">parquet.page.size</span></code>: The page size is for compression. 
When reading, each page can be decompressed independently. A block is composed 
of pages. The page is the smallest unit that must be read fully to access a 
single record. If this value is too small, the compression will deteriorate. 
Default size is 1048576 bytes (= 1 * 1024 * 1024).</li>
-<li><code class="docutils literal"><span 
class="pre">parquet.compression</span></code>: The compression algorithm used 
to compress pages. It should be one of <code class="docutils literal"><span 
class="pre">uncompressed</span></code>, <code class="docutils literal"><span 
class="pre">snappy</span></code>, <code class="docutils literal"><span 
class="pre">gzip</span></code>, <code class="docutils literal"><span 
class="pre">lzo</span></code>. Default is <code class="docutils literal"><span 
class="pre">uncompressed</span></code>.</li>
-<li><code class="docutils literal"><span 
class="pre">parquet.enable.dictionary</span></code>: The boolean value is to 
enable/disable dictionary encoding. It should be one of either <code 
class="docutils literal"><span class="pre">true</span></code> or <code 
class="docutils literal"><span class="pre">false</span></code>. Default is 
<code class="docutils literal"><span class="pre">true</span></code>.</li>
+<li><tt class="docutils literal"><span 
class="pre">parquet.block.size</span></tt>: The block size is the size of a row 
group being buffered in memory. This limits the memory usage when writing. 
Larger values will improve the I/O when reading but consume more memory when 
writing. Default size is 134217728 bytes (= 128 * 1024 * 1024).</li>
+<li><tt class="docutils literal"><span 
class="pre">parquet.page.size</span></tt>: The page size is for compression. 
When reading, each page can be decompressed independently. A block is composed 
of pages. The page is the smallest unit that must be read fully to access a 
single record. If this value is too small, the compression will deteriorate. 
Default size is 1048576 bytes (= 1 * 1024 * 1024).</li>
+<li><tt class="docutils literal"><span 
class="pre">parquet.compression</span></tt>: The compression algorithm used to 
compress pages. It should be one of <tt class="docutils literal"><span 
class="pre">uncompressed</span></tt>, <tt class="docutils literal"><span 
class="pre">snappy</span></tt>, <tt class="docutils literal"><span 
class="pre">gzip</span></tt>, <tt class="docutils literal"><span 
class="pre">lzo</span></tt>. Default is <tt class="docutils literal"><span 
class="pre">uncompressed</span></tt>.</li>
+<li><tt class="docutils literal"><span 
class="pre">parquet.enable.dictionary</span></tt>: The boolean value is to 
enable/disable dictionary encoding. It should be one of either <tt 
class="docutils literal"><span class="pre">true</span></tt> or <tt 
class="docutils literal"><span class="pre">false</span></tt>. Default is <tt 
class="docutils literal"><span class="pre">true</span></tt>.</li>
 </ul>
 </div>
 <div class="section" id="compatibility-issues-with-apache-hive">


Reply via email to