You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by uw...@apache.org on 2018/12/23 16:31:52 UTC
[45/51] [partial] arrow-site git commit: Upload nightly docs
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_modules/pyarrow/types.html
----------------------------------------------------------------------
diff --git a/docs/latest/_modules/pyarrow/types.html b/docs/latest/_modules/pyarrow/types.html
new file mode 100644
index 0000000..8abad45
--- /dev/null
+++ b/docs/latest/_modules/pyarrow/types.html
@@ -0,0 +1,516 @@
+
+
+
+<!DOCTYPE html>
+<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
+<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
+<head>
+ <meta charset="utf-8">
+
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+
+ <title>pyarrow.types — Apache Arrow v0.11.1.dev473+g6ed02454</title>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ <link rel="stylesheet" href="../../_static/css/theme.css" type="text/css" />
+ <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
+ <link rel="index" title="Index" href="../../genindex.html" />
+ <link rel="search" title="Search" href="../../search.html" />
+
+
+ <script src="../../_static/js/modernizr.min.js"></script>
+
+</head>
+
+<body class="wy-body-for-nav">
+
+
+ <div class="wy-grid-for-nav">
+
+
+ <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+ <div class="wy-side-scroll">
+ <div class="wy-side-nav-search">
+
+
+
+ <a href="../../index.html" class="icon icon-home"> Apache Arrow
+
+
+
+ </a>
+
+
+
+
+ <div class="version">
+ 0.11.1.dev473+g6ed02454
+ </div>
+
+
+
+
+<div role="search">
+ <form id="rtd-search-form" class="wy-form" action="../../search.html" method="get">
+ <input type="text" name="q" placeholder="Search docs" />
+ <input type="hidden" name="check_keywords" value="yes" />
+ <input type="hidden" name="area" value="default" />
+ </form>
+</div>
+
+
+ </div>
+
+ <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
+
+
+
+
+
+
+ <p class="caption"><span class="caption-text">Memory Format</span></p>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="../../format/README.html">Arrow specification documents</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../format/Guidelines.html">Implementation guidelines</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../format/Layout.html">Physical memory layout</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../format/Metadata.html">Metadata: Logical types, schemas, data headers</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../format/IPC.html">Interprocess messaging / communication (IPC)</a></li>
+</ul>
+<p class="caption"><span class="caption-text">Languages</span></p>
+<ul>
+<li class="toctree-l1"><a class="reference internal" href="../../cpp/index.html">C++ Implementation</a></li>
+<li class="toctree-l1"><a class="reference internal" href="../../python/index.html">Python bindings</a></li>
+</ul>
+
+
+
+ </div>
+ </div>
+ </nav>
+
+ <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
+
+
+ <nav class="wy-nav-top" aria-label="top navigation">
+
+ <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+ <a href="../../index.html">Apache Arrow</a>
+
+ </nav>
+
+
+ <div class="wy-nav-content">
+
+ <div class="rst-content">
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<div role="navigation" aria-label="breadcrumbs navigation">
+
+ <ul class="wy-breadcrumbs">
+
+ <li><a href="../../index.html">Docs</a> »</li>
+
+ <li><a href="../index.html">Module code</a> »</li>
+
+ <li><a href="../pyarrow.html">pyarrow</a> »</li>
+
+ <li>pyarrow.types</li>
+
+
+ <li class="wy-breadcrumbs-aside">
+
+ </li>
+
+ </ul>
+
+
+ <hr/>
+</div>
+ <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+ <div itemprop="articleBody">
+
+ <h1>Source code for pyarrow.types</h1><div class="highlight"><pre>
+<span></span><span class="c1"># Licensed to the Apache Software Foundation (ASF) under one</span>
+<span class="c1"># or more contributor license agreements. See the NOTICE file</span>
+<span class="c1"># distributed with this work for additional information</span>
+<span class="c1"># regarding copyright ownership. The ASF licenses this file</span>
+<span class="c1"># to you under the Apache License, Version 2.0 (the</span>
+<span class="c1"># "License"); you may not use this file except in compliance</span>
+<span class="c1"># with the License. You may obtain a copy of the License at</span>
+<span class="c1">#</span>
+<span class="c1"># http://www.apache.org/licenses/LICENSE-2.0</span>
+<span class="c1">#</span>
+<span class="c1"># Unless required by applicable law or agreed to in writing,</span>
+<span class="c1"># software distributed under the License is distributed on an</span>
+<span class="c1"># "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY</span>
+<span class="c1"># KIND, either express or implied. See the License for the</span>
+<span class="c1"># specific language governing permissions and limitations</span>
+<span class="c1"># under the License.</span>
+
+<span class="c1"># Tools for dealing with Arrow type metadata in Python</span>
+
+<span class="kn">from</span> <span class="nn">pyarrow.lib</span> <span class="k">import</span> <span class="p">(</span><span class="n">is_boolean_value</span><span class="p">,</span> <span class="c1"># noqa</span>
+ <span class="n">is_integer_value</span><span class="p">,</span>
+ <span class="n">is_float_value</span><span class="p">)</span>
+
+<span class="kn">import</span> <span class="nn">pyarrow.lib</span> <span class="k">as</span> <span class="nn">lib</span>
+
+
+<span class="n">_SIGNED_INTEGER_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_INT8</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT16</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT32</span><span class="p">,</span>
+ <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT64</span><span class="p">}</span>
+<span class="n">_UNSIGNED_INTEGER_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT8</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT16</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT32</span><span class="p">,</span>
+ <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT64</span><span class="p">}</span>
+<span class="n">_INTEGER_TYPES</span> <span class="o">=</span> <span class="n">_SIGNED_INTEGER_TYPES</span> <span class="o">|</span> <span class="n">_UNSIGNED_INTEGER_TYPES</span>
+<span class="n">_FLOATING_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_HALF_FLOAT</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_FLOAT</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DOUBLE</span><span class="p">}</span>
+<span class="n">_DATE_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_DATE32</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DATE64</span><span class="p">}</span>
+<span class="n">_TIME_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_TIME32</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_TIME64</span><span class="p">}</span>
+<span class="n">_TEMPORAL_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_TIMESTAMP</span><span class="p">}</span> <span class="o">|</span> <span class="n">_TIME_TYPES</span> <span class="o">|</span> <span class="n">_DATE_TYPES</span>
+<span class="n">_NESTED_TYPES</span> <span class="o">=</span> <span class="p">{</span><span class="n">lib</span><span class="o">.</span><span class="n">Type_LIST</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_STRUCT</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UNION</span><span class="p">,</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_MAP</span><span class="p">}</span>
+
+
+<div class="viewcode-block" id="is_null"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_null.html#pyarrow.types.is_null">[docs]</a><span class="k">def</span> <span class="nf">is_null</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a null type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_NA</span></div>
+
+
+<div class="viewcode-block" id="is_boolean"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_boolean.html#pyarrow.types.is_boolean">[docs]</a><span class="k">def</span> <span class="nf">is_boolean</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a boolean type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_BOOL</span></div>
+
+
+<div class="viewcode-block" id="is_integer"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_integer.html#pyarrow.types.is_integer">[docs]</a><span class="k">def</span> <span class="nf">is_integer</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of any integer type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_INTEGER_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_signed_integer"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_signed_integer.html#pyarrow.types.is_signed_integer">[docs]</a><span class="k">def</span> <span class="nf">is_signed_integer</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of any signed integer type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_SIGNED_INTEGER_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_unsigned_integer"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_unsigned_integer.html#pyarrow.types.is_unsigned_integer">[docs]</a><span class="k">def</span> <span class="nf">is_unsigned_integer</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of any unsigned integer type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_UNSIGNED_INTEGER_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_int8"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_int8.html#pyarrow.types.is_int8">[docs]</a><span class="k">def</span> <span class="nf">is_int8</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an int8 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT8</span></div>
+
+
+<div class="viewcode-block" id="is_int16"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_int16.html#pyarrow.types.is_int16">[docs]</a><span class="k">def</span> <span class="nf">is_int16</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an int16 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT16</span></div>
+
+
+<div class="viewcode-block" id="is_int32"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_int32.html#pyarrow.types.is_int32">[docs]</a><span class="k">def</span> <span class="nf">is_int32</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an int32 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT32</span></div>
+
+
+<div class="viewcode-block" id="is_int64"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_int64.html#pyarrow.types.is_int64">[docs]</a><span class="k">def</span> <span class="nf">is_int64</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an int64 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_INT64</span></div>
+
+
+<div class="viewcode-block" id="is_uint8"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_uint8.html#pyarrow.types.is_uint8">[docs]</a><span class="k">def</span> <span class="nf">is_uint8</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an uint8 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT8</span></div>
+
+
+<div class="viewcode-block" id="is_uint16"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_uint16.html#pyarrow.types.is_uint16">[docs]</a><span class="k">def</span> <span class="nf">is_uint16</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an uint16 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT16</span></div>
+
+
+<div class="viewcode-block" id="is_uint32"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_uint32.html#pyarrow.types.is_uint32">[docs]</a><span class="k">def</span> <span class="nf">is_uint32</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an uint32 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT32</span></div>
+
+
+<div class="viewcode-block" id="is_uint64"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_uint64.html#pyarrow.types.is_uint64">[docs]</a><span class="k">def</span> <span class="nf">is_uint64</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an uint64 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UINT64</span></div>
+
+
+<div class="viewcode-block" id="is_floating"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_floating.html#pyarrow.types.is_floating">[docs]</a><span class="k">def</span> <span class="nf">is_floating</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a floating point numeric type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_FLOATING_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_float16"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_float16.html#pyarrow.types.is_float16">[docs]</a><span class="k">def</span> <span class="nf">is_float16</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an float16 (half-precision) type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_HALF_FLOAT</span></div>
+
+
+<div class="viewcode-block" id="is_float32"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_float32.html#pyarrow.types.is_float32">[docs]</a><span class="k">def</span> <span class="nf">is_float32</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an float32 (single precision) type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_FLOAT</span></div>
+
+
+<div class="viewcode-block" id="is_float64"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_float64.html#pyarrow.types.is_float64">[docs]</a><span class="k">def</span> <span class="nf">is_float64</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of an float64 (double precision) type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DOUBLE</span></div>
+
+
+<div class="viewcode-block" id="is_list"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_list.html#pyarrow.types.is_list">[docs]</a><span class="k">def</span> <span class="nf">is_list</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a list type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_LIST</span></div>
+
+
+<div class="viewcode-block" id="is_struct"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_struct.html#pyarrow.types.is_struct">[docs]</a><span class="k">def</span> <span class="nf">is_struct</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a struct type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_STRUCT</span></div>
+
+
+<div class="viewcode-block" id="is_union"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_union.html#pyarrow.types.is_union">[docs]</a><span class="k">def</span> <span class="nf">is_union</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a union type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_UNION</span></div>
+
+
+<div class="viewcode-block" id="is_nested"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_nested.html#pyarrow.types.is_nested">[docs]</a><span class="k">def</span> <span class="nf">is_nested</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a nested type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_NESTED_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_temporal"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_temporal.html#pyarrow.types.is_temporal">[docs]</a><span class="k">def</span> <span class="nf">is_temporal</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a temporal (date, time, timestamp)</span>
+<span class="sd"> type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_TEMPORAL_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_timestamp"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_timestamp.html#pyarrow.types.is_timestamp">[docs]</a><span class="k">def</span> <span class="nf">is_timestamp</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a timestamp type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_TIMESTAMP</span></div>
+
+
+<div class="viewcode-block" id="is_time"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_time.html#pyarrow.types.is_time">[docs]</a><span class="k">def</span> <span class="nf">is_time</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a time type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_TIME_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_time32"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_time32.html#pyarrow.types.is_time32">[docs]</a><span class="k">def</span> <span class="nf">is_time32</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a time32 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_TIME32</span></div>
+
+
+<div class="viewcode-block" id="is_time64"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_time64.html#pyarrow.types.is_time64">[docs]</a><span class="k">def</span> <span class="nf">is_time64</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a time64 type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_TIME64</span></div>
+
+
+<div class="viewcode-block" id="is_binary"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_binary.html#pyarrow.types.is_binary">[docs]</a><span class="k">def</span> <span class="nf">is_binary</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a variable-length binary type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_BINARY</span></div>
+
+
+<div class="viewcode-block" id="is_unicode"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_unicode.html#pyarrow.types.is_unicode">[docs]</a><span class="k">def</span> <span class="nf">is_unicode</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Alias for is_string</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">is_string</span><span class="p">(</span><span class="n">t</span><span class="p">)</span></div>
+
+
+<div class="viewcode-block" id="is_string"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_string.html#pyarrow.types.is_string">[docs]</a><span class="k">def</span> <span class="nf">is_string</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of string (utf8 unicode) type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_STRING</span></div>
+
+
+<div class="viewcode-block" id="is_fixed_size_binary"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_fixed_size_binary.html#pyarrow.types.is_fixed_size_binary">[docs]</a><span class="k">def</span> <span class="nf">is_fixed_size_binary</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a fixed size binary type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_FIXED_SIZE_BINARY</span></div>
+
+
+<div class="viewcode-block" id="is_date"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_date.html#pyarrow.types.is_date">[docs]</a><span class="k">def</span> <span class="nf">is_date</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a date type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="ow">in</span> <span class="n">_DATE_TYPES</span></div>
+
+
+<div class="viewcode-block" id="is_date32"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_date32.html#pyarrow.types.is_date32">[docs]</a><span class="k">def</span> <span class="nf">is_date32</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a date32 (days) type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DATE32</span></div>
+
+
+<div class="viewcode-block" id="is_date64"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_date64.html#pyarrow.types.is_date64">[docs]</a><span class="k">def</span> <span class="nf">is_date64</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a date64 (milliseconds) type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DATE64</span></div>
+
+
+<div class="viewcode-block" id="is_map"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_map.html#pyarrow.types.is_map">[docs]</a><span class="k">def</span> <span class="nf">is_map</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a map logical type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_MAP</span></div>
+
+
+<div class="viewcode-block" id="is_decimal"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_decimal.html#pyarrow.types.is_decimal">[docs]</a><span class="k">def</span> <span class="nf">is_decimal</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a decimal type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DECIMAL</span></div>
+
+
+<div class="viewcode-block" id="is_dictionary"><a class="viewcode-back" href="../../python/generated/pyarrow.types.is_dictionary.html#pyarrow.types.is_dictionary">[docs]</a><span class="k">def</span> <span class="nf">is_dictionary</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if value is an instance of a dictionary-encoded type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">t</span><span class="o">.</span><span class="n">id</span> <span class="o">==</span> <span class="n">lib</span><span class="o">.</span><span class="n">Type_DICTIONARY</span></div>
+
+
+<span class="k">def</span> <span class="nf">is_primitive</span><span class="p">(</span><span class="n">t</span><span class="p">):</span>
+ <span class="sd">"""</span>
+<span class="sd"> Return True if the value is an instance of a primitive type</span>
+<span class="sd"> """</span>
+ <span class="k">return</span> <span class="n">lib</span><span class="o">.</span><span class="n">_is_primitive</span><span class="p">(</span><span class="n">t</span><span class="o">.</span><span class="n">id</span><span class="p">)</span>
+</pre></div>
+
+ </div>
+
+ </div>
+ <footer>
+
+
+ <hr/>
+
+ <div role="contentinfo">
+ <p>
+ © Copyright 2016-2018 Apache Software Foundation
+
+ </p>
+ </div>
+ Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a> provided by <a href="https://readthedocs.org">Read the Docs</a>.
+
+</footer>
+
+ </div>
+ </div>
+
+ </section>
+
+ </div>
+
+
+
+
+
+
+
+ <script type="text/javascript" id="documentation_options" data-url_root="../../" src="../../_static/documentation_options.js"></script>
+ <script type="text/javascript" src="../../_static/jquery.js"></script>
+ <script type="text/javascript" src="../../_static/underscore.js"></script>
+ <script type="text/javascript" src="../../_static/doctools.js"></script>
+
+
+
+
+ <script type="text/javascript" src="../../_static/js/theme.js"></script>
+
+ <script type="text/javascript">
+ jQuery(function () {
+ SphinxRtdTheme.Navigation.enable(true);
+ });
+ </script>
+<script async src="https://www.googletagmanager.com/gtag/js?id=UA-107500873-1"></script>
+<script>
+ window.dataLayer = window.dataLayer || [];
+ function gtag(){dataLayer.push(arguments);}
+ gtag('js', new Date());
+
+ gtag('config', 'UA-107500873-1');
+</script>
+
+
+</body>
+</html>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api.rst.txt b/docs/latest/_sources/cpp/api.rst.txt
new file mode 100644
index 0000000..f6c0418
--- /dev/null
+++ b/docs/latest/_sources/cpp/api.rst.txt
@@ -0,0 +1,30 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+*************
+API Reference
+*************
+
+.. toctree::
+ :maxdepth: 3
+
+ api/support
+ api/memory
+ api/datatype
+ api/array
+ api/builder
+ api/table
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api/array.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api/array.rst.txt b/docs/latest/_sources/cpp/api/array.rst.txt
new file mode 100644
index 0000000..bb981d1
--- /dev/null
+++ b/docs/latest/_sources/cpp/api/array.rst.txt
@@ -0,0 +1,92 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+======
+Arrays
+======
+
+.. doxygenclass:: arrow::Array
+ :project: arrow_cpp
+ :members:
+
+Concrete array subclasses
+=========================
+
+.. doxygenclass:: arrow::DictionaryArray
+ :project: arrow_cpp
+ :members:
+
+Non-nested
+----------
+
+.. doxygenclass:: arrow::FlatArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::NullArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::BinaryArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::StringArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::PrimitiveArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::BooleanArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::FixedSizeBinaryArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::Decimal128Array
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::NumericArray
+ :project: arrow_cpp
+ :members:
+
+Nested
+------
+
+.. doxygenclass:: arrow::UnionArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::ListArray
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::StructArray
+ :project: arrow_cpp
+ :members:
+
+Chunked Arrays
+==============
+
+.. doxygenclass:: arrow::ChunkedArray
+ :project: arrow_cpp
+ :members:
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api/builder.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api/builder.rst.txt b/docs/latest/_sources/cpp/api/builder.rst.txt
new file mode 100644
index 0000000..9e6540a
--- /dev/null
+++ b/docs/latest/_sources/cpp/api/builder.rst.txt
@@ -0,0 +1,56 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+==============
+Array Builders
+==============
+
+.. doxygenclass:: arrow::ArrayBuilder
+ :members:
+
+Concrete builder subclasses
+===========================
+
+.. doxygenclass:: arrow::NullBuilder
+ :members:
+
+.. doxygenclass:: arrow::BooleanBuilder
+ :members:
+
+.. doxygenclass:: arrow::NumericBuilder
+ :members:
+
+.. doxygenclass:: arrow::BinaryBuilder
+ :members:
+
+.. doxygenclass:: arrow::StringBuilder
+ :members:
+
+.. doxygenclass:: arrow::FixedSizeBinaryBuilder
+ :members:
+
+.. doxygenclass:: arrow::Decimal128Builder
+ :members:
+
+.. doxygenclass:: arrow::ListBuilder
+ :members:
+
+.. doxygenclass:: arrow::StructBuilder
+ :members:
+
+.. doxygenclass:: arrow::DictionaryBuilder
+ :members:
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api/datatype.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api/datatype.rst.txt b/docs/latest/_sources/cpp/api/datatype.rst.txt
new file mode 100644
index 0000000..adfc6e4
--- /dev/null
+++ b/docs/latest/_sources/cpp/api/datatype.rst.txt
@@ -0,0 +1,148 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+==========
+Data Types
+==========
+
+.. doxygenenum:: arrow::Type::type
+
+.. doxygenclass:: arrow::DataType
+ :members:
+
+.. _api-type-factories:
+
+Factory functions
+=================
+
+These functions are recommended for creating data types. They may return
+new objects or existing singletons, depending on the type requested.
+
+.. doxygengroup:: type-factories
+ :project: arrow_cpp
+ :content-only:
+
+Concrete type subclasses
+========================
+
+Primitive
+---------
+
+.. doxygenclass:: arrow::NullType
+ :members:
+
+.. doxygenclass:: arrow::BooleanType
+ :members:
+
+.. doxygenclass:: arrow::Int8Type
+ :members:
+
+.. doxygenclass:: arrow::Int16Type
+ :members:
+
+.. doxygenclass:: arrow::Int32Type
+ :members:
+
+.. doxygenclass:: arrow::Int64Type
+ :members:
+
+.. doxygenclass:: arrow::UInt8Type
+ :members:
+
+.. doxygenclass:: arrow::UInt16Type
+ :members:
+
+.. doxygenclass:: arrow::UInt32Type
+ :members:
+
+.. doxygenclass:: arrow::UInt64Type
+ :members:
+
+.. doxygenclass:: arrow::HalfFloatType
+ :members:
+
+.. doxygenclass:: arrow::FloatType
+ :members:
+
+.. doxygenclass:: arrow::DoubleType
+ :members:
+
+Time-related
+------------
+
+.. doxygenenum:: arrow::TimeUnit::type
+
+.. doxygenclass:: arrow::Date32Type
+ :members:
+
+.. doxygenclass:: arrow::Date64Type
+ :members:
+
+.. doxygenclass:: arrow::Time32Type
+ :members:
+
+.. doxygenclass:: arrow::Time64Type
+ :members:
+
+.. doxygenclass:: arrow::TimestampType
+ :members:
+
+Binary-like
+-----------
+
+.. doxygenclass:: arrow::BinaryType
+ :members:
+
+.. doxygenclass:: arrow::StringType
+ :members:
+
+.. doxygenclass:: arrow::FixedSizeBinaryType
+ :members:
+
+.. doxygenclass:: arrow::Decimal128Type
+ :members:
+
+Nested
+------
+
+.. doxygenclass:: arrow::ListType
+ :members:
+
+.. doxygenclass:: arrow::StructType
+ :members:
+
+.. doxygenclass:: arrow::UnionType
+ :members:
+
+Dictionary-encoded
+------------------
+
+.. doxygenclass:: arrow::DictionaryType
+ :members:
+
+Fields and Schemas
+==================
+
+.. doxygengroup:: schema-factories
+ :project: arrow_cpp
+ :content-only:
+
+.. doxygenclass:: arrow::Field
+ :members:
+
+.. doxygenclass:: arrow::Schema
+ :members:
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api/memory.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api/memory.rst.txt b/docs/latest/_sources/cpp/api/memory.rst.txt
new file mode 100644
index 0000000..c921229
--- /dev/null
+++ b/docs/latest/_sources/cpp/api/memory.rst.txt
@@ -0,0 +1,90 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Memory (management)
+===================
+
+Buffers
+-------
+
+.. doxygenclass:: arrow::Buffer
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::MutableBuffer
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::ResizableBuffer
+ :project: arrow_cpp
+ :members:
+
+Memory Pools
+------------
+
+.. doxygenfunction:: arrow::default_memory_pool
+ :project: arrow_cpp
+
+.. doxygenclass:: arrow::MemoryPool
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::LoggingMemoryPool
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::ProxyMemoryPool
+ :project: arrow_cpp
+ :members:
+
+Allocation Functions
+--------------------
+
+These functions allocate a buffer from a particular memory pool.
+
+.. doxygengroup:: buffer-allocation-functions
+ :project: arrow_cpp
+ :content-only:
+
+Slicing
+-------
+
+.. doxygengroup:: buffer-slicing-functions
+ :project: arrow_cpp
+ :content-only:
+
+Buffer Builders
+---------------
+
+.. doxygenclass:: arrow::BufferBuilder
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::TypedBufferBuilder
+ :project: arrow_cpp
+ :members:
+
+STL Integration
+---------------
+
+.. doxygenclass:: arrow::stl_allocator
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::STLMemoryPool
+ :project: arrow_cpp
+ :members:
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api/support.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api/support.rst.txt b/docs/latest/_sources/cpp/api/support.rst.txt
new file mode 100644
index 0000000..b165a99
--- /dev/null
+++ b/docs/latest/_sources/cpp/api/support.rst.txt
@@ -0,0 +1,29 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Programming Support
+===================
+
+Error return and reporting
+--------------------------
+
+.. doxygenclass:: arrow::Status
+ :project: arrow_cpp
+ :members:
+
+.. doxygendefine:: ARROW_RETURN_NOT_OK
+
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/api/table.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/api/table.rst.txt b/docs/latest/_sources/cpp/api/table.rst.txt
new file mode 100644
index 0000000..e8b4f8e
--- /dev/null
+++ b/docs/latest/_sources/cpp/api/table.rst.txt
@@ -0,0 +1,52 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+========================
+Two-dimensional Datasets
+========================
+
+Columns
+=======
+
+.. doxygenclass:: arrow::Column
+ :project: arrow_cpp
+ :members:
+
+Tables
+======
+
+.. doxygenclass:: arrow::Table
+ :project: arrow_cpp
+ :members:
+
+.. doxygenfunction:: arrow::ConcatenateTables
+ :project: arrow_cpp
+
+Record Batches
+==============
+
+.. doxygenclass:: arrow::RecordBatch
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::RecordBatchReader
+ :project: arrow_cpp
+ :members:
+
+.. doxygenclass:: arrow::TableBatchReader
+ :project: arrow_cpp
+ :members:
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/arrays.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/arrays.rst.txt b/docs/latest/_sources/cpp/arrays.rst.txt
new file mode 100644
index 0000000..0c5272d
--- /dev/null
+++ b/docs/latest/_sources/cpp/arrays.rst.txt
@@ -0,0 +1,211 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+======
+Arrays
+======
+
+The central type in Arrow is the class :class:`arrow::Array`. An array
+represents a known-length sequence of values all having the same type.
+Internally, those values are represented by one or several buffers, the
+number and meaning of which depend on the array's data type, as documented
+in :doc:`the Arrow data layout specification <../format/Layout>`.
+
+Those buffers consist of the value data itself and an optional bitmap buffer
+that indicates which array entries are null values. The bitmap buffer
+can be entirely omitted if the array is known to have zero null values.
+
+There are concrete subclasses of :class:`arrow::Array` for each data type,
+that help you access individual values of the array.
+
+Building an array
+=================
+
+As Arrow objects are immutable, there are classes provided that help you
+build these objects incrementally from third-party data. These classes
+are organized in a hierarchy around the :class:`arrow::ArrayBuilder` base class,
+with concrete subclasses tailored for each particular data type.
+
+For example, to build an array of ``int64_t`` elements, we can use the
+:class:`arrow::Int64Builder` class. In the following example, we build an array
+of the range 1 to 8 where the element that should hold the value 4 is nulled::
+
+ arrow::Int64Builder builder;
+ builder.Append(1);
+ builder.Append(2);
+ builder.Append(3);
+ builder.AppendNull();
+ builder.Append(5);
+ builder.Append(6);
+ builder.Append(7);
+ builder.Append(8);
+
+ std::shared_ptr<arrow::Array> array;
+ arrow::Status st = builder.Finish(&array);
+ if (!st.ok()) {
+ // ... do something on array building failure
+ }
+
+The resulting Array (which can be casted to the concrete :class:`arrow::Int64Array`
+subclass if you want to access its values) then consists of two
+:class:`arrow::Buffer`\s.
+The first buffer holds the null bitmap, which consists here of a single byte with
+the bits ``0|0|0|0|1|0|0|0``. As we use `least-significant bit (LSB) numbering`_.
+this indicates that the fourth entry in the array is null. The second
+buffer is simply an ``int64_t`` array containing all the above values.
+As the fourth entry is null, the value at that position in the buffer is
+undefined.
+
+Here is how you could access the concrete array's contents::
+
+ // Cast the Array to its actual type to access its data
+ auto int64_array = std::static_pointer_cast<arrow::Int64Array>(array);
+
+ // Get the pointer to the null bitmap.
+ const uint8_t* null_bitmap = int64_array->null_bitmap_data();
+
+ // Get the pointer to the actual data
+ const int64_t* data = int64_array->raw_values();
+
+ // Alternatively, given an array index, query its null bit and value directly
+ int64_t index = 2;
+ if (!int64_array->IsNull(index)) {
+ int64_t value = int64_array->Value(index);
+ }
+
+.. note::
+ :class:`arrow::Int64Array` (respectively :class:`arrow::Int64Builder`) is
+ just a ``typedef``, provided for convenience, of ``arrow::NumericArray<Int64Type>``
+ (respectively ``arrow::NumericBuilder<Int64Type>``).
+
+.. _least-significant bit (LSB) numbering: https://en.wikipedia.org/wiki/Bit_numbering
+
+Performance
+-----------
+
+While it is possible to build an array value-by-value as in the example above,
+to attain highest performance it is recommended to use the bulk appending
+methods (usually named ``AppendValues``) in the concrete :class:`arrow::ArrayBuilder`
+subclasses.
+
+If you know the number of elements in advance, it is also recommended to
+presize the working area by calling the :func:`~arrow::ArrayBuilder::Resize`
+or :func:`~arrow::ArrayBuilder::Reserve` methods.
+
+Here is how one could rewrite the above example to take advantage of those
+APIs::
+
+ arrow::Int64Builder builder;
+ // Make place for 8 values in total
+ builder.Resize(8);
+ // Bulk append the given values (with a null in 4th place as indicated by the
+ // validity vector)
+ std::vector<bool> validity = {true, true, true, false, true, true, true, true};
+ std::vector<int64_t> values = {1, 2, 3, 0, 5, 6, 7, 8};
+ builder.AppendValues(values, validity);
+
+ std::shared_ptr<arrow::Array> array;
+ arrow::Status st = builder.Finish(&array);
+
+If you still must append values one by one, some concrete builder subclasses
+have methods marked "Unsafe" that assume the working area has been correctly
+presized, and offer higher performance in exchange::
+
+ arrow::Int64Builder builder;
+ // Make place for 8 values in total
+ builder.Resize(8);
+ builder.UnsafeAppend(1);
+ builder.UnsafeAppend(2);
+ builder.UnsafeAppend(3);
+ builder.UnsafeAppendNull();
+ builder.UnsafeAppend(5);
+ builder.UnsafeAppend(6);
+ builder.UnsafeAppend(7);
+ builder.UnsafeAppend(8);
+
+ std::shared_ptr<arrow::Array> array;
+ arrow::Status st = builder.Finish(&array);
+
+
+Size Limitations and Recommendations
+====================================
+
+Some array types are structurally limited to 32-bit sizes. This is the case
+for list arrays (which can hold up to 2^31 elements), string arrays and binary
+arrays (which can hold up to 2GB of binary data), at least. Some other array
+types can hold up to 2^63 elements in the C++ implementation, but other Arrow
+implementations can have a 32-bit size limitation for those array types as well.
+
+For these reasons, it is recommended that huge data be chunked in subsets of
+more reasonable size.
+
+Chunked Arrays
+==============
+
+A :class:`arrow::ChunkedArray` is, like an array, a logical sequence of values;
+but unlike a simple array, a chunked array does not require the entire sequence
+to be physically contiguous in memory. Also, the constituents of a chunked array
+need not have the same size, but they must all have the same data type.
+
+A chunked array is constructed by agregating any number of arrays. Here we'll
+build a chunked array with the same logical values as in the example above,
+but in two separate chunks::
+
+ std::vector<std::shared_ptr<arrow::Array>> chunks;
+ std::shared_ptr<arrow::Array> array;
+
+ // Build first chunk
+ arrow::Int64Builder builder;
+ builder.Append(1);
+ builder.Append(2);
+ builder.Append(3);
+ if (!builder.Finish(&array).ok()) {
+ // ... do something on array building failure
+ }
+ chunks.push_back(std::move(array));
+
+ // Build second chunk
+ builder.Reset();
+ builder.AppendNull();
+ builder.Append(5);
+ builder.Append(6);
+ builder.Append(7);
+ builder.Append(8);
+ if (!builder.Finish(&array).ok()) {
+ // ... do something on array building failure
+ }
+ chunks.push_back(std::move(array));
+
+ auto chunked_array = std::make_shared<arrow::ChunkedArray>(std::move(chunks));
+
+ assert(chunked_array->num_chunks() == 2);
+ // Logical length in number of values
+ assert(chunked_array->length() == 8);
+ assert(chunked_array->null_count() == 1);
+
+Slicing
+=======
+
+Like for physical memory buffers, it is possible to make zero-copy slices
+of arrays and chunked arrays, to obtain an array or chunked array referring
+to some logical subsequence of the data. This is done by calling the
+:func:`arrow::Array::Slice` and :func:`arrow::ChunkedArray::Slice` methods,
+respectively.
+
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/conventions.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/conventions.rst.txt b/docs/latest/_sources/cpp/conventions.rst.txt
new file mode 100644
index 0000000..b042435
--- /dev/null
+++ b/docs/latest/_sources/cpp/conventions.rst.txt
@@ -0,0 +1,91 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+Conventions
+===========
+
+The Arrow C++ API follows a few simple guidelines. As with many rules,
+there may be exceptions.
+
+Language version
+----------------
+
+Arrow is C++11-compatible. A few backports are used for newer functionality,
+for example the :class:`std::string_view` class.
+
+Namespacing
+-----------
+
+All the Arrow API (except macros) is namespaced inside a ``arrow`` namespace,
+and nested namespaces thereof.
+
+Safe pointers
+-------------
+
+Arrow objects are usually passed and stored using safe pointers -- most of
+the time :class:`std::shared_ptr` but sometimes also :class:`std::unique_ptr`.
+
+Immutability
+------------
+
+Many Arrow objects are immutable: once constructed, their logical properties
+cannot change anymore. This makes it possible to use them in multi-threaded
+scenarios without requiring tedious and error-prone synchronization.
+
+There are obvious exceptions to this, such as IO objects or mutable data buffers.
+
+Error reporting
+---------------
+
+Most APIs indicate a successful or erroneous outcome by returning a
+:class:`arrow::Status` instance. Arrow doesn't throw exceptions of its
+own, but third-party exceptions might propagate through, especially
+:class:`std::bad_alloc` (but Arrow doesn't use the standard allocators for
+large data).
+
+As a consequence, the result value of a function is generally passed as an
+out-pointer parameter, rather than as a function return value.
+
+(however, functions which always determiniscally succeed may eschew this
+convention and return their result directly)
+
+Here is an example of checking the outcome of an operation::
+
+ const int64_t buffer_size = 4096;
+ std::shared_ptr<arrow::Buffer> buffer;
+
+ auto status = arrow::AllocateBuffer(buffer_size, &buffer);
+ if (!status.ok()) {
+ // ... handle error
+ }
+
+If the caller function itself returns a :class:`arrow::Status` and wants
+to propagate any non-successful outcomes, a convenience macro
+:cpp:func:`ARROW_RETURN_NON_OK` is available::
+
+ arrow::Status DoSomething() {
+ const int64_t buffer_size = 4096;
+ std::shared_ptr<arrow::Buffer> buffer;
+ ARROW_RETURN_NON_OK(arrow::AllocateBuffer(buffer_size, &buffer));
+ // ... allocation successful, do something with buffer below
+
+ // return success at the end
+ return Status::OK();
+ }
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/datatypes.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/datatypes.rst.txt b/docs/latest/_sources/cpp/datatypes.rst.txt
new file mode 100644
index 0000000..117c05b
--- /dev/null
+++ b/docs/latest/_sources/cpp/datatypes.rst.txt
@@ -0,0 +1,65 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+Data Types
+==========
+
+Data types govern how physical data is interpreted. Their :ref:`specification
+<spec-logical-types>` allows binary interoperability between different Arrow
+implementations, including from different programming languages and runtimes
+(for example it is possible to access the same data, without copying, from
+both Python and Java using the :py:mod:`pyarrow.jvm` bridge module).
+
+Information about a data type in C++ can be represented in three ways:
+
+1. Using a :class:`arrow::DataType` instance (e.g. as a function argument)
+2. Using a :class:`arrow::DataType` concrete subclass (e.g. as a template
+ parameter)
+3. Using a :type:`arrow::Type::type` enum value (e.g. as the condition of
+ a switch statement)
+
+The first form (using a :class:`arrow::DataType` instance) is the most idiomatic
+and flexible. Runtime-parametric types can only be fully represented with
+a DataType instance. For example, a :class:`arrow::TimestampType` needs to be
+constructed at runtime with a :type:`arrow::TimeUnit::type` parameter; a
+:class:`arrow::Decimal128Type` with *scale* and *precision* parameters;
+a :class:`arrow::ListType` with a full child type (itself a
+:class:`arrow::DataType` instance).
+
+The two other forms can be used where performance is critical, in order to
+avoid paying the price of dynamic typing and polymorphism. However, some
+amount of runtime switching can still be required for parametric types.
+It is not possible to reify all possible types at compile time, since Arrow
+data types allows arbitrary nesting.
+
+Creating data types
+-------------------
+
+To instantiate data types, it is recommended to call the provided
+:ref:`factory functions <api-type-factories>`::
+
+ std::shared_ptr<arrow::DataType> type;
+
+ // A 16-bit integer type
+ type = arrow::int16();
+ // A 64-bit timestamp type (with microsecond granularity)
+ type = arrow::timestamp(arrow::TimeUnit::MICRO);
+ // A list type of single-precision floating-point values
+ type = arrow::list(arrow::float32());
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/examples.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/examples.rst.txt b/docs/latest/_sources/cpp/examples.rst.txt
new file mode 100644
index 0000000..5f4372f
--- /dev/null
+++ b/docs/latest/_sources/cpp/examples.rst.txt
@@ -0,0 +1,30 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+Examples
+========
+
+Row to columnar conversion
+--------------------------
+
+The following example converts an array of structs to a :class:`arrow::Table`
+instance, and then converts it back to the original array of structs.
+
+.. literalinclude:: ../../../cpp/examples/arrow/row-wise-conversion-example.cc
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/getting_started.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/getting_started.rst.txt b/docs/latest/_sources/cpp/getting_started.rst.txt
new file mode 100644
index 0000000..7c55b76
--- /dev/null
+++ b/docs/latest/_sources/cpp/getting_started.rst.txt
@@ -0,0 +1,31 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+Getting Started
+===============
+
+.. toctree::
+
+ overview
+ conventions
+ memory
+ arrays
+ datatypes
+ tables
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/index.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/index.rst.txt b/docs/latest/_sources/cpp/index.rst.txt
new file mode 100644
index 0000000..1d70e6a
--- /dev/null
+++ b/docs/latest/_sources/cpp/index.rst.txt
@@ -0,0 +1,32 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+C++ Implementation
+==================
+
+.. toctree::
+ :maxdepth: 2
+
+ getting_started
+ examples
+ api
+
+.. TODO add "topics" chapter
+.. - nested arrays
+.. - dictionary encoding
+
+.. TODO add "building" or "development" chapter
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/memory.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/memory.rst.txt b/docs/latest/_sources/cpp/memory.rst.txt
new file mode 100644
index 0000000..23b4725
--- /dev/null
+++ b/docs/latest/_sources/cpp/memory.rst.txt
@@ -0,0 +1,127 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+=================
+Memory Management
+=================
+
+Buffers
+=======
+
+To avoid passing around raw data pointers with varying and non-obvious
+lifetime rules, Arrow provides a generic abstraction called :class:`arrow::Buffer`.
+A Buffer encapsulates a pointer and data size, and generally also ties its
+lifetime to that of an underlying provider (in other words, a Buffer should
+*always* point to valid memory till its destruction). Buffers are untyped:
+they simply denote a physical memory area regardless of its intended meaning
+or interpretation.
+
+Buffers may be allocated by Arrow itself , or by third-party routines.
+For example, it is possible to pass the data of a Python bytestring as a Arrow
+buffer, keeping the Python object alive as necessary.
+
+In addition, buffers come in various flavours: mutable or not, resizable or
+not. Generally, you will hold a mutable buffer when building up a piece
+of data, then it will be frozen as an immutable container such as an
+:doc:`array <arrays>`.
+
+.. note::
+ Some buffers may point to non-CPU memory, such as GPU-backed memory
+ provided by a CUDA context. If you're writing a GPU-aware application,
+ you will need to be careful not to interpret a GPU memory pointer as
+ a CPU-reachable pointer, or vice-versa.
+
+Accessing Buffer Memory
+-----------------------
+
+Buffers provide fast access to the underlying memory using the
+:func:`~arrow::Buffer::size` and :func:`~arrow::Buffer::data` accessors
+(or :func:`~arrow::Buffer::mutable_data` for writable access to a mutable
+buffer).
+
+Slicing
+-------
+
+It is possible to make zero-copy slices of buffers, to obtain a buffer
+referring to some contiguous subset of the underlying data. This is done
+by calling the :func:`arrow::SliceBuffer` and :func:`arrow::SliceMutableBuffer`
+functions.
+
+Allocating a Buffer
+-------------------
+
+You can allocate a buffer yourself by calling one of the
+:func:`arrow::AllocateBuffer` or :func:`arrow::AllocateResizableBuffer`
+overloads::
+
+ std::shared_ptr<arrow::Buffer> buffer;
+
+ if (!arrow::AllocateBuffer(4096, &buffer).ok()) {
+ // ... handle allocation error
+ }
+ uint8_t* buffer_data = buffer->mutable_data();
+ memcpy(buffer_data, "hello world", 11);
+
+Allocating a buffer this way ensures it is 64-bytes aligned and padded
+as recommended by the :doc:`Arrow memory specification <../format/Layout>`.
+
+Building a Buffer
+-----------------
+
+You can also allocate *and* build a Buffer incrementally, using the
+:class:`arrow::BufferBuilder` API::
+
+ BufferBuilder builder;
+ builder.Resize(11);
+ builder.Append("hello ", 6);
+ builder.Append("world", 5);
+
+ std::shared_ptr<arrow::Buffer> buffer;
+ if (!builder.Finish(&buffer).ok()) {
+ // ... handle buffer allocation error
+ }
+
+Memory Pools
+============
+
+When allocating a Buffer using the Arrow C++ API, the buffer's underlying
+memory is allocated by a :class:`arrow::MemoryPool` instance. Usually this
+will be the process-wide *default memory pool*, but many Arrow APIs allow
+you to pass another MemoryPool instance for their internal allocations.
+
+Memory pools are used for large long-lived data such as array buffers.
+Other data, such as small C++ objects and temporary workspaces, usually
+goes through the regular C++ allocators.
+
+Default Memory Pool
+-------------------
+
+Depending on how Arrow was compiled, the default memory pool may use the
+standard C ``malloc`` allocator, or a `jemalloc <http://jemalloc.net/>`_ heap.
+
+STL Integration
+---------------
+
+If you wish to use a Arrow memory pool to allocate the data of STL containers,
+you can do so using the :class:`arrow::stl_allocator` wrapper.
+
+Conversely, you can also use a STL allocator to allocate Arrow memory,
+using the :class:`arrow::STLMemoryPool` class. However, this may be less
+performant, as STL allocators don't provide a resizing operation.
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/overview.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/overview.rst.txt b/docs/latest/_sources/cpp/overview.rst.txt
new file mode 100644
index 0000000..490efc1
--- /dev/null
+++ b/docs/latest/_sources/cpp/overview.rst.txt
@@ -0,0 +1,93 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+High-Level Overview
+===================
+
+The Arrow C++ library is comprised of different parts, each of which serves
+a specific purpose.
+
+The physical layer
+------------------
+
+**Memory management** abstractions provide a uniform API over memory that
+may be allocated through various means, such as heap allocation, the memory
+mapping of a file or a static memory area. In particular, the **buffer**
+abstraction represents a contiguous area of physical data.
+
+The one-dimensional layer
+-------------------------
+
+**Data types** govern the *logical* interpretation of *physical* data.
+Many operations in Arrow are parametered, at compile-time or at runtime,
+by a data type.
+
+**Arrays** assemble one or several buffers with a data type, allowing to
+view them as a logical contiguous sequence of values (possibly nested).
+
+**Chunked arrays** are a generalization of arrays, comprising several same-type
+arrays into a longer logical sequence of values.
+
+The two-dimensional layer
+-------------------------
+
+**Schemas** describe a logical collection of several pieces of data,
+each with a distinct name and type, and optional metadata.
+
+**Columns** are like chunked arrays, but with optional metadata.
+
+**Tables** are collections of columns in accordance to a schema. They are
+the most capable dataset-providing abstraction in Arrow.
+
+**Record batches** are collections of contiguous arrays, described
+by a schema. They allow incremental construction or serialization of tables.
+
+The compute layer
+-----------------
+
+**Datums** are flexible dataset references, able to hold for example an array or table
+reference.
+
+**Kernels** are specialized computation functions running in a loop over a
+given set of datums representing input and output parameters to the functions.
+
+The IO layer
+------------
+
+**Streams** allow untyped sequential or seekable access over external data
+of various kinds (for example compressed or memory-mapped).
+
+The Inter-Process Communication (IPC) layer
+-------------------------------------------
+
+A **messaging format** allows interchange of Arrow data between processes, using
+as few copies as possible.
+
+The file formats layer
+----------------------
+
+Reading and writing Arrow data from/to various file formats is possible, for
+example **Parquet**, **CSV**, **Orc** or the Arrow-specific **Feather** format.
+
+The devices layer
+-----------------
+
+Basic **CUDA** integration is provided, allowing to describe Arrow data backed
+by GPU-allocated memory.
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/cpp/tables.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/cpp/tables.rst.txt b/docs/latest/_sources/cpp/tables.rst.txt
new file mode 100644
index 0000000..d42f0c6
--- /dev/null
+++ b/docs/latest/_sources/cpp/tables.rst.txt
@@ -0,0 +1,87 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+.. default-domain:: cpp
+.. highlight:: cpp
+
+========================
+Two-dimensional Datasets
+========================
+
+While arrays and chunked arrays represent a one-dimensional sequence of
+homogenous values, data often comes in the form of two-dimensional sets of
+heterogenous data (such as database tables, CSV files...). Arrow provides
+several abstractions to handle such data conveniently and efficiently.
+
+Fields
+======
+
+Fields are used to denote the particular columns of a table (and also
+the particular members of a nested data type such as :class:`arrow::StructType`).
+A field, i.e. an instance of :class:`arrow::Field`, holds together a data
+type, a field name and some optional metadata.
+
+The recommended way to create a field is to call the :func:`arrow::field`
+factory function.
+
+Schemas
+=======
+
+A schema describes the overall structure of a two-dimensional dataset such
+as a table. It holds a sequence of fields together with some optional
+schema-wide metadata (in addition to per-field metadata). The recommended
+way to create a schema is to call one the :func:`arrow::schema` factory
+function overloads::
+
+ // Create a schema describing datasets with two columns:
+ // a int32 column "A" and a utf8-encoded string column "B"
+ std::shared_ptr<arrow::Field> field_a, field_b;
+ std::shared_ptr<arrow::Schema> schema;
+
+ field_a = arrow::field("A", arrow::int32());
+ field_b = arrow::field("B", arrow::utf8());
+ schema = arrow::schema({field_a, field_b});
+
+Columns
+=======
+
+A :class:`arrow::Column` is a chunked array tied together with a field.
+The field describes the column's name (for lookup in a larger dataset)
+and its metadata.
+
+Tables
+======
+
+A :class:`arrow::Table` is a two-dimensional dataset of a number of columns,
+together with a schema. The columns' names and types must match the schema.
+Also, each column must have the same logical length in number of elements
+(although each column can be chunked in a different way).
+
+Record Batches
+==============
+
+A :class:`arrow::RecordBatch` is a two-dimensional dataset of a number of
+contiguous arrays, each the same length. Like a table, a record batch also
+has a schema which must match its arrays' datatypes.
+
+Record batches are a convenient unit of work for various serialization
+and computation functions, possibly incremental.
+
+A table can be streamed as an arbitrary number of record batches using
+a :class:`arrow::TableBatchReader`. Conversely, a logical sequence of
+record batches can be assembled to form a table using one of the
+:func:`arrow::Table::FromRecordBatches` factory function overloads.
http://git-wip-us.apache.org/repos/asf/arrow-site/blob/62ef7145/docs/latest/_sources/format/Guidelines.rst.txt
----------------------------------------------------------------------
diff --git a/docs/latest/_sources/format/Guidelines.rst.txt b/docs/latest/_sources/format/Guidelines.rst.txt
new file mode 100644
index 0000000..5b03220
--- /dev/null
+++ b/docs/latest/_sources/format/Guidelines.rst.txt
@@ -0,0 +1,43 @@
+.. Licensed to the Apache Software Foundation (ASF) under one
+.. or more contributor license agreements. See the NOTICE file
+.. distributed with this work for additional information
+.. regarding copyright ownership. The ASF licenses this file
+.. to you under the Apache License, Version 2.0 (the
+.. "License"); you may not use this file except in compliance
+.. with the License. You may obtain a copy of the License at
+
+.. http://www.apache.org/licenses/LICENSE-2.0
+
+.. Unless required by applicable law or agreed to in writing,
+.. software distributed under the License is distributed on an
+.. "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+.. KIND, either express or implied. See the License for the
+.. specific language governing permissions and limitations
+.. under the License.
+
+Implementation guidelines
+=========================
+
+An execution engine (or framework, or UDF executor, or storage engine, etc) can implements only a subset of the Arrow spec and/or extend it given the following constraints:
+
+Implementing a subset the spec
+------------------------------
+
+If only producing (and not consuming) arrow vectors.
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Any subset of the vector spec and the corresponding metadata can be implemented.
+
+If consuming and producing vectors
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+There is a minimal subset of vectors to be supported.
+Production of a subset of vectors and their corresponding metadata is always fine.
+Consumption of vectors should at least convert the unsupported input vectors to the supported subset (for example Timestamp.millis to timestamp.micros or int32 to int64)
+
+Extensibility
+-------------
+
+An execution engine implementor can also extend their memory representation with their own vectors internally as long as they are never exposed. Before sending data to another system expecting Arrow data these custom vectors should be converted to a type that exist in the Arrow spec.
+An example of this is operating on compressed data.
+These custom vectors are not exchanged externally and there is no support for custom metadata.