<?xml version="1.0" encoding="UTF-8"?>
<!--
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.
-->
<!DOCTYPE concept PUBLIC "-//OASIS//DTD DITA Concept//EN" "concept.dtd">
<concept id="parquet_fallback_schema_resolution" rev="2.6.0 IMPALA-2835">

  <title>PARQUET_FALLBACK_SCHEMA_RESOLUTION Query Option (<keyword keyref="impala26"/> or higher only)</title>
  <titlealts audience="PDF"><navtitle>PARQUET_FALLBACK_SCHEMA_RESOLUTION</navtitle></titlealts>
  <prolog>
    <metadata>
      <data name="Category" value="Impala"/>
      <data name="Category" value="Impala Query Options"/>
      <data name="Category" value="Parquet"/>
      <data name="Category" value="Schemas"/>
      <data name="Category" value="Developers"/>
      <data name="Category" value="Data Analysts"/>
    </metadata>
  </prolog>

  <conbody>

    <p rev="2.6.0 IMPALA-2835">
      <indexterm audience="hidden">PARQUET_FALLBACK_SCHEMA_RESOLUTION query option</indexterm>
      The <codeph>PARQUET_FALLBACK_SCHEMA_RESOLUTION</codeph> query option allows Impala to look
      up columns within Parquet files by column name, rather than column order,
      when necessary.
      The allowed values are:
      <ul>
        <li>
          POSITION (0)
        </li>
        <li>
          NAME (1)
        </li>
      </ul>
    </p>

    <p conref="../shared/impala_common.xml#common/usage_notes_blurb"/>
    <p>
      By default, Impala looks up columns within a Parquet file based on
      the order of columns in the table.
      The <codeph>name</codeph> setting for this option enables behavior for
      Impala queries similar to the Hive setting <codeph>parquet.column.index access=false</codeph>.
      It also allows Impala to query Parquet files created by Hive with the
      <codeph>parquet.column.index.access=false</codeph> setting in effect.
    </p>

    <p>
      <b>Type:</b> integer or string
    </p>

    <p conref="../shared/impala_common.xml#common/added_in_260"/>

    <p conref="../shared/impala_common.xml#common/related_info"/>
    <p>
      <xref href="impala_parquet.xml#parquet_schema_evolution"/>
    </p>

  </conbody>
</concept>
