diff --git a/.gitmodules b/.gitmodules
index 7d975031c5433567c184b5f04cf4f8bc6245c46d..6075b7e924327d99cc7703b45e2bfbf0d6dd7d76 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -128,6 +128,9 @@
 [submodule "contrib/icu"]
 	path = contrib/icu
 	url = https://github.com/unicode-org/icu.git
+[submodule "contrib/flatbuffers"]
+	path = contrib/flatbuffers
+	url = https://github.com/google/flatbuffers.git
 [submodule "contrib/libc-headers"]
 	path = contrib/libc-headers
 	url = https://github.com/ClickHouse-Extras/libc-headers.git
diff --git a/cmake/find/parquet.cmake b/cmake/find/parquet.cmake
index d302fd64e1e876da84b24b329ef7a17ce8e2db10..6501a05d7bb38fbb48450a62f64841d7681542a1 100644
--- a/cmake/find/parquet.cmake
+++ b/cmake/find/parquet.cmake
@@ -54,10 +54,12 @@ elseif(NOT MISSING_INTERNAL_PARQUET_LIBRARY AND NOT OS_FREEBSD)
     endif()
 
     if(${USE_STATIC_LIBRARIES})
+        set(FLATBUFFERS_LIBRARY flatbuffers)
         set(ARROW_LIBRARY arrow_static)
         set(PARQUET_LIBRARY parquet_static)
         set(THRIFT_LIBRARY thrift_static)
     else()
+        set(FLATBUFFERS_LIBRARY flatbuffers_shared)
         set(ARROW_LIBRARY arrow_shared)
         set(PARQUET_LIBRARY parquet_shared)
         if(USE_INTERNAL_PARQUET_LIBRARY_NATIVE_CMAKE)
@@ -74,7 +76,7 @@ endif()
 endif()
 
 if(USE_PARQUET)
-    message(STATUS "Using Parquet: ${ARROW_LIBRARY}:${ARROW_INCLUDE_DIR} ; ${PARQUET_LIBRARY}:${PARQUET_INCLUDE_DIR} ; ${THRIFT_LIBRARY}")
+    message(STATUS "Using Parquet: ${ARROW_LIBRARY}:${ARROW_INCLUDE_DIR} ; ${PARQUET_LIBRARY}:${PARQUET_INCLUDE_DIR} ; ${THRIFT_LIBRARY} ; ${FLATBUFFERS_LIBRARY}")
 else()
     message(STATUS "Building without Parquet support")
 endif()
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index 415d3a88703d5b9370f7fe33ed8024e0a768c171..80ccd8cce585d2443758d124aefbe2ff1ee1c9f7 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -159,6 +159,8 @@ if (USE_INTERNAL_PARQUET_LIBRARY_NATIVE_CMAKE)
     set (ARROW_PARQUET ON CACHE INTERNAL "")
     set (ARROW_VERBOSE_THIRDPARTY_BUILD ON CACHE INTERNAL "")
     set (ARROW_BUILD_SHARED 1 CACHE INTERNAL "")
+    set (ARROW_BUILD_UTILITIES OFF CACHE INTERNAL "")
+    set (ARROW_BUILD_INTEGRATION OFF CACHE INTERNAL "")
     set (ARROW_BOOST_HEADER_ONLY ON CACHE INTERNAL "")
     set (Boost_FOUND 1 CACHE INTERNAL "")
     if (MAKE_STATIC_LIBRARIES)
diff --git a/contrib/arrow b/contrib/arrow
index 87ac6fddaf21d0b4ee8b8090533ff293db0da1b4..b789226ccb2124285792107c758bb3b40b3d082a 160000
--- a/contrib/arrow
+++ b/contrib/arrow
@@ -1 +1 @@
-Subproject commit 87ac6fddaf21d0b4ee8b8090533ff293db0da1b4
+Subproject commit b789226ccb2124285792107c758bb3b40b3d082a
diff --git a/contrib/arrow-cmake/CMakeLists.txt b/contrib/arrow-cmake/CMakeLists.txt
index 3ba24f49498d8f2cc7bd4c2f1e8de45bc7133393..ccf3021d143901b0cb1f27c8a6e5bfbccb1f1bd9 100644
--- a/contrib/arrow-cmake/CMakeLists.txt
+++ b/contrib/arrow-cmake/CMakeLists.txt
@@ -1,46 +1,48 @@
+include(ExternalProject)
+
 # === thrift
 
 set(LIBRARY_DIR ${ClickHouse_SOURCE_DIR}/contrib/thrift/lib/cpp)
 # contrib/thrift/lib/cpp/CMakeLists.txt
 set(thriftcpp_SOURCES
-   ${LIBRARY_DIR}/src/thrift/TApplicationException.cpp
-   ${LIBRARY_DIR}/src/thrift/TOutput.cpp
-   ${LIBRARY_DIR}/src/thrift/async/TAsyncChannel.cpp
-   ${LIBRARY_DIR}/src/thrift/async/TAsyncProtocolProcessor.cpp
-   ${LIBRARY_DIR}/src/thrift/async/TConcurrentClientSyncInfo.h
-   ${LIBRARY_DIR}/src/thrift/async/TConcurrentClientSyncInfo.cpp
-   ${LIBRARY_DIR}/src/thrift/concurrency/ThreadManager.cpp
-   ${LIBRARY_DIR}/src/thrift/concurrency/TimerManager.cpp
-   ${LIBRARY_DIR}/src/thrift/concurrency/Util.cpp
-   ${LIBRARY_DIR}/src/thrift/processor/PeekProcessor.cpp
-   ${LIBRARY_DIR}/src/thrift/protocol/TBase64Utils.cpp
-   ${LIBRARY_DIR}/src/thrift/protocol/TDebugProtocol.cpp
-   ${LIBRARY_DIR}/src/thrift/protocol/TJSONProtocol.cpp
-   ${LIBRARY_DIR}/src/thrift/protocol/TMultiplexedProtocol.cpp
-   ${LIBRARY_DIR}/src/thrift/protocol/TProtocol.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TTransportException.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TFDTransport.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TSimpleFileTransport.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/THttpTransport.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/THttpClient.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/THttpServer.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TSocket.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TSocketPool.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TServerSocket.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TTransportUtils.cpp
-   ${LIBRARY_DIR}/src/thrift/transport/TBufferTransports.cpp
-   ${LIBRARY_DIR}/src/thrift/server/TConnectedClient.cpp
-   ${LIBRARY_DIR}/src/thrift/server/TServerFramework.cpp
-   ${LIBRARY_DIR}/src/thrift/server/TSimpleServer.cpp
-   ${LIBRARY_DIR}/src/thrift/server/TThreadPoolServer.cpp
-   ${LIBRARY_DIR}/src/thrift/server/TThreadedServer.cpp
-)
-set( thriftcpp_threads_SOURCES
-    ${LIBRARY_DIR}/src/thrift/concurrency/ThreadFactory.cpp
-    ${LIBRARY_DIR}/src/thrift/concurrency/Thread.cpp
-    ${LIBRARY_DIR}/src/thrift/concurrency/Monitor.cpp
-    ${LIBRARY_DIR}/src/thrift/concurrency/Mutex.cpp
-)
+        ${LIBRARY_DIR}/src/thrift/TApplicationException.cpp
+        ${LIBRARY_DIR}/src/thrift/TOutput.cpp
+        ${LIBRARY_DIR}/src/thrift/async/TAsyncChannel.cpp
+        ${LIBRARY_DIR}/src/thrift/async/TAsyncProtocolProcessor.cpp
+        ${LIBRARY_DIR}/src/thrift/async/TConcurrentClientSyncInfo.h
+        ${LIBRARY_DIR}/src/thrift/async/TConcurrentClientSyncInfo.cpp
+        ${LIBRARY_DIR}/src/thrift/concurrency/ThreadManager.cpp
+        ${LIBRARY_DIR}/src/thrift/concurrency/TimerManager.cpp
+        ${LIBRARY_DIR}/src/thrift/concurrency/Util.cpp
+        ${LIBRARY_DIR}/src/thrift/processor/PeekProcessor.cpp
+        ${LIBRARY_DIR}/src/thrift/protocol/TBase64Utils.cpp
+        ${LIBRARY_DIR}/src/thrift/protocol/TDebugProtocol.cpp
+        ${LIBRARY_DIR}/src/thrift/protocol/TJSONProtocol.cpp
+        ${LIBRARY_DIR}/src/thrift/protocol/TMultiplexedProtocol.cpp
+        ${LIBRARY_DIR}/src/thrift/protocol/TProtocol.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TTransportException.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TFDTransport.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TSimpleFileTransport.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/THttpTransport.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/THttpClient.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/THttpServer.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TSocket.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TSocketPool.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TServerSocket.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TTransportUtils.cpp
+        ${LIBRARY_DIR}/src/thrift/transport/TBufferTransports.cpp
+        ${LIBRARY_DIR}/src/thrift/server/TConnectedClient.cpp
+        ${LIBRARY_DIR}/src/thrift/server/TServerFramework.cpp
+        ${LIBRARY_DIR}/src/thrift/server/TSimpleServer.cpp
+        ${LIBRARY_DIR}/src/thrift/server/TThreadPoolServer.cpp
+        ${LIBRARY_DIR}/src/thrift/server/TThreadedServer.cpp
+        )
+set(thriftcpp_threads_SOURCES
+        ${LIBRARY_DIR}/src/thrift/concurrency/ThreadFactory.cpp
+        ${LIBRARY_DIR}/src/thrift/concurrency/Thread.cpp
+        ${LIBRARY_DIR}/src/thrift/concurrency/Monitor.cpp
+        ${LIBRARY_DIR}/src/thrift/concurrency/Mutex.cpp
+        )
 add_library(${THRIFT_LIBRARY} ${thriftcpp_SOURCES} ${thriftcpp_threads_SOURCES})
 set_target_properties(${THRIFT_LIBRARY} PROPERTIES CXX_STANDARD 14) # REMOVE after https://github.com/apache/thrift/pull/1641
 target_include_directories(${THRIFT_LIBRARY} SYSTEM PUBLIC ${ClickHouse_SOURCE_DIR}/contrib/thrift/lib/cpp/src PRIVATE ${Boost_INCLUDE_DIRS})
@@ -70,22 +72,88 @@ add_custom_command(OUTPUT orc_proto.pb.h orc_proto.pb.cc
         --cpp_out="${CMAKE_CURRENT_BINARY_DIR}"
         "${PROTO_DIR}/orc_proto.proto")
 
+
+# === flatbuffers
+
+##############################################################
+# fbs - Step 1: build flatbuffers lib and flatc compiler
+##############################################################
+set(FLATBUFFERS_SRC_DIR ${ClickHouse_SOURCE_DIR}/contrib/flatbuffers)
+set(FLATBUFFERS_BINARY_DIR ${ClickHouse_BINARY_DIR}/contrib/flatbuffers)
+set(FLATBUFFERS_INCLUDE_DIR ${FLATBUFFERS_SRC_DIR}/include)
+set(FLATBUFFERS_COMPILER "${FLATBUFFERS_BINARY_DIR}/flatc")
+
+# set flatbuffers CMake options
+if (${USE_STATIC_LIBRARIES})
+    set(FLATBUFFERS_BUILD_FLATLIB ON CACHE BOOL "Enable the build of the flatbuffers library")
+    set(FLATBUFFERS_BUILD_SHAREDLIB OFF CACHE BOOL "Disable the build of the flatbuffers shared library")
+else ()
+    set(FLATBUFFERS_BUILD_SHAREDLIB ON CACHE BOOL "Enable the build of the flatbuffers shared library")
+    set(FLATBUFFERS_BUILD_FLATLIB OFF CACHE BOOL "Disable the build of the flatbuffers library")
+endif ()
+set(FLATBUFFERS_BUILD_FLATC ON CACHE BOOL "Build flatbuffers compiler")
+set(FLATBUFFERS_BUILD_TESTS OFF CACHE BOOL "Skip flatbuffers tests")
+
+add_subdirectory(${FLATBUFFERS_SRC_DIR} "${FLATBUFFERS_BINARY_DIR}")
+
+###################################
+# fbs - Step 2: compile *.fbs files
+###################################
+set(ARROW_IPC_SRC_DIR ${ARROW_SRC_DIR}/arrow/ipc)
+set(ARROW_FORMAT_SRC_DIR ${ARROW_SRC_DIR}/../../format)
+
+set(FLATBUFFERS_COMPILED_OUT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src/arrow/ipc)
+
+set(FBS_OUTPUT_FILES "${FLATBUFFERS_COMPILED_OUT_DIR}/File_generated.h" "${FLATBUFFERS_COMPILED_OUT_DIR}/Message_generated.h"
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/feather_generated.h")
+
+set(FBS_SRC
+        ${ARROW_FORMAT_SRC_DIR}/Message.fbs
+        ${ARROW_FORMAT_SRC_DIR}/File.fbs
+        ${ARROW_FORMAT_SRC_DIR}/Schema.fbs
+        ${ARROW_FORMAT_SRC_DIR}/Tensor.fbs
+        ${ARROW_FORMAT_SRC_DIR}/SparseTensor.fbs
+        ${ARROW_IPC_SRC_DIR}/feather.fbs)
+
+foreach (FIL ${FBS_SRC})
+    get_filename_component(ABS_FIL ${FIL} ABSOLUTE)
+    list(APPEND ABS_FBS_SRC ${ABS_FIL})
+endforeach ()
+
+message(STATUS "FLATBUFFERS_LIBRARY: ${FLATBUFFERS_LIBRARY}, FLATBUFFERS_COMPILER: ${FLATBUFFERS_COMPILER}")
+message(STATUS "FLATBUFFERS_COMPILED_OUT_DIR: ${FLATBUFFERS_COMPILED_OUT_DIR}")
+message(STATUS "flatc: ${FLATBUFFERS_COMPILER} -c -o ${FLATBUFFERS_COMPILED_OUT_DIR}/ ${ABS_FBS_SRC}")
+
+add_custom_command(OUTPUT ${FBS_OUTPUT_FILES}
+        COMMAND ${FLATBUFFERS_COMPILER}
+        -c
+        -o
+        ${FLATBUFFERS_COMPILED_OUT_DIR}/
+        ${ABS_FBS_SRC}
+        DEPENDS flatc ${ABS_FBS_SRC}
+        COMMENT "Running flatc compiler on ${ABS_FBS_SRC}"
+        VERBATIM)
+
+add_custom_target(metadata_fbs DEPENDS ${FBS_OUTPUT_FILES})
+add_dependencies(metadata_fbs flatc)
+
 # arrow-cmake cmake file calling orc cmake subroutine which detects certain compiler features. 
 # Apple Clang compiler failed to compile this code without specifying c++11 standard. 
 # As result these compiler features detected as absent. In result it failed to compile orc itself.
 # In orc makefile there is code that sets flags, but arrow-cmake ignores these flags.
 if (CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-  set (CXX11_FLAGS "-std=c++0x")
-endif()
+    set(CXX11_FLAGS "-std=c++0x")
+endif ()
 
 include(${ClickHouse_SOURCE_DIR}/contrib/orc/cmake_modules/CheckSourceCompiles.cmake)
 include(orc_check.cmake)
-configure_file("${ORC_INCLUDE_DIR}/orc/orc-config.hh.in"  "${ORC_BUILD_INCLUDE_DIR}/orc/orc-config.hh")
+configure_file("${ORC_INCLUDE_DIR}/orc/orc-config.hh.in" "${ORC_BUILD_INCLUDE_DIR}/orc/orc-config.hh")
 configure_file("${ORC_SOURCE_SRC_DIR}/Adaptor.hh.in" "${ORC_BUILD_INCLUDE_DIR}/Adaptor.hh")
 
 
 set(ORC_SRCS
         ${ARROW_SRC_DIR}/arrow/adapters/orc/adapter.cc
+        ${ARROW_SRC_DIR}/arrow/adapters/orc/adapter_util.cc
         ${ORC_SOURCE_SRC_DIR}/Exceptions.cc
         ${ORC_SOURCE_SRC_DIR}/OrcFile.cc
         ${ORC_SOURCE_SRC_DIR}/Reader.cc
@@ -119,126 +187,165 @@ set(ORC_SRCS
 # === arrow
 
 set(LIBRARY_DIR ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src/arrow)
+
+configure_file("${LIBRARY_DIR}/util/config.h.cmake" "${CMAKE_CURRENT_SOURCE_DIR}/cpp/src/arrow/util/config.h")
+
 # arrow/cpp/src/arrow/CMakeLists.txt
 set(ARROW_SRCS
-  ${LIBRARY_DIR}/array.cc
-
-  ${LIBRARY_DIR}/builder.cc
-  ${LIBRARY_DIR}/array/builder_adaptive.cc
-  ${LIBRARY_DIR}/array/builder_base.cc
-  ${LIBRARY_DIR}/array/builder_binary.cc
-  ${LIBRARY_DIR}/array/builder_decimal.cc
-  ${LIBRARY_DIR}/array/builder_dict.cc
-  ${LIBRARY_DIR}/array/builder_nested.cc
-  ${LIBRARY_DIR}/array/builder_primitive.cc
-
-  ${LIBRARY_DIR}/buffer.cc
-  ${LIBRARY_DIR}/compare.cc
-  ${LIBRARY_DIR}/memory_pool.cc
-  ${LIBRARY_DIR}/pretty_print.cc
-  ${LIBRARY_DIR}/record_batch.cc
-  ${LIBRARY_DIR}/status.cc
-  ${LIBRARY_DIR}/table.cc
-  ${LIBRARY_DIR}/table_builder.cc
-  ${LIBRARY_DIR}/tensor.cc
-  ${LIBRARY_DIR}/sparse_tensor.cc
-  ${LIBRARY_DIR}/type.cc
-  ${LIBRARY_DIR}/visitor.cc
-
-  ${LIBRARY_DIR}/csv/converter.cc
-  ${LIBRARY_DIR}/csv/chunker.cc
-  ${LIBRARY_DIR}/csv/column-builder.cc
-  ${LIBRARY_DIR}/csv/options.cc
-  ${LIBRARY_DIR}/csv/parser.cc
-  ${LIBRARY_DIR}/csv/reader.cc
-
-  ${LIBRARY_DIR}/io/buffered.cc
-  ${LIBRARY_DIR}/io/compressed.cc
-  ${LIBRARY_DIR}/io/file.cc
-  ${LIBRARY_DIR}/io/interfaces.cc
-  ${LIBRARY_DIR}/io/memory.cc
-  ${LIBRARY_DIR}/io/readahead.cc
-
-  ${LIBRARY_DIR}/util/bit-util.cc
-  ${LIBRARY_DIR}/util/compression.cc
-  ${LIBRARY_DIR}/util/cpu-info.cc
-  ${LIBRARY_DIR}/util/decimal.cc
-  ${LIBRARY_DIR}/util/int-util.cc
-  ${LIBRARY_DIR}/util/io-util.cc
-  ${LIBRARY_DIR}/util/logging.cc
-  ${LIBRARY_DIR}/util/key_value_metadata.cc
-  ${LIBRARY_DIR}/util/task-group.cc
-  ${LIBRARY_DIR}/util/thread-pool.cc
-  ${LIBRARY_DIR}/util/trie.cc
-  ${LIBRARY_DIR}/util/utf8.cc
-  ${ORC_SRCS}
-)
+        ${LIBRARY_DIR}/array.cc
+        ${LIBRARY_DIR}/buffer.cc
+        ${LIBRARY_DIR}/builder.cc
+        ${LIBRARY_DIR}/compare.cc
+        ${LIBRARY_DIR}/extension_type.cc
+        ${LIBRARY_DIR}/memory_pool.cc
+        ${LIBRARY_DIR}/pretty_print.cc
+        ${LIBRARY_DIR}/record_batch.cc
+        ${LIBRARY_DIR}/result.cc
+        ${LIBRARY_DIR}/scalar.cc
+        ${LIBRARY_DIR}/sparse_tensor.cc
+        ${LIBRARY_DIR}/status.cc
+        ${LIBRARY_DIR}/table_builder.cc
+        ${LIBRARY_DIR}/table.cc
+        ${LIBRARY_DIR}/tensor.cc
+        ${LIBRARY_DIR}/type.cc
+        ${LIBRARY_DIR}/visitor.cc
+
+        ${LIBRARY_DIR}/array/builder_adaptive.cc
+        ${LIBRARY_DIR}/array/builder_base.cc
+        ${LIBRARY_DIR}/array/builder_binary.cc
+        ${LIBRARY_DIR}/array/builder_decimal.cc
+        ${LIBRARY_DIR}/array/builder_dict.cc
+        ${LIBRARY_DIR}/array/builder_nested.cc
+        ${LIBRARY_DIR}/array/builder_primitive.cc
+        ${LIBRARY_DIR}/array/builder_union.cc
+        ${LIBRARY_DIR}/array/concatenate.cc
+        ${LIBRARY_DIR}/array/dict_internal.cc
+        ${LIBRARY_DIR}/array/diff.cc
+
+        ${LIBRARY_DIR}/csv/converter.cc
+        ${LIBRARY_DIR}/csv/chunker.cc
+        ${LIBRARY_DIR}/csv/column_builder.cc
+        ${LIBRARY_DIR}/csv/options.cc
+        ${LIBRARY_DIR}/csv/parser.cc
+        ${LIBRARY_DIR}/csv/reader.cc
+
+        ${LIBRARY_DIR}/ipc/dictionary.cc
+        ${LIBRARY_DIR}/ipc/feather.cc
+#        ${LIBRARY_DIR}/ipc/file_to_stream.cc
+        ${LIBRARY_DIR}/ipc/message.cc
+        ${LIBRARY_DIR}/ipc/metadata_internal.cc
+        ${LIBRARY_DIR}/ipc/options.cc
+        ${LIBRARY_DIR}/ipc/reader.cc
+#        ${LIBRARY_DIR}/ipc/stream_to_file.cc
+        ${LIBRARY_DIR}/ipc/writer.cc
+
+        ${LIBRARY_DIR}/io/buffered.cc
+        ${LIBRARY_DIR}/io/compressed.cc
+        ${LIBRARY_DIR}/io/file.cc
+        ${LIBRARY_DIR}/io/interfaces.cc
+        ${LIBRARY_DIR}/io/memory.cc
+        ${LIBRARY_DIR}/io/readahead.cc
+        ${LIBRARY_DIR}/io/slow.cc
+
+        ${LIBRARY_DIR}/util/basic_decimal.cc
+        ${LIBRARY_DIR}/util/bit_util.cc
+        #  ${LIBRARY_DIR}/util/compression_brotli.cc
+#        ${LIBRARY_DIR}/util/compression_bz2.cc
+        ${LIBRARY_DIR}/util/compression.cc
+        ${LIBRARY_DIR}/util/compression_lz4.cc
+        ${LIBRARY_DIR}/util/compression_snappy.cc
+        ${LIBRARY_DIR}/util/compression_zlib.cc
+        ${LIBRARY_DIR}/util/compression_zstd.cc
+        ${LIBRARY_DIR}/util/cpu_info.cc
+        ${LIBRARY_DIR}/util/decimal.cc
+        ${LIBRARY_DIR}/util/int_util.cc
+        ${LIBRARY_DIR}/util/io_util.cc
+        ${LIBRARY_DIR}/util/key_value_metadata.cc
+        ${LIBRARY_DIR}/util/logging.cc
+        ${LIBRARY_DIR}/util/memory.cc
+        ${LIBRARY_DIR}/util/string_builder.cc
+        ${LIBRARY_DIR}/util/string.cc
+        ${LIBRARY_DIR}/util/task_group.cc
+        ${LIBRARY_DIR}/util/thread_pool.cc
+        ${LIBRARY_DIR}/util/trie.cc
+        #  ${LIBRARY_DIR}/util/uri.cc
+        ${LIBRARY_DIR}/util/utf8.cc
+
+        ${LIBRARY_DIR}/vendored/base64.cpp
+        ${ORC_SRCS}
+        )
 
 set(ARROW_SRCS ${ARROW_SRCS}
-    ${LIBRARY_DIR}/compute/context.cc
-    ${LIBRARY_DIR}/compute/kernels/boolean.cc
-    ${LIBRARY_DIR}/compute/kernels/cast.cc
-    ${LIBRARY_DIR}/compute/kernels/hash.cc
-    ${LIBRARY_DIR}/compute/kernels/util-internal.cc
-)
+        ${LIBRARY_DIR}/compute/context.cc
+        ${LIBRARY_DIR}/compute/kernels/boolean.cc
+        ${LIBRARY_DIR}/compute/kernels/cast.cc
+        ${LIBRARY_DIR}/compute/kernels/hash.cc
+        ${LIBRARY_DIR}/compute/kernels/util_internal.cc
+        )
 
 if (LZ4_INCLUDE_DIR AND LZ4_LIBRARY)
     set(ARROW_WITH_LZ4 1)
-endif()
+endif ()
 
-if(SNAPPY_INCLUDE_DIR AND SNAPPY_LIBRARY)
+if (SNAPPY_INCLUDE_DIR AND SNAPPY_LIBRARY)
     set(ARROW_WITH_SNAPPY 1)
-endif()
+endif ()
 
-if(ZLIB_INCLUDE_DIR AND ZLIB_LIBRARIES)
+if (ZLIB_INCLUDE_DIR AND ZLIB_LIBRARIES)
     set(ARROW_WITH_ZLIB 1)
-endif()
+endif ()
 
 if (ZSTD_INCLUDE_DIR AND ZSTD_LIBRARY)
     set(ARROW_WITH_ZSTD 1)
-endif()
+endif ()
 
 if (ARROW_WITH_LZ4)
-  add_definitions(-DARROW_WITH_LZ4)
-  SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_lz4.cc ${ARROW_SRCS})
-endif()
+    add_definitions(-DARROW_WITH_LZ4)
+    SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_lz4.cc ${ARROW_SRCS})
+endif ()
 
 if (ARROW_WITH_SNAPPY)
-  add_definitions(-DARROW_WITH_SNAPPY)
-  SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_snappy.cc ${ARROW_SRCS})
-endif()
+    add_definitions(-DARROW_WITH_SNAPPY)
+    SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_snappy.cc ${ARROW_SRCS})
+endif ()
 
 if (ARROW_WITH_ZLIB)
-  add_definitions(-DARROW_WITH_ZLIB)
-  SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_zlib.cc ${ARROW_SRCS})
-endif()
+    add_definitions(-DARROW_WITH_ZLIB)
+    SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_zlib.cc ${ARROW_SRCS})
+endif ()
 
 if (ARROW_WITH_ZSTD)
-  add_definitions(-DARROW_WITH_ZSTD)
-  SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_zstd.cc ${ARROW_SRCS})
-endif()
+    add_definitions(-DARROW_WITH_ZSTD)
+    SET(ARROW_SRCS ${LIBRARY_DIR}/util/compression_zstd.cc ${ARROW_SRCS})
+endif ()
 
 
 add_library(${ARROW_LIBRARY} ${ARROW_SRCS})
 
+# Arrow dependencies
+add_dependencies(${ARROW_LIBRARY} ${FLATBUFFERS_LIBRARY} metadata_fbs)
+
+target_link_libraries(${ARROW_LIBRARY} PRIVATE boost_system_internal boost_filesystem_internal boost_regex_internal)
+target_link_libraries(${ARROW_LIBRARY} PRIVATE ${FLATBUFFERS_LIBRARY})
+
 if (USE_INTERNAL_PROTOBUF_LIBRARY)
     add_dependencies(${ARROW_LIBRARY} protoc)
-endif()
+endif ()
 
 target_include_directories(${ARROW_LIBRARY} SYSTEM PUBLIC ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src ${Boost_INCLUDE_DIRS})
 target_link_libraries(${ARROW_LIBRARY} PRIVATE ${DOUBLE_CONVERSION_LIBRARIES} ${Protobuf_LIBRARY})
 if (ARROW_WITH_LZ4)
     target_link_libraries(${ARROW_LIBRARY} PRIVATE ${LZ4_LIBRARY})
-endif()
+endif ()
 if (ARROW_WITH_SNAPPY)
     target_link_libraries(${ARROW_LIBRARY} PRIVATE ${SNAPPY_LIBRARY})
-endif()
+endif ()
 if (ARROW_WITH_ZLIB)
     target_link_libraries(${ARROW_LIBRARY} PRIVATE ${ZLIB_LIBRARIES})
-endif()
+endif ()
 if (ARROW_WITH_ZSTD)
     target_link_libraries(${ARROW_LIBRARY} PRIVATE ${ZSTD_LIBRARY})
-endif()
+endif ()
 
 target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ORC_INCLUDE_DIR})
 target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ORC_SOURCE_SRC_DIR})
@@ -248,52 +355,54 @@ target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ORC_BUILD_SRC_DIR})
 target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ORC_BUILD_INCLUDE_DIR})
 target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ORC_ADDITION_SOURCE_DIR})
 target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ARROW_SRC_DIR})
-
+target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${FLATBUFFERS_INCLUDE_DIR})
 # === parquet
 
 set(LIBRARY_DIR ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src/parquet)
 # arrow/cpp/src/parquet/CMakeLists.txt
 set(PARQUET_SRCS
-  ${LIBRARY_DIR}/arrow/reader.cc
-  ${LIBRARY_DIR}/arrow/record_reader.cc
-  ${LIBRARY_DIR}/arrow/schema.cc
-  ${LIBRARY_DIR}/arrow/writer.cc
-  ${LIBRARY_DIR}/bloom_filter.cc
-  ${LIBRARY_DIR}/column_reader.cc
-  ${LIBRARY_DIR}/column_scanner.cc
-  ${LIBRARY_DIR}/column_writer.cc
-  ${LIBRARY_DIR}/file_reader.cc
-  ${LIBRARY_DIR}/file_writer.cc
-  ${LIBRARY_DIR}/metadata.cc
-  ${LIBRARY_DIR}/murmur3.cc
-  ${LIBRARY_DIR}/printer.cc
-  ${LIBRARY_DIR}/schema.cc
-  ${LIBRARY_DIR}/statistics.cc
-  ${LIBRARY_DIR}/types.cc
-  ${LIBRARY_DIR}/util/comparison.cc
-  ${LIBRARY_DIR}/util/memory.cc
-)
+        ${LIBRARY_DIR}/arrow/reader.cc
+        ${LIBRARY_DIR}/arrow/reader_internal.cc
+        ${LIBRARY_DIR}/arrow/schema.cc
+        ${LIBRARY_DIR}/arrow/writer.cc
+        ${LIBRARY_DIR}/bloom_filter.cc
+        ${LIBRARY_DIR}/column_reader.cc
+        ${LIBRARY_DIR}/column_scanner.cc
+        ${LIBRARY_DIR}/column_writer.cc
+        ${LIBRARY_DIR}/deprecated_io.cc
+        ${LIBRARY_DIR}/encoding.cc
+        ${LIBRARY_DIR}/file_reader.cc
+        ${LIBRARY_DIR}/file_writer.cc
+        ${LIBRARY_DIR}/metadata.cc
+        ${LIBRARY_DIR}/murmur3.cc
+        ${LIBRARY_DIR}/platform.cc
+        ${LIBRARY_DIR}/printer.cc
+        ${LIBRARY_DIR}/properties.cc
+        ${LIBRARY_DIR}/schema.cc
+        ${LIBRARY_DIR}/statistics.cc
+        ${LIBRARY_DIR}/types.cc
+        )
 #list(TRANSFORM PARQUET_SRCS PREPEND ${LIBRARY_DIR}/) # cmake 3.12
 list(APPEND PARQUET_SRCS
-  ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src/parquet/parquet_constants.cpp
-  ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src/parquet/parquet_types.cpp
-)
+        ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src/parquet/parquet_constants.cpp
+        ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src/parquet/parquet_types.cpp
+        )
 add_library(${PARQUET_LIBRARY} ${PARQUET_SRCS})
 target_include_directories(${PARQUET_LIBRARY} SYSTEM PUBLIC ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src ${CMAKE_CURRENT_SOURCE_DIR}/cpp/src)
 include(${ClickHouse_SOURCE_DIR}/contrib/thrift/build/cmake/ConfigureChecks.cmake) # makes config.h
 target_link_libraries(${PARQUET_LIBRARY} PUBLIC ${ARROW_LIBRARY} PRIVATE ${THRIFT_LIBRARY} ${Boost_REGEX_LIBRARY})
 target_include_directories(${PARQUET_LIBRARY} PRIVATE ${Boost_INCLUDE_DIRS})
 
-if(SANITIZE STREQUAL "undefined")
+if (SANITIZE STREQUAL "undefined")
     target_compile_options(${PARQUET_LIBRARY} PRIVATE -fno-sanitize=undefined)
     target_compile_options(${ARROW_LIBRARY} PRIVATE -fno-sanitize=undefined)
-endif()
+endif ()
 
 # === tools
 
 set(TOOLS_DIR ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/tools/parquet)
-set(PARQUET_TOOLS parquet-dump-schema parquet-reader parquet-scan)
-foreach(TOOL ${PARQUET_TOOLS})
+set(PARQUET_TOOLS parquet_dump_schema parquet_reader parquet_scan)
+foreach (TOOL ${PARQUET_TOOLS})
     add_executable(${TOOL} ${TOOLS_DIR}/${TOOL}.cc)
     target_link_libraries(${TOOL} PRIVATE ${PARQUET_LIBRARY})
-endforeach()
+endforeach ()
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/File_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/File_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..37e2f9c7ea4a9206d70c4bf45f5ccffaaec9d1f5
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/ipc/File_generated.h
@@ -0,0 +1,181 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_FILE_ORG_APACHE_ARROW_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_FILE_ORG_APACHE_ARROW_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "Schema_generated.h"
+
+namespace org {
+namespace apache {
+namespace arrow {
+namespace flatbuf {
+
+struct Footer;
+
+struct Block;
+
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Block FLATBUFFERS_FINAL_CLASS {
+ private:
+  int64_t offset_;
+  int32_t metaDataLength_;
+  int32_t padding0__;
+  int64_t bodyLength_;
+
+ public:
+  Block() {
+    memset(static_cast<void *>(this), 0, sizeof(Block));
+  }
+  Block(int64_t _offset, int32_t _metaDataLength, int64_t _bodyLength)
+      : offset_(flatbuffers::EndianScalar(_offset)),
+        metaDataLength_(flatbuffers::EndianScalar(_metaDataLength)),
+        padding0__(0),
+        bodyLength_(flatbuffers::EndianScalar(_bodyLength)) {
+    (void)padding0__;
+  }
+  /// Index to the start of the RecordBlock (note this is past the Message header)
+  int64_t offset() const {
+    return flatbuffers::EndianScalar(offset_);
+  }
+  /// Length of the metadata
+  int32_t metaDataLength() const {
+    return flatbuffers::EndianScalar(metaDataLength_);
+  }
+  /// Length of the data (this is aligned so there can be a gap between this and
+  /// the metatdata).
+  int64_t bodyLength() const {
+    return flatbuffers::EndianScalar(bodyLength_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Block, 24);
+
+/// ----------------------------------------------------------------------
+/// Arrow File metadata
+///
+struct Footer FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VERSION = 4,
+    VT_SCHEMA = 6,
+    VT_DICTIONARIES = 8,
+    VT_RECORDBATCHES = 10
+  };
+  MetadataVersion version() const {
+    return static_cast<MetadataVersion>(GetField<int16_t>(VT_VERSION, 0));
+  }
+  const Schema *schema() const {
+    return GetPointer<const Schema *>(VT_SCHEMA);
+  }
+  const flatbuffers::Vector<const Block *> *dictionaries() const {
+    return GetPointer<const flatbuffers::Vector<const Block *> *>(VT_DICTIONARIES);
+  }
+  const flatbuffers::Vector<const Block *> *recordBatches() const {
+    return GetPointer<const flatbuffers::Vector<const Block *> *>(VT_RECORDBATCHES);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_VERSION) &&
+           VerifyOffset(verifier, VT_SCHEMA) &&
+           verifier.VerifyTable(schema()) &&
+           VerifyOffset(verifier, VT_DICTIONARIES) &&
+           verifier.VerifyVector(dictionaries()) &&
+           VerifyOffset(verifier, VT_RECORDBATCHES) &&
+           verifier.VerifyVector(recordBatches()) &&
+           verifier.EndTable();
+  }
+};
+
+struct FooterBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_version(MetadataVersion version) {
+    fbb_.AddElement<int16_t>(Footer::VT_VERSION, static_cast<int16_t>(version), 0);
+  }
+  void add_schema(flatbuffers::Offset<Schema> schema) {
+    fbb_.AddOffset(Footer::VT_SCHEMA, schema);
+  }
+  void add_dictionaries(flatbuffers::Offset<flatbuffers::Vector<const Block *>> dictionaries) {
+    fbb_.AddOffset(Footer::VT_DICTIONARIES, dictionaries);
+  }
+  void add_recordBatches(flatbuffers::Offset<flatbuffers::Vector<const Block *>> recordBatches) {
+    fbb_.AddOffset(Footer::VT_RECORDBATCHES, recordBatches);
+  }
+  explicit FooterBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  FooterBuilder &operator=(const FooterBuilder &);
+  flatbuffers::Offset<Footer> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Footer>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Footer> CreateFooter(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    MetadataVersion version = MetadataVersion_V1,
+    flatbuffers::Offset<Schema> schema = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const Block *>> dictionaries = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const Block *>> recordBatches = 0) {
+  FooterBuilder builder_(_fbb);
+  builder_.add_recordBatches(recordBatches);
+  builder_.add_dictionaries(dictionaries);
+  builder_.add_schema(schema);
+  builder_.add_version(version);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Footer> CreateFooterDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    MetadataVersion version = MetadataVersion_V1,
+    flatbuffers::Offset<Schema> schema = 0,
+    const std::vector<Block> *dictionaries = nullptr,
+    const std::vector<Block> *recordBatches = nullptr) {
+  auto dictionaries__ = dictionaries ? _fbb.CreateVectorOfStructs<Block>(*dictionaries) : 0;
+  auto recordBatches__ = recordBatches ? _fbb.CreateVectorOfStructs<Block>(*recordBatches) : 0;
+  return org::apache::arrow::flatbuf::CreateFooter(
+      _fbb,
+      version,
+      schema,
+      dictionaries__,
+      recordBatches__);
+}
+
+inline const org::apache::arrow::flatbuf::Footer *GetFooter(const void *buf) {
+  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Footer>(buf);
+}
+
+inline const org::apache::arrow::flatbuf::Footer *GetSizePrefixedFooter(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Footer>(buf);
+}
+
+inline bool VerifyFooterBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Footer>(nullptr);
+}
+
+inline bool VerifySizePrefixedFooterBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Footer>(nullptr);
+}
+
+inline void FinishFooterBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Footer> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedFooterBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Footer> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace flatbuf
+}  // namespace arrow
+}  // namespace apache
+}  // namespace org
+
+#endif  // FLATBUFFERS_GENERATED_FILE_ORG_APACHE_ARROW_FLATBUF_H_
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/Message_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/Message_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..734ce9892c27589ae435fd0075e9bf7c566eab64
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/ipc/Message_generated.h
@@ -0,0 +1,508 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "Schema_generated.h"
+#include "SparseTensor_generated.h"
+#include "Tensor_generated.h"
+
+namespace org {
+namespace apache {
+namespace arrow {
+namespace flatbuf {
+
+struct FieldNode;
+
+struct RecordBatch;
+
+struct DictionaryBatch;
+
+struct Message;
+
+/// ----------------------------------------------------------------------
+/// The root Message type
+/// This union enables us to easily send different message types without
+/// redundant storage, and in the future we can easily add new message types.
+///
+/// Arrow implementations do not need to implement all of the message types,
+/// which may include experimental metadata types. For maximum compatibility,
+/// it is best to send data using RecordBatch
+enum MessageHeader {
+  MessageHeader_NONE = 0,
+  MessageHeader_Schema = 1,
+  MessageHeader_DictionaryBatch = 2,
+  MessageHeader_RecordBatch = 3,
+  MessageHeader_Tensor = 4,
+  MessageHeader_SparseTensor = 5,
+  MessageHeader_MIN = MessageHeader_NONE,
+  MessageHeader_MAX = MessageHeader_SparseTensor
+};
+
+inline const MessageHeader (&EnumValuesMessageHeader())[6] {
+  static const MessageHeader values[] = {
+    MessageHeader_NONE,
+    MessageHeader_Schema,
+    MessageHeader_DictionaryBatch,
+    MessageHeader_RecordBatch,
+    MessageHeader_Tensor,
+    MessageHeader_SparseTensor
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMessageHeader() {
+  static const char * const names[] = {
+    "NONE",
+    "Schema",
+    "DictionaryBatch",
+    "RecordBatch",
+    "Tensor",
+    "SparseTensor",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameMessageHeader(MessageHeader e) {
+  if (e < MessageHeader_NONE || e > MessageHeader_SparseTensor) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesMessageHeader()[index];
+}
+
+template<typename T> struct MessageHeaderTraits {
+  static const MessageHeader enum_value = MessageHeader_NONE;
+};
+
+template<> struct MessageHeaderTraits<Schema> {
+  static const MessageHeader enum_value = MessageHeader_Schema;
+};
+
+template<> struct MessageHeaderTraits<DictionaryBatch> {
+  static const MessageHeader enum_value = MessageHeader_DictionaryBatch;
+};
+
+template<> struct MessageHeaderTraits<RecordBatch> {
+  static const MessageHeader enum_value = MessageHeader_RecordBatch;
+};
+
+template<> struct MessageHeaderTraits<Tensor> {
+  static const MessageHeader enum_value = MessageHeader_Tensor;
+};
+
+template<> struct MessageHeaderTraits<SparseTensor> {
+  static const MessageHeader enum_value = MessageHeader_SparseTensor;
+};
+
+bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type);
+bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+/// ----------------------------------------------------------------------
+/// Data structures for describing a table row batch (a collection of
+/// equal-length Arrow arrays)
+/// Metadata about a field at some level of a nested type tree (but not
+/// its children).
+///
+/// For example, a List<Int16> with values [[1, 2, 3], null, [4], [5, 6], null]
+/// would have {length: 5, null_count: 2} for its List node, and {length: 6,
+/// null_count: 0} for its Int16 node, as separate FieldNode structs
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) FieldNode FLATBUFFERS_FINAL_CLASS {
+ private:
+  int64_t length_;
+  int64_t null_count_;
+
+ public:
+  FieldNode() {
+    memset(static_cast<void *>(this), 0, sizeof(FieldNode));
+  }
+  FieldNode(int64_t _length, int64_t _null_count)
+      : length_(flatbuffers::EndianScalar(_length)),
+        null_count_(flatbuffers::EndianScalar(_null_count)) {
+  }
+  /// The number of value slots in the Arrow array at this level of a nested
+  /// tree
+  int64_t length() const {
+    return flatbuffers::EndianScalar(length_);
+  }
+  /// The number of observed nulls. Fields with null_count == 0 may choose not
+  /// to write their physical validity bitmap out as a materialized buffer,
+  /// instead setting the length of the bitmap buffer to 0.
+  int64_t null_count() const {
+    return flatbuffers::EndianScalar(null_count_);
+  }
+};
+FLATBUFFERS_STRUCT_END(FieldNode, 16);
+
+/// A data header describing the shared memory layout of a "record" or "row"
+/// batch. Some systems call this a "row batch" internally and others a "record
+/// batch".
+struct RecordBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LENGTH = 4,
+    VT_NODES = 6,
+    VT_BUFFERS = 8
+  };
+  /// number of records / rows. The arrays in the batch should all have this
+  /// length
+  int64_t length() const {
+    return GetField<int64_t>(VT_LENGTH, 0);
+  }
+  /// Nodes correspond to the pre-ordered flattened logical schema
+  const flatbuffers::Vector<const FieldNode *> *nodes() const {
+    return GetPointer<const flatbuffers::Vector<const FieldNode *> *>(VT_NODES);
+  }
+  /// Buffers correspond to the pre-ordered flattened buffer tree
+  ///
+  /// The number of buffers appended to this list depends on the schema. For
+  /// example, most primitive arrays will have 2 buffers, 1 for the validity
+  /// bitmap and 1 for the values. For struct arrays, there will only be a
+  /// single buffer for the validity (nulls) bitmap
+  const flatbuffers::Vector<const Buffer *> *buffers() const {
+    return GetPointer<const flatbuffers::Vector<const Buffer *> *>(VT_BUFFERS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_LENGTH) &&
+           VerifyOffset(verifier, VT_NODES) &&
+           verifier.VerifyVector(nodes()) &&
+           VerifyOffset(verifier, VT_BUFFERS) &&
+           verifier.VerifyVector(buffers()) &&
+           verifier.EndTable();
+  }
+};
+
+struct RecordBatchBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_length(int64_t length) {
+    fbb_.AddElement<int64_t>(RecordBatch::VT_LENGTH, length, 0);
+  }
+  void add_nodes(flatbuffers::Offset<flatbuffers::Vector<const FieldNode *>> nodes) {
+    fbb_.AddOffset(RecordBatch::VT_NODES, nodes);
+  }
+  void add_buffers(flatbuffers::Offset<flatbuffers::Vector<const Buffer *>> buffers) {
+    fbb_.AddOffset(RecordBatch::VT_BUFFERS, buffers);
+  }
+  explicit RecordBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  RecordBatchBuilder &operator=(const RecordBatchBuilder &);
+  flatbuffers::Offset<RecordBatch> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<RecordBatch>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<RecordBatch> CreateRecordBatch(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t length = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const FieldNode *>> nodes = 0,
+    flatbuffers::Offset<flatbuffers::Vector<const Buffer *>> buffers = 0) {
+  RecordBatchBuilder builder_(_fbb);
+  builder_.add_length(length);
+  builder_.add_buffers(buffers);
+  builder_.add_nodes(nodes);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<RecordBatch> CreateRecordBatchDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t length = 0,
+    const std::vector<FieldNode> *nodes = nullptr,
+    const std::vector<Buffer> *buffers = nullptr) {
+  auto nodes__ = nodes ? _fbb.CreateVectorOfStructs<FieldNode>(*nodes) : 0;
+  auto buffers__ = buffers ? _fbb.CreateVectorOfStructs<Buffer>(*buffers) : 0;
+  return org::apache::arrow::flatbuf::CreateRecordBatch(
+      _fbb,
+      length,
+      nodes__,
+      buffers__);
+}
+
+/// For sending dictionary encoding information. Any Field can be
+/// dictionary-encoded, but in this case none of its children may be
+/// dictionary-encoded.
+/// There is one vector / column per dictionary, but that vector / column
+/// may be spread across multiple dictionary batches by using the isDelta
+/// flag
+struct DictionaryBatch FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_DATA = 6,
+    VT_ISDELTA = 8
+  };
+  int64_t id() const {
+    return GetField<int64_t>(VT_ID, 0);
+  }
+  const RecordBatch *data() const {
+    return GetPointer<const RecordBatch *>(VT_DATA);
+  }
+  /// If isDelta is true the values in the dictionary are to be appended to a
+  /// dictionary with the indicated id
+  bool isDelta() const {
+    return GetField<uint8_t>(VT_ISDELTA, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_ID) &&
+           VerifyOffset(verifier, VT_DATA) &&
+           verifier.VerifyTable(data()) &&
+           VerifyField<uint8_t>(verifier, VT_ISDELTA) &&
+           verifier.EndTable();
+  }
+};
+
+struct DictionaryBatchBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(int64_t id) {
+    fbb_.AddElement<int64_t>(DictionaryBatch::VT_ID, id, 0);
+  }
+  void add_data(flatbuffers::Offset<RecordBatch> data) {
+    fbb_.AddOffset(DictionaryBatch::VT_DATA, data);
+  }
+  void add_isDelta(bool isDelta) {
+    fbb_.AddElement<uint8_t>(DictionaryBatch::VT_ISDELTA, static_cast<uint8_t>(isDelta), 0);
+  }
+  explicit DictionaryBatchBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DictionaryBatchBuilder &operator=(const DictionaryBatchBuilder &);
+  flatbuffers::Offset<DictionaryBatch> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<DictionaryBatch>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<DictionaryBatch> CreateDictionaryBatch(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t id = 0,
+    flatbuffers::Offset<RecordBatch> data = 0,
+    bool isDelta = false) {
+  DictionaryBatchBuilder builder_(_fbb);
+  builder_.add_id(id);
+  builder_.add_data(data);
+  builder_.add_isDelta(isDelta);
+  return builder_.Finish();
+}
+
+struct Message FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_VERSION = 4,
+    VT_HEADER_TYPE = 6,
+    VT_HEADER = 8,
+    VT_BODYLENGTH = 10,
+    VT_CUSTOM_METADATA = 12
+  };
+  MetadataVersion version() const {
+    return static_cast<MetadataVersion>(GetField<int16_t>(VT_VERSION, 0));
+  }
+  MessageHeader header_type() const {
+    return static_cast<MessageHeader>(GetField<uint8_t>(VT_HEADER_TYPE, 0));
+  }
+  const void *header() const {
+    return GetPointer<const void *>(VT_HEADER);
+  }
+  template<typename T> const T *header_as() const;
+  const Schema *header_as_Schema() const {
+    return header_type() == MessageHeader_Schema ? static_cast<const Schema *>(header()) : nullptr;
+  }
+  const DictionaryBatch *header_as_DictionaryBatch() const {
+    return header_type() == MessageHeader_DictionaryBatch ? static_cast<const DictionaryBatch *>(header()) : nullptr;
+  }
+  const RecordBatch *header_as_RecordBatch() const {
+    return header_type() == MessageHeader_RecordBatch ? static_cast<const RecordBatch *>(header()) : nullptr;
+  }
+  const Tensor *header_as_Tensor() const {
+    return header_type() == MessageHeader_Tensor ? static_cast<const Tensor *>(header()) : nullptr;
+  }
+  const SparseTensor *header_as_SparseTensor() const {
+    return header_type() == MessageHeader_SparseTensor ? static_cast<const SparseTensor *>(header()) : nullptr;
+  }
+  int64_t bodyLength() const {
+    return GetField<int64_t>(VT_BODYLENGTH, 0);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *custom_metadata() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_CUSTOM_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_VERSION) &&
+           VerifyField<uint8_t>(verifier, VT_HEADER_TYPE) &&
+           VerifyOffset(verifier, VT_HEADER) &&
+           VerifyMessageHeader(verifier, header(), header_type()) &&
+           VerifyField<int64_t>(verifier, VT_BODYLENGTH) &&
+           VerifyOffset(verifier, VT_CUSTOM_METADATA) &&
+           verifier.VerifyVector(custom_metadata()) &&
+           verifier.VerifyVectorOfTables(custom_metadata()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const Schema *Message::header_as<Schema>() const {
+  return header_as_Schema();
+}
+
+template<> inline const DictionaryBatch *Message::header_as<DictionaryBatch>() const {
+  return header_as_DictionaryBatch();
+}
+
+template<> inline const RecordBatch *Message::header_as<RecordBatch>() const {
+  return header_as_RecordBatch();
+}
+
+template<> inline const Tensor *Message::header_as<Tensor>() const {
+  return header_as_Tensor();
+}
+
+template<> inline const SparseTensor *Message::header_as<SparseTensor>() const {
+  return header_as_SparseTensor();
+}
+
+struct MessageBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_version(MetadataVersion version) {
+    fbb_.AddElement<int16_t>(Message::VT_VERSION, static_cast<int16_t>(version), 0);
+  }
+  void add_header_type(MessageHeader header_type) {
+    fbb_.AddElement<uint8_t>(Message::VT_HEADER_TYPE, static_cast<uint8_t>(header_type), 0);
+  }
+  void add_header(flatbuffers::Offset<void> header) {
+    fbb_.AddOffset(Message::VT_HEADER, header);
+  }
+  void add_bodyLength(int64_t bodyLength) {
+    fbb_.AddElement<int64_t>(Message::VT_BODYLENGTH, bodyLength, 0);
+  }
+  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> custom_metadata) {
+    fbb_.AddOffset(Message::VT_CUSTOM_METADATA, custom_metadata);
+  }
+  explicit MessageBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  MessageBuilder &operator=(const MessageBuilder &);
+  flatbuffers::Offset<Message> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Message>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Message> CreateMessage(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    MetadataVersion version = MetadataVersion_V1,
+    MessageHeader header_type = MessageHeader_NONE,
+    flatbuffers::Offset<void> header = 0,
+    int64_t bodyLength = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> custom_metadata = 0) {
+  MessageBuilder builder_(_fbb);
+  builder_.add_bodyLength(bodyLength);
+  builder_.add_custom_metadata(custom_metadata);
+  builder_.add_header(header);
+  builder_.add_version(version);
+  builder_.add_header_type(header_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Message> CreateMessageDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    MetadataVersion version = MetadataVersion_V1,
+    MessageHeader header_type = MessageHeader_NONE,
+    flatbuffers::Offset<void> header = 0,
+    int64_t bodyLength = 0,
+    const std::vector<flatbuffers::Offset<KeyValue>> *custom_metadata = nullptr) {
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*custom_metadata) : 0;
+  return org::apache::arrow::flatbuf::CreateMessage(
+      _fbb,
+      version,
+      header_type,
+      header,
+      bodyLength,
+      custom_metadata__);
+}
+
+inline bool VerifyMessageHeader(flatbuffers::Verifier &verifier, const void *obj, MessageHeader type) {
+  switch (type) {
+    case MessageHeader_NONE: {
+      return true;
+    }
+    case MessageHeader_Schema: {
+      auto ptr = reinterpret_cast<const Schema *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader_DictionaryBatch: {
+      auto ptr = reinterpret_cast<const DictionaryBatch *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader_RecordBatch: {
+      auto ptr = reinterpret_cast<const RecordBatch *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader_Tensor: {
+      auto ptr = reinterpret_cast<const Tensor *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case MessageHeader_SparseTensor: {
+      auto ptr = reinterpret_cast<const SparseTensor *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return false;
+  }
+}
+
+inline bool VerifyMessageHeaderVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyMessageHeader(
+        verifier,  values->Get(i), types->GetEnum<MessageHeader>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const org::apache::arrow::flatbuf::Message *GetMessage(const void *buf) {
+  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Message>(buf);
+}
+
+inline const org::apache::arrow::flatbuf::Message *GetSizePrefixedMessage(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Message>(buf);
+}
+
+inline bool VerifyMessageBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Message>(nullptr);
+}
+
+inline bool VerifySizePrefixedMessageBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Message>(nullptr);
+}
+
+inline void FinishMessageBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedMessageBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Message> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace flatbuf
+}  // namespace arrow
+}  // namespace apache
+}  // namespace org
+
+#endif  // FLATBUFFERS_GENERATED_MESSAGE_ORG_APACHE_ARROW_FLATBUF_H_
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/Schema_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/Schema_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..b4f0e7ea2341043b6160bf5c48bef1b341dddefd
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/ipc/Schema_generated.h
@@ -0,0 +1,2045 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_SCHEMA_ORG_APACHE_ARROW_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_SCHEMA_ORG_APACHE_ARROW_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace org {
+namespace apache {
+namespace arrow {
+namespace flatbuf {
+
+struct Null;
+
+struct Struct_;
+
+struct List;
+
+struct LargeList;
+
+struct FixedSizeList;
+
+struct Map;
+
+struct Union;
+
+struct Int;
+
+struct FloatingPoint;
+
+struct Utf8;
+
+struct Binary;
+
+struct LargeUtf8;
+
+struct LargeBinary;
+
+struct FixedSizeBinary;
+
+struct Bool;
+
+struct Decimal;
+
+struct Date;
+
+struct Time;
+
+struct Timestamp;
+
+struct Interval;
+
+struct Duration;
+
+struct KeyValue;
+
+struct DictionaryEncoding;
+
+struct Field;
+
+struct Buffer;
+
+struct Schema;
+
+enum MetadataVersion {
+  /// 0.1.0
+  MetadataVersion_V1 = 0  /// 0.2.0
+,
+  MetadataVersion_V2 = 1  /// 0.3.0 -> 0.7.1
+,
+  MetadataVersion_V3 = 2  /// >= 0.8.0
+,
+  MetadataVersion_V4 = 3,
+  MetadataVersion_MIN = MetadataVersion_V1,
+  MetadataVersion_MAX = MetadataVersion_V4
+};
+
+inline const MetadataVersion (&EnumValuesMetadataVersion())[4] {
+  static const MetadataVersion values[] = {
+    MetadataVersion_V1,
+    MetadataVersion_V2,
+    MetadataVersion_V3,
+    MetadataVersion_V4
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesMetadataVersion() {
+  static const char * const names[] = {
+    "V1",
+    "V2",
+    "V3",
+    "V4",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameMetadataVersion(MetadataVersion e) {
+  if (e < MetadataVersion_V1 || e > MetadataVersion_V4) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesMetadataVersion()[index];
+}
+
+enum UnionMode {
+  UnionMode_Sparse = 0,
+  UnionMode_Dense = 1,
+  UnionMode_MIN = UnionMode_Sparse,
+  UnionMode_MAX = UnionMode_Dense
+};
+
+inline const UnionMode (&EnumValuesUnionMode())[2] {
+  static const UnionMode values[] = {
+    UnionMode_Sparse,
+    UnionMode_Dense
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesUnionMode() {
+  static const char * const names[] = {
+    "Sparse",
+    "Dense",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameUnionMode(UnionMode e) {
+  if (e < UnionMode_Sparse || e > UnionMode_Dense) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesUnionMode()[index];
+}
+
+enum Precision {
+  Precision_HALF = 0,
+  Precision_SINGLE = 1,
+  Precision_DOUBLE = 2,
+  Precision_MIN = Precision_HALF,
+  Precision_MAX = Precision_DOUBLE
+};
+
+inline const Precision (&EnumValuesPrecision())[3] {
+  static const Precision values[] = {
+    Precision_HALF,
+    Precision_SINGLE,
+    Precision_DOUBLE
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesPrecision() {
+  static const char * const names[] = {
+    "HALF",
+    "SINGLE",
+    "DOUBLE",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNamePrecision(Precision e) {
+  if (e < Precision_HALF || e > Precision_DOUBLE) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesPrecision()[index];
+}
+
+enum DateUnit {
+  DateUnit_DAY = 0,
+  DateUnit_MILLISECOND = 1,
+  DateUnit_MIN = DateUnit_DAY,
+  DateUnit_MAX = DateUnit_MILLISECOND
+};
+
+inline const DateUnit (&EnumValuesDateUnit())[2] {
+  static const DateUnit values[] = {
+    DateUnit_DAY,
+    DateUnit_MILLISECOND
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesDateUnit() {
+  static const char * const names[] = {
+    "DAY",
+    "MILLISECOND",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameDateUnit(DateUnit e) {
+  if (e < DateUnit_DAY || e > DateUnit_MILLISECOND) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesDateUnit()[index];
+}
+
+enum TimeUnit {
+  TimeUnit_SECOND = 0,
+  TimeUnit_MILLISECOND = 1,
+  TimeUnit_MICROSECOND = 2,
+  TimeUnit_NANOSECOND = 3,
+  TimeUnit_MIN = TimeUnit_SECOND,
+  TimeUnit_MAX = TimeUnit_NANOSECOND
+};
+
+inline const TimeUnit (&EnumValuesTimeUnit())[4] {
+  static const TimeUnit values[] = {
+    TimeUnit_SECOND,
+    TimeUnit_MILLISECOND,
+    TimeUnit_MICROSECOND,
+    TimeUnit_NANOSECOND
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesTimeUnit() {
+  static const char * const names[] = {
+    "SECOND",
+    "MILLISECOND",
+    "MICROSECOND",
+    "NANOSECOND",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameTimeUnit(TimeUnit e) {
+  if (e < TimeUnit_SECOND || e > TimeUnit_NANOSECOND) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesTimeUnit()[index];
+}
+
+enum IntervalUnit {
+  IntervalUnit_YEAR_MONTH = 0,
+  IntervalUnit_DAY_TIME = 1,
+  IntervalUnit_MIN = IntervalUnit_YEAR_MONTH,
+  IntervalUnit_MAX = IntervalUnit_DAY_TIME
+};
+
+inline const IntervalUnit (&EnumValuesIntervalUnit())[2] {
+  static const IntervalUnit values[] = {
+    IntervalUnit_YEAR_MONTH,
+    IntervalUnit_DAY_TIME
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesIntervalUnit() {
+  static const char * const names[] = {
+    "YEAR_MONTH",
+    "DAY_TIME",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameIntervalUnit(IntervalUnit e) {
+  if (e < IntervalUnit_YEAR_MONTH || e > IntervalUnit_DAY_TIME) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesIntervalUnit()[index];
+}
+
+/// ----------------------------------------------------------------------
+/// Top-level Type value, enabling extensible type-specific metadata. We can
+/// add new logical types to Type without breaking backwards compatibility
+enum Type {
+  Type_NONE = 0,
+  Type_Null = 1,
+  Type_Int = 2,
+  Type_FloatingPoint = 3,
+  Type_Binary = 4,
+  Type_Utf8 = 5,
+  Type_Bool = 6,
+  Type_Decimal = 7,
+  Type_Date = 8,
+  Type_Time = 9,
+  Type_Timestamp = 10,
+  Type_Interval = 11,
+  Type_List = 12,
+  Type_Struct_ = 13,
+  Type_Union = 14,
+  Type_FixedSizeBinary = 15,
+  Type_FixedSizeList = 16,
+  Type_Map = 17,
+  Type_Duration = 18,
+  Type_LargeBinary = 19,
+  Type_LargeUtf8 = 20,
+  Type_LargeList = 21,
+  Type_MIN = Type_NONE,
+  Type_MAX = Type_LargeList
+};
+
+inline const Type (&EnumValuesType())[22] {
+  static const Type values[] = {
+    Type_NONE,
+    Type_Null,
+    Type_Int,
+    Type_FloatingPoint,
+    Type_Binary,
+    Type_Utf8,
+    Type_Bool,
+    Type_Decimal,
+    Type_Date,
+    Type_Time,
+    Type_Timestamp,
+    Type_Interval,
+    Type_List,
+    Type_Struct_,
+    Type_Union,
+    Type_FixedSizeBinary,
+    Type_FixedSizeList,
+    Type_Map,
+    Type_Duration,
+    Type_LargeBinary,
+    Type_LargeUtf8,
+    Type_LargeList
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesType() {
+  static const char * const names[] = {
+    "NONE",
+    "Null",
+    "Int",
+    "FloatingPoint",
+    "Binary",
+    "Utf8",
+    "Bool",
+    "Decimal",
+    "Date",
+    "Time",
+    "Timestamp",
+    "Interval",
+    "List",
+    "Struct_",
+    "Union",
+    "FixedSizeBinary",
+    "FixedSizeList",
+    "Map",
+    "Duration",
+    "LargeBinary",
+    "LargeUtf8",
+    "LargeList",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameType(Type e) {
+  if (e < Type_NONE || e > Type_LargeList) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesType()[index];
+}
+
+template<typename T> struct TypeTraits {
+  static const Type enum_value = Type_NONE;
+};
+
+template<> struct TypeTraits<Null> {
+  static const Type enum_value = Type_Null;
+};
+
+template<> struct TypeTraits<Int> {
+  static const Type enum_value = Type_Int;
+};
+
+template<> struct TypeTraits<FloatingPoint> {
+  static const Type enum_value = Type_FloatingPoint;
+};
+
+template<> struct TypeTraits<Binary> {
+  static const Type enum_value = Type_Binary;
+};
+
+template<> struct TypeTraits<Utf8> {
+  static const Type enum_value = Type_Utf8;
+};
+
+template<> struct TypeTraits<Bool> {
+  static const Type enum_value = Type_Bool;
+};
+
+template<> struct TypeTraits<Decimal> {
+  static const Type enum_value = Type_Decimal;
+};
+
+template<> struct TypeTraits<Date> {
+  static const Type enum_value = Type_Date;
+};
+
+template<> struct TypeTraits<Time> {
+  static const Type enum_value = Type_Time;
+};
+
+template<> struct TypeTraits<Timestamp> {
+  static const Type enum_value = Type_Timestamp;
+};
+
+template<> struct TypeTraits<Interval> {
+  static const Type enum_value = Type_Interval;
+};
+
+template<> struct TypeTraits<List> {
+  static const Type enum_value = Type_List;
+};
+
+template<> struct TypeTraits<Struct_> {
+  static const Type enum_value = Type_Struct_;
+};
+
+template<> struct TypeTraits<Union> {
+  static const Type enum_value = Type_Union;
+};
+
+template<> struct TypeTraits<FixedSizeBinary> {
+  static const Type enum_value = Type_FixedSizeBinary;
+};
+
+template<> struct TypeTraits<FixedSizeList> {
+  static const Type enum_value = Type_FixedSizeList;
+};
+
+template<> struct TypeTraits<Map> {
+  static const Type enum_value = Type_Map;
+};
+
+template<> struct TypeTraits<Duration> {
+  static const Type enum_value = Type_Duration;
+};
+
+template<> struct TypeTraits<LargeBinary> {
+  static const Type enum_value = Type_LargeBinary;
+};
+
+template<> struct TypeTraits<LargeUtf8> {
+  static const Type enum_value = Type_LargeUtf8;
+};
+
+template<> struct TypeTraits<LargeList> {
+  static const Type enum_value = Type_LargeList;
+};
+
+bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type);
+bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+/// ----------------------------------------------------------------------
+/// Endianness of the platform producing the data
+enum Endianness {
+  Endianness_Little = 0,
+  Endianness_Big = 1,
+  Endianness_MIN = Endianness_Little,
+  Endianness_MAX = Endianness_Big
+};
+
+inline const Endianness (&EnumValuesEndianness())[2] {
+  static const Endianness values[] = {
+    Endianness_Little,
+    Endianness_Big
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesEndianness() {
+  static const char * const names[] = {
+    "Little",
+    "Big",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameEndianness(Endianness e) {
+  if (e < Endianness_Little || e > Endianness_Big) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesEndianness()[index];
+}
+
+/// ----------------------------------------------------------------------
+/// A Buffer represents a single contiguous memory segment
+FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(8) Buffer FLATBUFFERS_FINAL_CLASS {
+ private:
+  int64_t offset_;
+  int64_t length_;
+
+ public:
+  Buffer() {
+    memset(static_cast<void *>(this), 0, sizeof(Buffer));
+  }
+  Buffer(int64_t _offset, int64_t _length)
+      : offset_(flatbuffers::EndianScalar(_offset)),
+        length_(flatbuffers::EndianScalar(_length)) {
+  }
+  /// The relative offset into the shared memory page where the bytes for this
+  /// buffer starts
+  int64_t offset() const {
+    return flatbuffers::EndianScalar(offset_);
+  }
+  /// The absolute length (in bytes) of the memory buffer. The memory is found
+  /// from offset (inclusive) to offset + length (non-inclusive).
+  int64_t length() const {
+    return flatbuffers::EndianScalar(length_);
+  }
+};
+FLATBUFFERS_STRUCT_END(Buffer, 16);
+
+/// These are stored in the flatbuffer in the Type union below
+struct Null FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct NullBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit NullBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  NullBuilder &operator=(const NullBuilder &);
+  flatbuffers::Offset<Null> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Null>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Null> CreateNull(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  NullBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
+/// (according to the physical memory layout). We used Struct_ here as
+/// Struct is a reserved word in Flatbuffers
+struct Struct_ FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct Struct_Builder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit Struct_Builder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  Struct_Builder &operator=(const Struct_Builder &);
+  flatbuffers::Offset<Struct_> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Struct_>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Struct_> CreateStruct_(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  Struct_Builder builder_(_fbb);
+  return builder_.Finish();
+}
+
+struct List FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct ListBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit ListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ListBuilder &operator=(const ListBuilder &);
+  flatbuffers::Offset<List> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<List>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<List> CreateList(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  ListBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Same as List, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
+struct LargeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct LargeListBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit LargeListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LargeListBuilder &operator=(const LargeListBuilder &);
+  flatbuffers::Offset<LargeList> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<LargeList>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LargeList> CreateLargeList(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  LargeListBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+struct FixedSizeList FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LISTSIZE = 4
+  };
+  /// Number of list items per value
+  int32_t listSize() const {
+    return GetField<int32_t>(VT_LISTSIZE, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_LISTSIZE) &&
+           verifier.EndTable();
+  }
+};
+
+struct FixedSizeListBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_listSize(int32_t listSize) {
+    fbb_.AddElement<int32_t>(FixedSizeList::VT_LISTSIZE, listSize, 0);
+  }
+  explicit FixedSizeListBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  FixedSizeListBuilder &operator=(const FixedSizeListBuilder &);
+  flatbuffers::Offset<FixedSizeList> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<FixedSizeList>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<FixedSizeList> CreateFixedSizeList(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t listSize = 0) {
+  FixedSizeListBuilder builder_(_fbb);
+  builder_.add_listSize(listSize);
+  return builder_.Finish();
+}
+
+/// A Map is a logical nested type that is represented as
+///
+/// List<entry: Struct<key: K, value: V>>
+///
+/// In this layout, the keys and values are each respectively contiguous. We do
+/// not constrain the key and value types, so the application is responsible
+/// for ensuring that the keys are hashable and unique. Whether the keys are sorted
+/// may be set in the metadata for this field
+///
+/// In a Field with Map type, the Field has a child Struct field, which then
+/// has two children: key type and the second the value type. The names of the
+/// child fields may be respectively "entry", "key", and "value", but this is
+/// not enforced
+///
+/// Map
+///   - child[0] entry: Struct
+///     - child[0] key: K
+///     - child[1] value: V
+///
+/// Neither the "entry" field nor the "key" field may be nullable.
+///
+/// The metadata is structured so that Arrow systems without special handling
+/// for Map can make Map an alias for List. The "layout" attribute for the Map
+/// field must have the same contents as a List.
+struct Map FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_KEYSSORTED = 4
+  };
+  /// Set to true if the keys within each value are sorted
+  bool keysSorted() const {
+    return GetField<uint8_t>(VT_KEYSSORTED, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_KEYSSORTED) &&
+           verifier.EndTable();
+  }
+};
+
+struct MapBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_keysSorted(bool keysSorted) {
+    fbb_.AddElement<uint8_t>(Map::VT_KEYSSORTED, static_cast<uint8_t>(keysSorted), 0);
+  }
+  explicit MapBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  MapBuilder &operator=(const MapBuilder &);
+  flatbuffers::Offset<Map> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Map>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Map> CreateMap(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    bool keysSorted = false) {
+  MapBuilder builder_(_fbb);
+  builder_.add_keysSorted(keysSorted);
+  return builder_.Finish();
+}
+
+/// A union is a complex type with children in Field
+/// By default ids in the type vector refer to the offsets in the children
+/// optionally typeIds provides an indirection between the child offset and the type id
+/// for each child typeIds[offset] is the id used in the type vector
+struct Union FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_MODE = 4,
+    VT_TYPEIDS = 6
+  };
+  UnionMode mode() const {
+    return static_cast<UnionMode>(GetField<int16_t>(VT_MODE, 0));
+  }
+  const flatbuffers::Vector<int32_t> *typeIds() const {
+    return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_TYPEIDS);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_MODE) &&
+           VerifyOffset(verifier, VT_TYPEIDS) &&
+           verifier.VerifyVector(typeIds()) &&
+           verifier.EndTable();
+  }
+};
+
+struct UnionBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_mode(UnionMode mode) {
+    fbb_.AddElement<int16_t>(Union::VT_MODE, static_cast<int16_t>(mode), 0);
+  }
+  void add_typeIds(flatbuffers::Offset<flatbuffers::Vector<int32_t>> typeIds) {
+    fbb_.AddOffset(Union::VT_TYPEIDS, typeIds);
+  }
+  explicit UnionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  UnionBuilder &operator=(const UnionBuilder &);
+  flatbuffers::Offset<Union> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Union>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Union> CreateUnion(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    UnionMode mode = UnionMode_Sparse,
+    flatbuffers::Offset<flatbuffers::Vector<int32_t>> typeIds = 0) {
+  UnionBuilder builder_(_fbb);
+  builder_.add_typeIds(typeIds);
+  builder_.add_mode(mode);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Union> CreateUnionDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    UnionMode mode = UnionMode_Sparse,
+    const std::vector<int32_t> *typeIds = nullptr) {
+  auto typeIds__ = typeIds ? _fbb.CreateVector<int32_t>(*typeIds) : 0;
+  return org::apache::arrow::flatbuf::CreateUnion(
+      _fbb,
+      mode,
+      typeIds__);
+}
+
+struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BITWIDTH = 4,
+    VT_IS_SIGNED = 6
+  };
+  int32_t bitWidth() const {
+    return GetField<int32_t>(VT_BITWIDTH, 0);
+  }
+  bool is_signed() const {
+    return GetField<uint8_t>(VT_IS_SIGNED, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_BITWIDTH) &&
+           VerifyField<uint8_t>(verifier, VT_IS_SIGNED) &&
+           verifier.EndTable();
+  }
+};
+
+struct IntBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_bitWidth(int32_t bitWidth) {
+    fbb_.AddElement<int32_t>(Int::VT_BITWIDTH, bitWidth, 0);
+  }
+  void add_is_signed(bool is_signed) {
+    fbb_.AddElement<uint8_t>(Int::VT_IS_SIGNED, static_cast<uint8_t>(is_signed), 0);
+  }
+  explicit IntBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  IntBuilder &operator=(const IntBuilder &);
+  flatbuffers::Offset<Int> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Int>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Int> CreateInt(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t bitWidth = 0,
+    bool is_signed = false) {
+  IntBuilder builder_(_fbb);
+  builder_.add_bitWidth(bitWidth);
+  builder_.add_is_signed(is_signed);
+  return builder_.Finish();
+}
+
+struct FloatingPoint FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PRECISION = 4
+  };
+  Precision precision() const {
+    return static_cast<Precision>(GetField<int16_t>(VT_PRECISION, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_PRECISION) &&
+           verifier.EndTable();
+  }
+};
+
+struct FloatingPointBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_precision(Precision precision) {
+    fbb_.AddElement<int16_t>(FloatingPoint::VT_PRECISION, static_cast<int16_t>(precision), 0);
+  }
+  explicit FloatingPointBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  FloatingPointBuilder &operator=(const FloatingPointBuilder &);
+  flatbuffers::Offset<FloatingPoint> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<FloatingPoint>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<FloatingPoint> CreateFloatingPoint(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Precision precision = Precision_HALF) {
+  FloatingPointBuilder builder_(_fbb);
+  builder_.add_precision(precision);
+  return builder_.Finish();
+}
+
+/// Unicode with UTF-8 encoding
+struct Utf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct Utf8Builder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit Utf8Builder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  Utf8Builder &operator=(const Utf8Builder &);
+  flatbuffers::Offset<Utf8> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Utf8>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Utf8> CreateUtf8(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  Utf8Builder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Opaque binary data
+struct Binary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct BinaryBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit BinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  BinaryBuilder &operator=(const BinaryBuilder &);
+  flatbuffers::Offset<Binary> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Binary>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Binary> CreateBinary(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  BinaryBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Same as Utf8, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
+struct LargeUtf8 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct LargeUtf8Builder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit LargeUtf8Builder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LargeUtf8Builder &operator=(const LargeUtf8Builder &);
+  flatbuffers::Offset<LargeUtf8> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<LargeUtf8>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LargeUtf8> CreateLargeUtf8(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  LargeUtf8Builder builder_(_fbb);
+  return builder_.Finish();
+}
+
+/// Same as Binary, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
+struct LargeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct LargeBinaryBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit LargeBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  LargeBinaryBuilder &operator=(const LargeBinaryBuilder &);
+  flatbuffers::Offset<LargeBinary> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<LargeBinary>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<LargeBinary> CreateLargeBinary(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  LargeBinaryBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+struct FixedSizeBinary FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_BYTEWIDTH = 4
+  };
+  /// Number of bytes per value
+  int32_t byteWidth() const {
+    return GetField<int32_t>(VT_BYTEWIDTH, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_BYTEWIDTH) &&
+           verifier.EndTable();
+  }
+};
+
+struct FixedSizeBinaryBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_byteWidth(int32_t byteWidth) {
+    fbb_.AddElement<int32_t>(FixedSizeBinary::VT_BYTEWIDTH, byteWidth, 0);
+  }
+  explicit FixedSizeBinaryBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  FixedSizeBinaryBuilder &operator=(const FixedSizeBinaryBuilder &);
+  flatbuffers::Offset<FixedSizeBinary> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<FixedSizeBinary>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<FixedSizeBinary> CreateFixedSizeBinary(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t byteWidth = 0) {
+  FixedSizeBinaryBuilder builder_(_fbb);
+  builder_.add_byteWidth(byteWidth);
+  return builder_.Finish();
+}
+
+struct Bool FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct BoolBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit BoolBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  BoolBuilder &operator=(const BoolBuilder &);
+  flatbuffers::Offset<Bool> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Bool>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Bool> CreateBool(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  BoolBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+struct Decimal FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_PRECISION = 4,
+    VT_SCALE = 6
+  };
+  /// Total number of decimal digits
+  int32_t precision() const {
+    return GetField<int32_t>(VT_PRECISION, 0);
+  }
+  /// Number of digits after the decimal point "."
+  int32_t scale() const {
+    return GetField<int32_t>(VT_SCALE, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int32_t>(verifier, VT_PRECISION) &&
+           VerifyField<int32_t>(verifier, VT_SCALE) &&
+           verifier.EndTable();
+  }
+};
+
+struct DecimalBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_precision(int32_t precision) {
+    fbb_.AddElement<int32_t>(Decimal::VT_PRECISION, precision, 0);
+  }
+  void add_scale(int32_t scale) {
+    fbb_.AddElement<int32_t>(Decimal::VT_SCALE, scale, 0);
+  }
+  explicit DecimalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DecimalBuilder &operator=(const DecimalBuilder &);
+  flatbuffers::Offset<Decimal> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Decimal>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Decimal> CreateDecimal(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int32_t precision = 0,
+    int32_t scale = 0) {
+  DecimalBuilder builder_(_fbb);
+  builder_.add_scale(scale);
+  builder_.add_precision(precision);
+  return builder_.Finish();
+}
+
+/// Date is either a 32-bit or 64-bit type representing elapsed time since UNIX
+/// epoch (1970-01-01), stored in either of two units:
+///
+/// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
+///   leap seconds), where the values are evenly divisible by 86400000
+/// * Days (32 bits) since the UNIX epoch
+struct Date FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4
+  };
+  DateUnit unit() const {
+    return static_cast<DateUnit>(GetField<int16_t>(VT_UNIT, 1));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           verifier.EndTable();
+  }
+};
+
+struct DateBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(DateUnit unit) {
+    fbb_.AddElement<int16_t>(Date::VT_UNIT, static_cast<int16_t>(unit), 1);
+  }
+  explicit DateBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DateBuilder &operator=(const DateBuilder &);
+  flatbuffers::Offset<Date> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Date>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Date> CreateDate(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    DateUnit unit = DateUnit_MILLISECOND) {
+  DateBuilder builder_(_fbb);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+/// Time type. The physical storage type depends on the unit
+/// - SECOND and MILLISECOND: 32 bits
+/// - MICROSECOND and NANOSECOND: 64 bits
+struct Time FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4,
+    VT_BITWIDTH = 6
+  };
+  TimeUnit unit() const {
+    return static_cast<TimeUnit>(GetField<int16_t>(VT_UNIT, 1));
+  }
+  int32_t bitWidth() const {
+    return GetField<int32_t>(VT_BITWIDTH, 32);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           VerifyField<int32_t>(verifier, VT_BITWIDTH) &&
+           verifier.EndTable();
+  }
+};
+
+struct TimeBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(TimeUnit unit) {
+    fbb_.AddElement<int16_t>(Time::VT_UNIT, static_cast<int16_t>(unit), 1);
+  }
+  void add_bitWidth(int32_t bitWidth) {
+    fbb_.AddElement<int32_t>(Time::VT_BITWIDTH, bitWidth, 32);
+  }
+  explicit TimeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TimeBuilder &operator=(const TimeBuilder &);
+  flatbuffers::Offset<Time> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Time>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Time> CreateTime(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_MILLISECOND,
+    int32_t bitWidth = 32) {
+  TimeBuilder builder_(_fbb);
+  builder_.add_bitWidth(bitWidth);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+/// Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding
+/// leap seconds, as a 64-bit integer. Note that UNIX time does not include
+/// leap seconds.
+///
+/// The Timestamp metadata supports both "time zone naive" and "time zone
+/// aware" timestamps. Read about the timezone attribute for more detail
+struct Timestamp FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4,
+    VT_TIMEZONE = 6
+  };
+  TimeUnit unit() const {
+    return static_cast<TimeUnit>(GetField<int16_t>(VT_UNIT, 0));
+  }
+  /// The time zone is a string indicating the name of a time zone, one of:
+  ///
+  /// * As used in the Olson time zone database (the "tz database" or
+  ///   "tzdata"), such as "America/New_York"
+  /// * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
+  ///
+  /// Whether a timezone string is present indicates different semantics about
+  /// the data:
+  ///
+  /// * If the time zone is null or equal to an empty string, the data is "time
+  ///   zone naive" and shall be displayed *as is* to the user, not localized
+  ///   to the locale of the user. This data can be though of as UTC but
+  ///   without having "UTC" as the time zone, it is not considered to be
+  ///   localized to any time zone
+  ///
+  /// * If the time zone is set to a valid value, values can be displayed as
+  ///   "localized" to that time zone, even though the underlying 64-bit
+  ///   integers are identical to the same data stored in UTC. Converting
+  ///   between time zones is a metadata-only operation and does not change the
+  ///   underlying values
+  const flatbuffers::String *timezone() const {
+    return GetPointer<const flatbuffers::String *>(VT_TIMEZONE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           VerifyOffset(verifier, VT_TIMEZONE) &&
+           verifier.VerifyString(timezone()) &&
+           verifier.EndTable();
+  }
+};
+
+struct TimestampBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(TimeUnit unit) {
+    fbb_.AddElement<int16_t>(Timestamp::VT_UNIT, static_cast<int16_t>(unit), 0);
+  }
+  void add_timezone(flatbuffers::Offset<flatbuffers::String> timezone) {
+    fbb_.AddOffset(Timestamp::VT_TIMEZONE, timezone);
+  }
+  explicit TimestampBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TimestampBuilder &operator=(const TimestampBuilder &);
+  flatbuffers::Offset<Timestamp> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Timestamp>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Timestamp> CreateTimestamp(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_SECOND,
+    flatbuffers::Offset<flatbuffers::String> timezone = 0) {
+  TimestampBuilder builder_(_fbb);
+  builder_.add_timezone(timezone);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Timestamp> CreateTimestampDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_SECOND,
+    const char *timezone = nullptr) {
+  auto timezone__ = timezone ? _fbb.CreateString(timezone) : 0;
+  return org::apache::arrow::flatbuf::CreateTimestamp(
+      _fbb,
+      unit,
+      timezone__);
+}
+
+struct Interval FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4
+  };
+  IntervalUnit unit() const {
+    return static_cast<IntervalUnit>(GetField<int16_t>(VT_UNIT, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           verifier.EndTable();
+  }
+};
+
+struct IntervalBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(IntervalUnit unit) {
+    fbb_.AddElement<int16_t>(Interval::VT_UNIT, static_cast<int16_t>(unit), 0);
+  }
+  explicit IntervalBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  IntervalBuilder &operator=(const IntervalBuilder &);
+  flatbuffers::Offset<Interval> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Interval>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Interval> CreateInterval(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    IntervalUnit unit = IntervalUnit_YEAR_MONTH) {
+  IntervalBuilder builder_(_fbb);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+struct Duration FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4
+  };
+  TimeUnit unit() const {
+    return static_cast<TimeUnit>(GetField<int16_t>(VT_UNIT, 1));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_UNIT) &&
+           verifier.EndTable();
+  }
+};
+
+struct DurationBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(TimeUnit unit) {
+    fbb_.AddElement<int16_t>(Duration::VT_UNIT, static_cast<int16_t>(unit), 1);
+  }
+  explicit DurationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DurationBuilder &operator=(const DurationBuilder &);
+  flatbuffers::Offset<Duration> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Duration>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Duration> CreateDuration(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_MILLISECOND) {
+  DurationBuilder builder_(_fbb);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+/// ----------------------------------------------------------------------
+/// user defined key value pairs to add custom metadata to arrow
+/// key namespacing is the responsibility of the user
+struct KeyValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_KEY = 4,
+    VT_VALUE = 6
+  };
+  const flatbuffers::String *key() const {
+    return GetPointer<const flatbuffers::String *>(VT_KEY);
+  }
+  const flatbuffers::String *value() const {
+    return GetPointer<const flatbuffers::String *>(VT_VALUE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_KEY) &&
+           verifier.VerifyString(key()) &&
+           VerifyOffset(verifier, VT_VALUE) &&
+           verifier.VerifyString(value()) &&
+           verifier.EndTable();
+  }
+};
+
+struct KeyValueBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_key(flatbuffers::Offset<flatbuffers::String> key) {
+    fbb_.AddOffset(KeyValue::VT_KEY, key);
+  }
+  void add_value(flatbuffers::Offset<flatbuffers::String> value) {
+    fbb_.AddOffset(KeyValue::VT_VALUE, value);
+  }
+  explicit KeyValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  KeyValueBuilder &operator=(const KeyValueBuilder &);
+  flatbuffers::Offset<KeyValue> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<KeyValue>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<KeyValue> CreateKeyValue(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> key = 0,
+    flatbuffers::Offset<flatbuffers::String> value = 0) {
+  KeyValueBuilder builder_(_fbb);
+  builder_.add_value(value);
+  builder_.add_key(key);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<KeyValue> CreateKeyValueDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *key = nullptr,
+    const char *value = nullptr) {
+  auto key__ = key ? _fbb.CreateString(key) : 0;
+  auto value__ = value ? _fbb.CreateString(value) : 0;
+  return org::apache::arrow::flatbuf::CreateKeyValue(
+      _fbb,
+      key__,
+      value__);
+}
+
+/// ----------------------------------------------------------------------
+/// Dictionary encoding metadata
+struct DictionaryEncoding FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ID = 4,
+    VT_INDEXTYPE = 6,
+    VT_ISORDERED = 8
+  };
+  /// The known dictionary id in the application where this data is used. In
+  /// the file or streaming formats, the dictionary ids are found in the
+  /// DictionaryBatch messages
+  int64_t id() const {
+    return GetField<int64_t>(VT_ID, 0);
+  }
+  /// The dictionary indices are constrained to be positive integers. If this
+  /// field is null, the indices must be signed int32
+  const Int *indexType() const {
+    return GetPointer<const Int *>(VT_INDEXTYPE);
+  }
+  /// By default, dictionaries are not ordered, or the order does not have
+  /// semantic meaning. In some statistical, applications, dictionary-encoding
+  /// is used to represent ordered categorical data, and we provide a way to
+  /// preserve that metadata here
+  bool isOrdered() const {
+    return GetField<uint8_t>(VT_ISORDERED, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_ID) &&
+           VerifyOffset(verifier, VT_INDEXTYPE) &&
+           verifier.VerifyTable(indexType()) &&
+           VerifyField<uint8_t>(verifier, VT_ISORDERED) &&
+           verifier.EndTable();
+  }
+};
+
+struct DictionaryEncodingBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_id(int64_t id) {
+    fbb_.AddElement<int64_t>(DictionaryEncoding::VT_ID, id, 0);
+  }
+  void add_indexType(flatbuffers::Offset<Int> indexType) {
+    fbb_.AddOffset(DictionaryEncoding::VT_INDEXTYPE, indexType);
+  }
+  void add_isOrdered(bool isOrdered) {
+    fbb_.AddElement<uint8_t>(DictionaryEncoding::VT_ISORDERED, static_cast<uint8_t>(isOrdered), 0);
+  }
+  explicit DictionaryEncodingBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DictionaryEncodingBuilder &operator=(const DictionaryEncodingBuilder &);
+  flatbuffers::Offset<DictionaryEncoding> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<DictionaryEncoding>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<DictionaryEncoding> CreateDictionaryEncoding(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t id = 0,
+    flatbuffers::Offset<Int> indexType = 0,
+    bool isOrdered = false) {
+  DictionaryEncodingBuilder builder_(_fbb);
+  builder_.add_id(id);
+  builder_.add_indexType(indexType);
+  builder_.add_isOrdered(isOrdered);
+  return builder_.Finish();
+}
+
+/// ----------------------------------------------------------------------
+/// A field represents a named column in a record / row batch or child of a
+/// nested type.
+struct Field FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_NULLABLE = 6,
+    VT_TYPE_TYPE = 8,
+    VT_TYPE = 10,
+    VT_DICTIONARY = 12,
+    VT_CHILDREN = 14,
+    VT_CUSTOM_METADATA = 16
+  };
+  /// Name is not required, in i.e. a List
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  /// Whether or not this field can contain nulls. Should be true in general.
+  bool nullable() const {
+    return GetField<uint8_t>(VT_NULLABLE, 0) != 0;
+  }
+  Type type_type() const {
+    return static_cast<Type>(GetField<uint8_t>(VT_TYPE_TYPE, 0));
+  }
+  /// This is the type of the decoded value if the field is dictionary encoded.
+  const void *type() const {
+    return GetPointer<const void *>(VT_TYPE);
+  }
+  template<typename T> const T *type_as() const;
+  const Null *type_as_Null() const {
+    return type_type() == Type_Null ? static_cast<const Null *>(type()) : nullptr;
+  }
+  const Int *type_as_Int() const {
+    return type_type() == Type_Int ? static_cast<const Int *>(type()) : nullptr;
+  }
+  const FloatingPoint *type_as_FloatingPoint() const {
+    return type_type() == Type_FloatingPoint ? static_cast<const FloatingPoint *>(type()) : nullptr;
+  }
+  const Binary *type_as_Binary() const {
+    return type_type() == Type_Binary ? static_cast<const Binary *>(type()) : nullptr;
+  }
+  const Utf8 *type_as_Utf8() const {
+    return type_type() == Type_Utf8 ? static_cast<const Utf8 *>(type()) : nullptr;
+  }
+  const Bool *type_as_Bool() const {
+    return type_type() == Type_Bool ? static_cast<const Bool *>(type()) : nullptr;
+  }
+  const Decimal *type_as_Decimal() const {
+    return type_type() == Type_Decimal ? static_cast<const Decimal *>(type()) : nullptr;
+  }
+  const Date *type_as_Date() const {
+    return type_type() == Type_Date ? static_cast<const Date *>(type()) : nullptr;
+  }
+  const Time *type_as_Time() const {
+    return type_type() == Type_Time ? static_cast<const Time *>(type()) : nullptr;
+  }
+  const Timestamp *type_as_Timestamp() const {
+    return type_type() == Type_Timestamp ? static_cast<const Timestamp *>(type()) : nullptr;
+  }
+  const Interval *type_as_Interval() const {
+    return type_type() == Type_Interval ? static_cast<const Interval *>(type()) : nullptr;
+  }
+  const List *type_as_List() const {
+    return type_type() == Type_List ? static_cast<const List *>(type()) : nullptr;
+  }
+  const Struct_ *type_as_Struct_() const {
+    return type_type() == Type_Struct_ ? static_cast<const Struct_ *>(type()) : nullptr;
+  }
+  const Union *type_as_Union() const {
+    return type_type() == Type_Union ? static_cast<const Union *>(type()) : nullptr;
+  }
+  const FixedSizeBinary *type_as_FixedSizeBinary() const {
+    return type_type() == Type_FixedSizeBinary ? static_cast<const FixedSizeBinary *>(type()) : nullptr;
+  }
+  const FixedSizeList *type_as_FixedSizeList() const {
+    return type_type() == Type_FixedSizeList ? static_cast<const FixedSizeList *>(type()) : nullptr;
+  }
+  const Map *type_as_Map() const {
+    return type_type() == Type_Map ? static_cast<const Map *>(type()) : nullptr;
+  }
+  const Duration *type_as_Duration() const {
+    return type_type() == Type_Duration ? static_cast<const Duration *>(type()) : nullptr;
+  }
+  const LargeBinary *type_as_LargeBinary() const {
+    return type_type() == Type_LargeBinary ? static_cast<const LargeBinary *>(type()) : nullptr;
+  }
+  const LargeUtf8 *type_as_LargeUtf8() const {
+    return type_type() == Type_LargeUtf8 ? static_cast<const LargeUtf8 *>(type()) : nullptr;
+  }
+  const LargeList *type_as_LargeList() const {
+    return type_type() == Type_LargeList ? static_cast<const LargeList *>(type()) : nullptr;
+  }
+  /// Present only if the field is dictionary encoded.
+  const DictionaryEncoding *dictionary() const {
+    return GetPointer<const DictionaryEncoding *>(VT_DICTIONARY);
+  }
+  /// children apply only to nested data types like Struct, List and Union. For
+  /// primitive types children will have length 0.
+  const flatbuffers::Vector<flatbuffers::Offset<Field>> *children() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Field>> *>(VT_CHILDREN);
+  }
+  /// User-defined metadata
+  const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *custom_metadata() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_CUSTOM_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyField<uint8_t>(verifier, VT_NULLABLE) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE) &&
+           VerifyOffset(verifier, VT_TYPE) &&
+           VerifyType(verifier, type(), type_type()) &&
+           VerifyOffset(verifier, VT_DICTIONARY) &&
+           verifier.VerifyTable(dictionary()) &&
+           VerifyOffset(verifier, VT_CHILDREN) &&
+           verifier.VerifyVector(children()) &&
+           verifier.VerifyVectorOfTables(children()) &&
+           VerifyOffset(verifier, VT_CUSTOM_METADATA) &&
+           verifier.VerifyVector(custom_metadata()) &&
+           verifier.VerifyVectorOfTables(custom_metadata()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const Null *Field::type_as<Null>() const {
+  return type_as_Null();
+}
+
+template<> inline const Int *Field::type_as<Int>() const {
+  return type_as_Int();
+}
+
+template<> inline const FloatingPoint *Field::type_as<FloatingPoint>() const {
+  return type_as_FloatingPoint();
+}
+
+template<> inline const Binary *Field::type_as<Binary>() const {
+  return type_as_Binary();
+}
+
+template<> inline const Utf8 *Field::type_as<Utf8>() const {
+  return type_as_Utf8();
+}
+
+template<> inline const Bool *Field::type_as<Bool>() const {
+  return type_as_Bool();
+}
+
+template<> inline const Decimal *Field::type_as<Decimal>() const {
+  return type_as_Decimal();
+}
+
+template<> inline const Date *Field::type_as<Date>() const {
+  return type_as_Date();
+}
+
+template<> inline const Time *Field::type_as<Time>() const {
+  return type_as_Time();
+}
+
+template<> inline const Timestamp *Field::type_as<Timestamp>() const {
+  return type_as_Timestamp();
+}
+
+template<> inline const Interval *Field::type_as<Interval>() const {
+  return type_as_Interval();
+}
+
+template<> inline const List *Field::type_as<List>() const {
+  return type_as_List();
+}
+
+template<> inline const Struct_ *Field::type_as<Struct_>() const {
+  return type_as_Struct_();
+}
+
+template<> inline const Union *Field::type_as<Union>() const {
+  return type_as_Union();
+}
+
+template<> inline const FixedSizeBinary *Field::type_as<FixedSizeBinary>() const {
+  return type_as_FixedSizeBinary();
+}
+
+template<> inline const FixedSizeList *Field::type_as<FixedSizeList>() const {
+  return type_as_FixedSizeList();
+}
+
+template<> inline const Map *Field::type_as<Map>() const {
+  return type_as_Map();
+}
+
+template<> inline const Duration *Field::type_as<Duration>() const {
+  return type_as_Duration();
+}
+
+template<> inline const LargeBinary *Field::type_as<LargeBinary>() const {
+  return type_as_LargeBinary();
+}
+
+template<> inline const LargeUtf8 *Field::type_as<LargeUtf8>() const {
+  return type_as_LargeUtf8();
+}
+
+template<> inline const LargeList *Field::type_as<LargeList>() const {
+  return type_as_LargeList();
+}
+
+struct FieldBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(Field::VT_NAME, name);
+  }
+  void add_nullable(bool nullable) {
+    fbb_.AddElement<uint8_t>(Field::VT_NULLABLE, static_cast<uint8_t>(nullable), 0);
+  }
+  void add_type_type(Type type_type) {
+    fbb_.AddElement<uint8_t>(Field::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
+  }
+  void add_type(flatbuffers::Offset<void> type) {
+    fbb_.AddOffset(Field::VT_TYPE, type);
+  }
+  void add_dictionary(flatbuffers::Offset<DictionaryEncoding> dictionary) {
+    fbb_.AddOffset(Field::VT_DICTIONARY, dictionary);
+  }
+  void add_children(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> children) {
+    fbb_.AddOffset(Field::VT_CHILDREN, children);
+  }
+  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> custom_metadata) {
+    fbb_.AddOffset(Field::VT_CUSTOM_METADATA, custom_metadata);
+  }
+  explicit FieldBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  FieldBuilder &operator=(const FieldBuilder &);
+  flatbuffers::Offset<Field> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Field>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Field> CreateField(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    bool nullable = false,
+    Type type_type = Type_NONE,
+    flatbuffers::Offset<void> type = 0,
+    flatbuffers::Offset<DictionaryEncoding> dictionary = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> children = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> custom_metadata = 0) {
+  FieldBuilder builder_(_fbb);
+  builder_.add_custom_metadata(custom_metadata);
+  builder_.add_children(children);
+  builder_.add_dictionary(dictionary);
+  builder_.add_type(type);
+  builder_.add_name(name);
+  builder_.add_type_type(type_type);
+  builder_.add_nullable(nullable);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Field> CreateFieldDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    bool nullable = false,
+    Type type_type = Type_NONE,
+    flatbuffers::Offset<void> type = 0,
+    flatbuffers::Offset<DictionaryEncoding> dictionary = 0,
+    const std::vector<flatbuffers::Offset<Field>> *children = nullptr,
+    const std::vector<flatbuffers::Offset<KeyValue>> *custom_metadata = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto children__ = children ? _fbb.CreateVector<flatbuffers::Offset<Field>>(*children) : 0;
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*custom_metadata) : 0;
+  return org::apache::arrow::flatbuf::CreateField(
+      _fbb,
+      name__,
+      nullable,
+      type_type,
+      type,
+      dictionary,
+      children__,
+      custom_metadata__);
+}
+
+/// ----------------------------------------------------------------------
+/// A Schema describes the columns in a row batch
+struct Schema FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_ENDIANNESS = 4,
+    VT_FIELDS = 6,
+    VT_CUSTOM_METADATA = 8
+  };
+  /// endianness of the buffer
+  /// it is Little Endian by default
+  /// if endianness doesn't match the underlying system then the vectors need to be converted
+  Endianness endianness() const {
+    return static_cast<Endianness>(GetField<int16_t>(VT_ENDIANNESS, 0));
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<Field>> *fields() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Field>> *>(VT_FIELDS);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *custom_metadata() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<KeyValue>> *>(VT_CUSTOM_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int16_t>(verifier, VT_ENDIANNESS) &&
+           VerifyOffset(verifier, VT_FIELDS) &&
+           verifier.VerifyVector(fields()) &&
+           verifier.VerifyVectorOfTables(fields()) &&
+           VerifyOffset(verifier, VT_CUSTOM_METADATA) &&
+           verifier.VerifyVector(custom_metadata()) &&
+           verifier.VerifyVectorOfTables(custom_metadata()) &&
+           verifier.EndTable();
+  }
+};
+
+struct SchemaBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_endianness(Endianness endianness) {
+    fbb_.AddElement<int16_t>(Schema::VT_ENDIANNESS, static_cast<int16_t>(endianness), 0);
+  }
+  void add_fields(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> fields) {
+    fbb_.AddOffset(Schema::VT_FIELDS, fields);
+  }
+  void add_custom_metadata(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> custom_metadata) {
+    fbb_.AddOffset(Schema::VT_CUSTOM_METADATA, custom_metadata);
+  }
+  explicit SchemaBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  SchemaBuilder &operator=(const SchemaBuilder &);
+  flatbuffers::Offset<Schema> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Schema>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Schema> CreateSchema(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Endianness endianness = Endianness_Little,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Field>>> fields = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<KeyValue>>> custom_metadata = 0) {
+  SchemaBuilder builder_(_fbb);
+  builder_.add_custom_metadata(custom_metadata);
+  builder_.add_fields(fields);
+  builder_.add_endianness(endianness);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Schema> CreateSchemaDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Endianness endianness = Endianness_Little,
+    const std::vector<flatbuffers::Offset<Field>> *fields = nullptr,
+    const std::vector<flatbuffers::Offset<KeyValue>> *custom_metadata = nullptr) {
+  auto fields__ = fields ? _fbb.CreateVector<flatbuffers::Offset<Field>>(*fields) : 0;
+  auto custom_metadata__ = custom_metadata ? _fbb.CreateVector<flatbuffers::Offset<KeyValue>>(*custom_metadata) : 0;
+  return org::apache::arrow::flatbuf::CreateSchema(
+      _fbb,
+      endianness,
+      fields__,
+      custom_metadata__);
+}
+
+inline bool VerifyType(flatbuffers::Verifier &verifier, const void *obj, Type type) {
+  switch (type) {
+    case Type_NONE: {
+      return true;
+    }
+    case Type_Null: {
+      auto ptr = reinterpret_cast<const Null *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Int: {
+      auto ptr = reinterpret_cast<const Int *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_FloatingPoint: {
+      auto ptr = reinterpret_cast<const FloatingPoint *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Binary: {
+      auto ptr = reinterpret_cast<const Binary *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Utf8: {
+      auto ptr = reinterpret_cast<const Utf8 *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Bool: {
+      auto ptr = reinterpret_cast<const Bool *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Decimal: {
+      auto ptr = reinterpret_cast<const Decimal *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Date: {
+      auto ptr = reinterpret_cast<const Date *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Time: {
+      auto ptr = reinterpret_cast<const Time *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Timestamp: {
+      auto ptr = reinterpret_cast<const Timestamp *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Interval: {
+      auto ptr = reinterpret_cast<const Interval *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_List: {
+      auto ptr = reinterpret_cast<const List *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Struct_: {
+      auto ptr = reinterpret_cast<const Struct_ *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Union: {
+      auto ptr = reinterpret_cast<const Union *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_FixedSizeBinary: {
+      auto ptr = reinterpret_cast<const FixedSizeBinary *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_FixedSizeList: {
+      auto ptr = reinterpret_cast<const FixedSizeList *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Map: {
+      auto ptr = reinterpret_cast<const Map *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_Duration: {
+      auto ptr = reinterpret_cast<const Duration *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_LargeBinary: {
+      auto ptr = reinterpret_cast<const LargeBinary *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_LargeUtf8: {
+      auto ptr = reinterpret_cast<const LargeUtf8 *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case Type_LargeList: {
+      auto ptr = reinterpret_cast<const LargeList *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return false;
+  }
+}
+
+inline bool VerifyTypeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyType(
+        verifier,  values->Get(i), types->GetEnum<Type>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const org::apache::arrow::flatbuf::Schema *GetSchema(const void *buf) {
+  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Schema>(buf);
+}
+
+inline const org::apache::arrow::flatbuf::Schema *GetSizePrefixedSchema(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Schema>(buf);
+}
+
+inline bool VerifySchemaBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Schema>(nullptr);
+}
+
+inline bool VerifySizePrefixedSchemaBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Schema>(nullptr);
+}
+
+inline void FinishSchemaBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedSchemaBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Schema> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace flatbuf
+}  // namespace arrow
+}  // namespace apache
+}  // namespace org
+
+#endif  // FLATBUFFERS_GENERATED_SCHEMA_ORG_APACHE_ARROW_FLATBUF_H_
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/SparseTensor_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/SparseTensor_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..94974c58638543b53ee1893a6f553722a3f60ece
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/ipc/SparseTensor_generated.h
@@ -0,0 +1,644 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_SPARSETENSOR_ORG_APACHE_ARROW_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_SPARSETENSOR_ORG_APACHE_ARROW_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "Schema_generated.h"
+#include "Tensor_generated.h"
+
+namespace org {
+namespace apache {
+namespace arrow {
+namespace flatbuf {
+
+struct SparseTensorIndexCOO;
+
+struct SparseMatrixIndexCSR;
+
+struct SparseTensor;
+
+enum SparseTensorIndex {
+  SparseTensorIndex_NONE = 0,
+  SparseTensorIndex_SparseTensorIndexCOO = 1,
+  SparseTensorIndex_SparseMatrixIndexCSR = 2,
+  SparseTensorIndex_MIN = SparseTensorIndex_NONE,
+  SparseTensorIndex_MAX = SparseTensorIndex_SparseMatrixIndexCSR
+};
+
+inline const SparseTensorIndex (&EnumValuesSparseTensorIndex())[3] {
+  static const SparseTensorIndex values[] = {
+    SparseTensorIndex_NONE,
+    SparseTensorIndex_SparseTensorIndexCOO,
+    SparseTensorIndex_SparseMatrixIndexCSR
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesSparseTensorIndex() {
+  static const char * const names[] = {
+    "NONE",
+    "SparseTensorIndexCOO",
+    "SparseMatrixIndexCSR",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameSparseTensorIndex(SparseTensorIndex e) {
+  if (e < SparseTensorIndex_NONE || e > SparseTensorIndex_SparseMatrixIndexCSR) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesSparseTensorIndex()[index];
+}
+
+template<typename T> struct SparseTensorIndexTraits {
+  static const SparseTensorIndex enum_value = SparseTensorIndex_NONE;
+};
+
+template<> struct SparseTensorIndexTraits<SparseTensorIndexCOO> {
+  static const SparseTensorIndex enum_value = SparseTensorIndex_SparseTensorIndexCOO;
+};
+
+template<> struct SparseTensorIndexTraits<SparseMatrixIndexCSR> {
+  static const SparseTensorIndex enum_value = SparseTensorIndex_SparseMatrixIndexCSR;
+};
+
+bool VerifySparseTensorIndex(flatbuffers::Verifier &verifier, const void *obj, SparseTensorIndex type);
+bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+/// ----------------------------------------------------------------------
+/// EXPERIMENTAL: Data structures for sparse tensors
+/// Coodinate (COO) format of sparse tensor index.
+///
+/// COO's index list are represented as a NxM matrix,
+/// where N is the number of non-zero values,
+/// and M is the number of dimensions of a sparse tensor.
+///
+/// indicesBuffer stores the location and size of the data of this indices
+/// matrix.  The value type and the stride of the indices matrix is
+/// specified in indicesType and indicesStrides fields.
+///
+/// For example, let X be a 2x3x4x5 tensor, and it has the following
+/// 6 non-zero values:
+///
+///   X[0, 1, 2, 0] := 1
+///   X[1, 1, 2, 3] := 2
+///   X[0, 2, 1, 0] := 3
+///   X[0, 1, 3, 0] := 4
+///   X[0, 1, 2, 1] := 5
+///   X[1, 2, 0, 4] := 6
+///
+/// In COO format, the index matrix of X is the following 4x6 matrix:
+///
+///   [[0, 0, 0, 0, 1, 1],
+///    [1, 1, 1, 2, 1, 2],
+///    [2, 2, 3, 1, 2, 0],
+///    [0, 1, 0, 0, 3, 4]]
+///
+/// Note that the indices are sorted in lexicographical order.
+struct SparseTensorIndexCOO FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_INDICESTYPE = 4,
+    VT_INDICESSTRIDES = 6,
+    VT_INDICESBUFFER = 8
+  };
+  /// The type of values in indicesBuffer
+  const Int *indicesType() const {
+    return GetPointer<const Int *>(VT_INDICESTYPE);
+  }
+  /// Non-negative byte offsets to advance one value cell along each dimension
+  const flatbuffers::Vector<int64_t> *indicesStrides() const {
+    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_INDICESSTRIDES);
+  }
+  /// The location and size of the indices matrix's data
+  const Buffer *indicesBuffer() const {
+    return GetStruct<const Buffer *>(VT_INDICESBUFFER);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_INDICESTYPE) &&
+           verifier.VerifyTable(indicesType()) &&
+           VerifyOffset(verifier, VT_INDICESSTRIDES) &&
+           verifier.VerifyVector(indicesStrides()) &&
+           VerifyField<Buffer>(verifier, VT_INDICESBUFFER) &&
+           verifier.EndTable();
+  }
+};
+
+struct SparseTensorIndexCOOBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_indicesType(flatbuffers::Offset<Int> indicesType) {
+    fbb_.AddOffset(SparseTensorIndexCOO::VT_INDICESTYPE, indicesType);
+  }
+  void add_indicesStrides(flatbuffers::Offset<flatbuffers::Vector<int64_t>> indicesStrides) {
+    fbb_.AddOffset(SparseTensorIndexCOO::VT_INDICESSTRIDES, indicesStrides);
+  }
+  void add_indicesBuffer(const Buffer *indicesBuffer) {
+    fbb_.AddStruct(SparseTensorIndexCOO::VT_INDICESBUFFER, indicesBuffer);
+  }
+  explicit SparseTensorIndexCOOBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  SparseTensorIndexCOOBuilder &operator=(const SparseTensorIndexCOOBuilder &);
+  flatbuffers::Offset<SparseTensorIndexCOO> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<SparseTensorIndexCOO>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOO(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<Int> indicesType = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int64_t>> indicesStrides = 0,
+    const Buffer *indicesBuffer = 0) {
+  SparseTensorIndexCOOBuilder builder_(_fbb);
+  builder_.add_indicesBuffer(indicesBuffer);
+  builder_.add_indicesStrides(indicesStrides);
+  builder_.add_indicesType(indicesType);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<SparseTensorIndexCOO> CreateSparseTensorIndexCOODirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<Int> indicesType = 0,
+    const std::vector<int64_t> *indicesStrides = nullptr,
+    const Buffer *indicesBuffer = 0) {
+  auto indicesStrides__ = indicesStrides ? _fbb.CreateVector<int64_t>(*indicesStrides) : 0;
+  return org::apache::arrow::flatbuf::CreateSparseTensorIndexCOO(
+      _fbb,
+      indicesType,
+      indicesStrides__,
+      indicesBuffer);
+}
+
+/// Compressed Sparse Row format, that is matrix-specific.
+struct SparseMatrixIndexCSR FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_INDPTRTYPE = 4,
+    VT_INDPTRBUFFER = 6,
+    VT_INDICESTYPE = 8,
+    VT_INDICESBUFFER = 10
+  };
+  /// The type of values in indptrBuffer
+  const Int *indptrType() const {
+    return GetPointer<const Int *>(VT_INDPTRTYPE);
+  }
+  /// indptrBuffer stores the location and size of indptr array that
+  /// represents the range of the rows.
+  /// The i-th row spans from indptr[i] to indptr[i+1] in the data.
+  /// The length of this array is 1 + (the number of rows), and the type
+  /// of index value is long.
+  ///
+  /// For example, let X be the following 6x4 matrix:
+  ///
+  ///   X := [[0, 1, 2, 0],
+  ///         [0, 0, 3, 0],
+  ///         [0, 4, 0, 5],
+  ///         [0, 0, 0, 0],
+  ///         [6, 0, 7, 8],
+  ///         [0, 9, 0, 0]].
+  ///
+  /// The array of non-zero values in X is:
+  ///
+  ///   values(X) = [1, 2, 3, 4, 5, 6, 7, 8, 9].
+  ///
+  /// And the indptr of X is:
+  ///
+  ///   indptr(X) = [0, 2, 3, 5, 5, 8, 10].
+  const Buffer *indptrBuffer() const {
+    return GetStruct<const Buffer *>(VT_INDPTRBUFFER);
+  }
+  /// The type of values in indicesBuffer
+  const Int *indicesType() const {
+    return GetPointer<const Int *>(VT_INDICESTYPE);
+  }
+  /// indicesBuffer stores the location and size of the array that
+  /// contains the column indices of the corresponding non-zero values.
+  /// The type of index value is long.
+  ///
+  /// For example, the indices of the above X is:
+  ///
+  ///   indices(X) = [1, 2, 2, 1, 3, 0, 2, 3, 1].
+  ///
+  /// Note that the indices are sorted in lexicographical order for each row.
+  const Buffer *indicesBuffer() const {
+    return GetStruct<const Buffer *>(VT_INDICESBUFFER);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_INDPTRTYPE) &&
+           verifier.VerifyTable(indptrType()) &&
+           VerifyField<Buffer>(verifier, VT_INDPTRBUFFER) &&
+           VerifyOffset(verifier, VT_INDICESTYPE) &&
+           verifier.VerifyTable(indicesType()) &&
+           VerifyField<Buffer>(verifier, VT_INDICESBUFFER) &&
+           verifier.EndTable();
+  }
+};
+
+struct SparseMatrixIndexCSRBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_indptrType(flatbuffers::Offset<Int> indptrType) {
+    fbb_.AddOffset(SparseMatrixIndexCSR::VT_INDPTRTYPE, indptrType);
+  }
+  void add_indptrBuffer(const Buffer *indptrBuffer) {
+    fbb_.AddStruct(SparseMatrixIndexCSR::VT_INDPTRBUFFER, indptrBuffer);
+  }
+  void add_indicesType(flatbuffers::Offset<Int> indicesType) {
+    fbb_.AddOffset(SparseMatrixIndexCSR::VT_INDICESTYPE, indicesType);
+  }
+  void add_indicesBuffer(const Buffer *indicesBuffer) {
+    fbb_.AddStruct(SparseMatrixIndexCSR::VT_INDICESBUFFER, indicesBuffer);
+  }
+  explicit SparseMatrixIndexCSRBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  SparseMatrixIndexCSRBuilder &operator=(const SparseMatrixIndexCSRBuilder &);
+  flatbuffers::Offset<SparseMatrixIndexCSR> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<SparseMatrixIndexCSR>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<SparseMatrixIndexCSR> CreateSparseMatrixIndexCSR(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<Int> indptrType = 0,
+    const Buffer *indptrBuffer = 0,
+    flatbuffers::Offset<Int> indicesType = 0,
+    const Buffer *indicesBuffer = 0) {
+  SparseMatrixIndexCSRBuilder builder_(_fbb);
+  builder_.add_indicesBuffer(indicesBuffer);
+  builder_.add_indicesType(indicesType);
+  builder_.add_indptrBuffer(indptrBuffer);
+  builder_.add_indptrType(indptrType);
+  return builder_.Finish();
+}
+
+struct SparseTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_TYPE_TYPE = 4,
+    VT_TYPE = 6,
+    VT_SHAPE = 8,
+    VT_NON_ZERO_LENGTH = 10,
+    VT_SPARSEINDEX_TYPE = 12,
+    VT_SPARSEINDEX = 14,
+    VT_DATA = 16
+  };
+  Type type_type() const {
+    return static_cast<Type>(GetField<uint8_t>(VT_TYPE_TYPE, 0));
+  }
+  /// The type of data contained in a value cell.
+  /// Currently only fixed-width value types are supported,
+  /// no strings or nested types.
+  const void *type() const {
+    return GetPointer<const void *>(VT_TYPE);
+  }
+  template<typename T> const T *type_as() const;
+  const Null *type_as_Null() const {
+    return type_type() == Type_Null ? static_cast<const Null *>(type()) : nullptr;
+  }
+  const Int *type_as_Int() const {
+    return type_type() == Type_Int ? static_cast<const Int *>(type()) : nullptr;
+  }
+  const FloatingPoint *type_as_FloatingPoint() const {
+    return type_type() == Type_FloatingPoint ? static_cast<const FloatingPoint *>(type()) : nullptr;
+  }
+  const Binary *type_as_Binary() const {
+    return type_type() == Type_Binary ? static_cast<const Binary *>(type()) : nullptr;
+  }
+  const Utf8 *type_as_Utf8() const {
+    return type_type() == Type_Utf8 ? static_cast<const Utf8 *>(type()) : nullptr;
+  }
+  const Bool *type_as_Bool() const {
+    return type_type() == Type_Bool ? static_cast<const Bool *>(type()) : nullptr;
+  }
+  const Decimal *type_as_Decimal() const {
+    return type_type() == Type_Decimal ? static_cast<const Decimal *>(type()) : nullptr;
+  }
+  const Date *type_as_Date() const {
+    return type_type() == Type_Date ? static_cast<const Date *>(type()) : nullptr;
+  }
+  const Time *type_as_Time() const {
+    return type_type() == Type_Time ? static_cast<const Time *>(type()) : nullptr;
+  }
+  const Timestamp *type_as_Timestamp() const {
+    return type_type() == Type_Timestamp ? static_cast<const Timestamp *>(type()) : nullptr;
+  }
+  const Interval *type_as_Interval() const {
+    return type_type() == Type_Interval ? static_cast<const Interval *>(type()) : nullptr;
+  }
+  const List *type_as_List() const {
+    return type_type() == Type_List ? static_cast<const List *>(type()) : nullptr;
+  }
+  const Struct_ *type_as_Struct_() const {
+    return type_type() == Type_Struct_ ? static_cast<const Struct_ *>(type()) : nullptr;
+  }
+  const Union *type_as_Union() const {
+    return type_type() == Type_Union ? static_cast<const Union *>(type()) : nullptr;
+  }
+  const FixedSizeBinary *type_as_FixedSizeBinary() const {
+    return type_type() == Type_FixedSizeBinary ? static_cast<const FixedSizeBinary *>(type()) : nullptr;
+  }
+  const FixedSizeList *type_as_FixedSizeList() const {
+    return type_type() == Type_FixedSizeList ? static_cast<const FixedSizeList *>(type()) : nullptr;
+  }
+  const Map *type_as_Map() const {
+    return type_type() == Type_Map ? static_cast<const Map *>(type()) : nullptr;
+  }
+  const Duration *type_as_Duration() const {
+    return type_type() == Type_Duration ? static_cast<const Duration *>(type()) : nullptr;
+  }
+  const LargeBinary *type_as_LargeBinary() const {
+    return type_type() == Type_LargeBinary ? static_cast<const LargeBinary *>(type()) : nullptr;
+  }
+  const LargeUtf8 *type_as_LargeUtf8() const {
+    return type_type() == Type_LargeUtf8 ? static_cast<const LargeUtf8 *>(type()) : nullptr;
+  }
+  const LargeList *type_as_LargeList() const {
+    return type_type() == Type_LargeList ? static_cast<const LargeList *>(type()) : nullptr;
+  }
+  /// The dimensions of the tensor, optionally named.
+  const flatbuffers::Vector<flatbuffers::Offset<TensorDim>> *shape() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TensorDim>> *>(VT_SHAPE);
+  }
+  /// The number of non-zero values in a sparse tensor.
+  int64_t non_zero_length() const {
+    return GetField<int64_t>(VT_NON_ZERO_LENGTH, 0);
+  }
+  SparseTensorIndex sparseIndex_type() const {
+    return static_cast<SparseTensorIndex>(GetField<uint8_t>(VT_SPARSEINDEX_TYPE, 0));
+  }
+  /// Sparse tensor index
+  const void *sparseIndex() const {
+    return GetPointer<const void *>(VT_SPARSEINDEX);
+  }
+  template<typename T> const T *sparseIndex_as() const;
+  const SparseTensorIndexCOO *sparseIndex_as_SparseTensorIndexCOO() const {
+    return sparseIndex_type() == SparseTensorIndex_SparseTensorIndexCOO ? static_cast<const SparseTensorIndexCOO *>(sparseIndex()) : nullptr;
+  }
+  const SparseMatrixIndexCSR *sparseIndex_as_SparseMatrixIndexCSR() const {
+    return sparseIndex_type() == SparseTensorIndex_SparseMatrixIndexCSR ? static_cast<const SparseMatrixIndexCSR *>(sparseIndex()) : nullptr;
+  }
+  /// The location and size of the tensor's data
+  const Buffer *data() const {
+    return GetStruct<const Buffer *>(VT_DATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE) &&
+           VerifyOffset(verifier, VT_TYPE) &&
+           VerifyType(verifier, type(), type_type()) &&
+           VerifyOffset(verifier, VT_SHAPE) &&
+           verifier.VerifyVector(shape()) &&
+           verifier.VerifyVectorOfTables(shape()) &&
+           VerifyField<int64_t>(verifier, VT_NON_ZERO_LENGTH) &&
+           VerifyField<uint8_t>(verifier, VT_SPARSEINDEX_TYPE) &&
+           VerifyOffset(verifier, VT_SPARSEINDEX) &&
+           VerifySparseTensorIndex(verifier, sparseIndex(), sparseIndex_type()) &&
+           VerifyField<Buffer>(verifier, VT_DATA) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const Null *SparseTensor::type_as<Null>() const {
+  return type_as_Null();
+}
+
+template<> inline const Int *SparseTensor::type_as<Int>() const {
+  return type_as_Int();
+}
+
+template<> inline const FloatingPoint *SparseTensor::type_as<FloatingPoint>() const {
+  return type_as_FloatingPoint();
+}
+
+template<> inline const Binary *SparseTensor::type_as<Binary>() const {
+  return type_as_Binary();
+}
+
+template<> inline const Utf8 *SparseTensor::type_as<Utf8>() const {
+  return type_as_Utf8();
+}
+
+template<> inline const Bool *SparseTensor::type_as<Bool>() const {
+  return type_as_Bool();
+}
+
+template<> inline const Decimal *SparseTensor::type_as<Decimal>() const {
+  return type_as_Decimal();
+}
+
+template<> inline const Date *SparseTensor::type_as<Date>() const {
+  return type_as_Date();
+}
+
+template<> inline const Time *SparseTensor::type_as<Time>() const {
+  return type_as_Time();
+}
+
+template<> inline const Timestamp *SparseTensor::type_as<Timestamp>() const {
+  return type_as_Timestamp();
+}
+
+template<> inline const Interval *SparseTensor::type_as<Interval>() const {
+  return type_as_Interval();
+}
+
+template<> inline const List *SparseTensor::type_as<List>() const {
+  return type_as_List();
+}
+
+template<> inline const Struct_ *SparseTensor::type_as<Struct_>() const {
+  return type_as_Struct_();
+}
+
+template<> inline const Union *SparseTensor::type_as<Union>() const {
+  return type_as_Union();
+}
+
+template<> inline const FixedSizeBinary *SparseTensor::type_as<FixedSizeBinary>() const {
+  return type_as_FixedSizeBinary();
+}
+
+template<> inline const FixedSizeList *SparseTensor::type_as<FixedSizeList>() const {
+  return type_as_FixedSizeList();
+}
+
+template<> inline const Map *SparseTensor::type_as<Map>() const {
+  return type_as_Map();
+}
+
+template<> inline const Duration *SparseTensor::type_as<Duration>() const {
+  return type_as_Duration();
+}
+
+template<> inline const LargeBinary *SparseTensor::type_as<LargeBinary>() const {
+  return type_as_LargeBinary();
+}
+
+template<> inline const LargeUtf8 *SparseTensor::type_as<LargeUtf8>() const {
+  return type_as_LargeUtf8();
+}
+
+template<> inline const LargeList *SparseTensor::type_as<LargeList>() const {
+  return type_as_LargeList();
+}
+
+template<> inline const SparseTensorIndexCOO *SparseTensor::sparseIndex_as<SparseTensorIndexCOO>() const {
+  return sparseIndex_as_SparseTensorIndexCOO();
+}
+
+template<> inline const SparseMatrixIndexCSR *SparseTensor::sparseIndex_as<SparseMatrixIndexCSR>() const {
+  return sparseIndex_as_SparseMatrixIndexCSR();
+}
+
+struct SparseTensorBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_type_type(Type type_type) {
+    fbb_.AddElement<uint8_t>(SparseTensor::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
+  }
+  void add_type(flatbuffers::Offset<void> type) {
+    fbb_.AddOffset(SparseTensor::VT_TYPE, type);
+  }
+  void add_shape(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TensorDim>>> shape) {
+    fbb_.AddOffset(SparseTensor::VT_SHAPE, shape);
+  }
+  void add_non_zero_length(int64_t non_zero_length) {
+    fbb_.AddElement<int64_t>(SparseTensor::VT_NON_ZERO_LENGTH, non_zero_length, 0);
+  }
+  void add_sparseIndex_type(SparseTensorIndex sparseIndex_type) {
+    fbb_.AddElement<uint8_t>(SparseTensor::VT_SPARSEINDEX_TYPE, static_cast<uint8_t>(sparseIndex_type), 0);
+  }
+  void add_sparseIndex(flatbuffers::Offset<void> sparseIndex) {
+    fbb_.AddOffset(SparseTensor::VT_SPARSEINDEX, sparseIndex);
+  }
+  void add_data(const Buffer *data) {
+    fbb_.AddStruct(SparseTensor::VT_DATA, data);
+  }
+  explicit SparseTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  SparseTensorBuilder &operator=(const SparseTensorBuilder &);
+  flatbuffers::Offset<SparseTensor> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<SparseTensor>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<SparseTensor> CreateSparseTensor(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Type type_type = Type_NONE,
+    flatbuffers::Offset<void> type = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TensorDim>>> shape = 0,
+    int64_t non_zero_length = 0,
+    SparseTensorIndex sparseIndex_type = SparseTensorIndex_NONE,
+    flatbuffers::Offset<void> sparseIndex = 0,
+    const Buffer *data = 0) {
+  SparseTensorBuilder builder_(_fbb);
+  builder_.add_non_zero_length(non_zero_length);
+  builder_.add_data(data);
+  builder_.add_sparseIndex(sparseIndex);
+  builder_.add_shape(shape);
+  builder_.add_type(type);
+  builder_.add_sparseIndex_type(sparseIndex_type);
+  builder_.add_type_type(type_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<SparseTensor> CreateSparseTensorDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Type type_type = Type_NONE,
+    flatbuffers::Offset<void> type = 0,
+    const std::vector<flatbuffers::Offset<TensorDim>> *shape = nullptr,
+    int64_t non_zero_length = 0,
+    SparseTensorIndex sparseIndex_type = SparseTensorIndex_NONE,
+    flatbuffers::Offset<void> sparseIndex = 0,
+    const Buffer *data = 0) {
+  auto shape__ = shape ? _fbb.CreateVector<flatbuffers::Offset<TensorDim>>(*shape) : 0;
+  return org::apache::arrow::flatbuf::CreateSparseTensor(
+      _fbb,
+      type_type,
+      type,
+      shape__,
+      non_zero_length,
+      sparseIndex_type,
+      sparseIndex,
+      data);
+}
+
+inline bool VerifySparseTensorIndex(flatbuffers::Verifier &verifier, const void *obj, SparseTensorIndex type) {
+  switch (type) {
+    case SparseTensorIndex_NONE: {
+      return true;
+    }
+    case SparseTensorIndex_SparseTensorIndexCOO: {
+      auto ptr = reinterpret_cast<const SparseTensorIndexCOO *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case SparseTensorIndex_SparseMatrixIndexCSR: {
+      auto ptr = reinterpret_cast<const SparseMatrixIndexCSR *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return false;
+  }
+}
+
+inline bool VerifySparseTensorIndexVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifySparseTensorIndex(
+        verifier,  values->Get(i), types->GetEnum<SparseTensorIndex>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const org::apache::arrow::flatbuf::SparseTensor *GetSparseTensor(const void *buf) {
+  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::SparseTensor>(buf);
+}
+
+inline const org::apache::arrow::flatbuf::SparseTensor *GetSizePrefixedSparseTensor(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::SparseTensor>(buf);
+}
+
+inline bool VerifySparseTensorBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::SparseTensor>(nullptr);
+}
+
+inline bool VerifySizePrefixedSparseTensorBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::SparseTensor>(nullptr);
+}
+
+inline void FinishSparseTensorBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::SparseTensor> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedSparseTensorBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::SparseTensor> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace flatbuf
+}  // namespace arrow
+}  // namespace apache
+}  // namespace org
+
+#endif  // FLATBUFFERS_GENERATED_SPARSETENSOR_ORG_APACHE_ARROW_FLATBUF_H_
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/Tensor_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/Tensor_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..8483eb116b30e5faaba4f04aa2c1977899a928cc
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/ipc/Tensor_generated.h
@@ -0,0 +1,377 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_TENSOR_ORG_APACHE_ARROW_FLATBUF_H_
+#define FLATBUFFERS_GENERATED_TENSOR_ORG_APACHE_ARROW_FLATBUF_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+#include "Schema_generated.h"
+
+namespace org {
+namespace apache {
+namespace arrow {
+namespace flatbuf {
+
+struct TensorDim;
+
+struct Tensor;
+
+/// ----------------------------------------------------------------------
+/// Data structures for dense tensors
+/// Shape data for a single axis in a tensor
+struct TensorDim FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_SIZE = 4,
+    VT_NAME = 6
+  };
+  /// Length of dimension
+  int64_t size() const {
+    return GetField<int64_t>(VT_SIZE, 0);
+  }
+  /// Name of the dimension, optional
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int64_t>(verifier, VT_SIZE) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           verifier.EndTable();
+  }
+};
+
+struct TensorDimBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_size(int64_t size) {
+    fbb_.AddElement<int64_t>(TensorDim::VT_SIZE, size, 0);
+  }
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(TensorDim::VT_NAME, name);
+  }
+  explicit TensorDimBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TensorDimBuilder &operator=(const TensorDimBuilder &);
+  flatbuffers::Offset<TensorDim> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<TensorDim>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<TensorDim> CreateTensorDim(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t size = 0,
+    flatbuffers::Offset<flatbuffers::String> name = 0) {
+  TensorDimBuilder builder_(_fbb);
+  builder_.add_size(size);
+  builder_.add_name(name);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<TensorDim> CreateTensorDimDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    int64_t size = 0,
+    const char *name = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  return org::apache::arrow::flatbuf::CreateTensorDim(
+      _fbb,
+      size,
+      name__);
+}
+
+struct Tensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_TYPE_TYPE = 4,
+    VT_TYPE = 6,
+    VT_SHAPE = 8,
+    VT_STRIDES = 10,
+    VT_DATA = 12
+  };
+  Type type_type() const {
+    return static_cast<Type>(GetField<uint8_t>(VT_TYPE_TYPE, 0));
+  }
+  /// The type of data contained in a value cell. Currently only fixed-width
+  /// value types are supported, no strings or nested types
+  const void *type() const {
+    return GetPointer<const void *>(VT_TYPE);
+  }
+  template<typename T> const T *type_as() const;
+  const Null *type_as_Null() const {
+    return type_type() == Type_Null ? static_cast<const Null *>(type()) : nullptr;
+  }
+  const Int *type_as_Int() const {
+    return type_type() == Type_Int ? static_cast<const Int *>(type()) : nullptr;
+  }
+  const FloatingPoint *type_as_FloatingPoint() const {
+    return type_type() == Type_FloatingPoint ? static_cast<const FloatingPoint *>(type()) : nullptr;
+  }
+  const Binary *type_as_Binary() const {
+    return type_type() == Type_Binary ? static_cast<const Binary *>(type()) : nullptr;
+  }
+  const Utf8 *type_as_Utf8() const {
+    return type_type() == Type_Utf8 ? static_cast<const Utf8 *>(type()) : nullptr;
+  }
+  const Bool *type_as_Bool() const {
+    return type_type() == Type_Bool ? static_cast<const Bool *>(type()) : nullptr;
+  }
+  const Decimal *type_as_Decimal() const {
+    return type_type() == Type_Decimal ? static_cast<const Decimal *>(type()) : nullptr;
+  }
+  const Date *type_as_Date() const {
+    return type_type() == Type_Date ? static_cast<const Date *>(type()) : nullptr;
+  }
+  const Time *type_as_Time() const {
+    return type_type() == Type_Time ? static_cast<const Time *>(type()) : nullptr;
+  }
+  const Timestamp *type_as_Timestamp() const {
+    return type_type() == Type_Timestamp ? static_cast<const Timestamp *>(type()) : nullptr;
+  }
+  const Interval *type_as_Interval() const {
+    return type_type() == Type_Interval ? static_cast<const Interval *>(type()) : nullptr;
+  }
+  const List *type_as_List() const {
+    return type_type() == Type_List ? static_cast<const List *>(type()) : nullptr;
+  }
+  const Struct_ *type_as_Struct_() const {
+    return type_type() == Type_Struct_ ? static_cast<const Struct_ *>(type()) : nullptr;
+  }
+  const Union *type_as_Union() const {
+    return type_type() == Type_Union ? static_cast<const Union *>(type()) : nullptr;
+  }
+  const FixedSizeBinary *type_as_FixedSizeBinary() const {
+    return type_type() == Type_FixedSizeBinary ? static_cast<const FixedSizeBinary *>(type()) : nullptr;
+  }
+  const FixedSizeList *type_as_FixedSizeList() const {
+    return type_type() == Type_FixedSizeList ? static_cast<const FixedSizeList *>(type()) : nullptr;
+  }
+  const Map *type_as_Map() const {
+    return type_type() == Type_Map ? static_cast<const Map *>(type()) : nullptr;
+  }
+  const Duration *type_as_Duration() const {
+    return type_type() == Type_Duration ? static_cast<const Duration *>(type()) : nullptr;
+  }
+  const LargeBinary *type_as_LargeBinary() const {
+    return type_type() == Type_LargeBinary ? static_cast<const LargeBinary *>(type()) : nullptr;
+  }
+  const LargeUtf8 *type_as_LargeUtf8() const {
+    return type_type() == Type_LargeUtf8 ? static_cast<const LargeUtf8 *>(type()) : nullptr;
+  }
+  const LargeList *type_as_LargeList() const {
+    return type_type() == Type_LargeList ? static_cast<const LargeList *>(type()) : nullptr;
+  }
+  /// The dimensions of the tensor, optionally named
+  const flatbuffers::Vector<flatbuffers::Offset<TensorDim>> *shape() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TensorDim>> *>(VT_SHAPE);
+  }
+  /// Non-negative byte offsets to advance one value cell along each dimension
+  const flatbuffers::Vector<int64_t> *strides() const {
+    return GetPointer<const flatbuffers::Vector<int64_t> *>(VT_STRIDES);
+  }
+  /// The location and size of the tensor's data
+  const Buffer *data() const {
+    return GetStruct<const Buffer *>(VT_DATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<uint8_t>(verifier, VT_TYPE_TYPE) &&
+           VerifyOffset(verifier, VT_TYPE) &&
+           VerifyType(verifier, type(), type_type()) &&
+           VerifyOffset(verifier, VT_SHAPE) &&
+           verifier.VerifyVector(shape()) &&
+           verifier.VerifyVectorOfTables(shape()) &&
+           VerifyOffset(verifier, VT_STRIDES) &&
+           verifier.VerifyVector(strides()) &&
+           VerifyField<Buffer>(verifier, VT_DATA) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const Null *Tensor::type_as<Null>() const {
+  return type_as_Null();
+}
+
+template<> inline const Int *Tensor::type_as<Int>() const {
+  return type_as_Int();
+}
+
+template<> inline const FloatingPoint *Tensor::type_as<FloatingPoint>() const {
+  return type_as_FloatingPoint();
+}
+
+template<> inline const Binary *Tensor::type_as<Binary>() const {
+  return type_as_Binary();
+}
+
+template<> inline const Utf8 *Tensor::type_as<Utf8>() const {
+  return type_as_Utf8();
+}
+
+template<> inline const Bool *Tensor::type_as<Bool>() const {
+  return type_as_Bool();
+}
+
+template<> inline const Decimal *Tensor::type_as<Decimal>() const {
+  return type_as_Decimal();
+}
+
+template<> inline const Date *Tensor::type_as<Date>() const {
+  return type_as_Date();
+}
+
+template<> inline const Time *Tensor::type_as<Time>() const {
+  return type_as_Time();
+}
+
+template<> inline const Timestamp *Tensor::type_as<Timestamp>() const {
+  return type_as_Timestamp();
+}
+
+template<> inline const Interval *Tensor::type_as<Interval>() const {
+  return type_as_Interval();
+}
+
+template<> inline const List *Tensor::type_as<List>() const {
+  return type_as_List();
+}
+
+template<> inline const Struct_ *Tensor::type_as<Struct_>() const {
+  return type_as_Struct_();
+}
+
+template<> inline const Union *Tensor::type_as<Union>() const {
+  return type_as_Union();
+}
+
+template<> inline const FixedSizeBinary *Tensor::type_as<FixedSizeBinary>() const {
+  return type_as_FixedSizeBinary();
+}
+
+template<> inline const FixedSizeList *Tensor::type_as<FixedSizeList>() const {
+  return type_as_FixedSizeList();
+}
+
+template<> inline const Map *Tensor::type_as<Map>() const {
+  return type_as_Map();
+}
+
+template<> inline const Duration *Tensor::type_as<Duration>() const {
+  return type_as_Duration();
+}
+
+template<> inline const LargeBinary *Tensor::type_as<LargeBinary>() const {
+  return type_as_LargeBinary();
+}
+
+template<> inline const LargeUtf8 *Tensor::type_as<LargeUtf8>() const {
+  return type_as_LargeUtf8();
+}
+
+template<> inline const LargeList *Tensor::type_as<LargeList>() const {
+  return type_as_LargeList();
+}
+
+struct TensorBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_type_type(Type type_type) {
+    fbb_.AddElement<uint8_t>(Tensor::VT_TYPE_TYPE, static_cast<uint8_t>(type_type), 0);
+  }
+  void add_type(flatbuffers::Offset<void> type) {
+    fbb_.AddOffset(Tensor::VT_TYPE, type);
+  }
+  void add_shape(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TensorDim>>> shape) {
+    fbb_.AddOffset(Tensor::VT_SHAPE, shape);
+  }
+  void add_strides(flatbuffers::Offset<flatbuffers::Vector<int64_t>> strides) {
+    fbb_.AddOffset(Tensor::VT_STRIDES, strides);
+  }
+  void add_data(const Buffer *data) {
+    fbb_.AddStruct(Tensor::VT_DATA, data);
+  }
+  explicit TensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TensorBuilder &operator=(const TensorBuilder &);
+  flatbuffers::Offset<Tensor> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Tensor>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Tensor> CreateTensor(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Type type_type = Type_NONE,
+    flatbuffers::Offset<void> type = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TensorDim>>> shape = 0,
+    flatbuffers::Offset<flatbuffers::Vector<int64_t>> strides = 0,
+    const Buffer *data = 0) {
+  TensorBuilder builder_(_fbb);
+  builder_.add_data(data);
+  builder_.add_strides(strides);
+  builder_.add_shape(shape);
+  builder_.add_type(type);
+  builder_.add_type_type(type_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Tensor> CreateTensorDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Type type_type = Type_NONE,
+    flatbuffers::Offset<void> type = 0,
+    const std::vector<flatbuffers::Offset<TensorDim>> *shape = nullptr,
+    const std::vector<int64_t> *strides = nullptr,
+    const Buffer *data = 0) {
+  auto shape__ = shape ? _fbb.CreateVector<flatbuffers::Offset<TensorDim>>(*shape) : 0;
+  auto strides__ = strides ? _fbb.CreateVector<int64_t>(*strides) : 0;
+  return org::apache::arrow::flatbuf::CreateTensor(
+      _fbb,
+      type_type,
+      type,
+      shape__,
+      strides__,
+      data);
+}
+
+inline const org::apache::arrow::flatbuf::Tensor *GetTensor(const void *buf) {
+  return flatbuffers::GetRoot<org::apache::arrow::flatbuf::Tensor>(buf);
+}
+
+inline const org::apache::arrow::flatbuf::Tensor *GetSizePrefixedTensor(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<org::apache::arrow::flatbuf::Tensor>(buf);
+}
+
+inline bool VerifyTensorBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<org::apache::arrow::flatbuf::Tensor>(nullptr);
+}
+
+inline bool VerifySizePrefixedTensorBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<org::apache::arrow::flatbuf::Tensor>(nullptr);
+}
+
+inline void FinishTensorBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Tensor> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedTensorBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<org::apache::arrow::flatbuf::Tensor> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace flatbuf
+}  // namespace arrow
+}  // namespace apache
+}  // namespace org
+
+#endif  // FLATBUFFERS_GENERATED_TENSOR_ORG_APACHE_ARROW_FLATBUF_H_
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/feather_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/feather_generated.h
new file mode 100644
index 0000000000000000000000000000000000000000..538d3359915e04621570107ad82f202c63d9be8d
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/ipc/feather_generated.h
@@ -0,0 +1,839 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+
+#ifndef FLATBUFFERS_GENERATED_FEATHER_ARROW_IPC_FEATHER_FBS_H_
+#define FLATBUFFERS_GENERATED_FEATHER_ARROW_IPC_FEATHER_FBS_H_
+
+#include "flatbuffers/flatbuffers.h"
+
+namespace arrow {
+namespace ipc {
+namespace feather {
+namespace fbs {
+
+struct PrimitiveArray;
+
+struct CategoryMetadata;
+
+struct TimestampMetadata;
+
+struct DateMetadata;
+
+struct TimeMetadata;
+
+struct Column;
+
+struct CTable;
+
+/// Feather is an experimental serialization format implemented using
+/// techniques from Apache Arrow. It was created as a proof-of-concept of an
+/// interoperable file format for storing data frames originating in Python or
+/// R. It enabled the developers to sidestep some of the open design questions
+/// in Arrow from early 2016 and instead create something simple and useful for
+/// the intended use cases.
+enum Type {
+  Type_BOOL = 0,
+  Type_INT8 = 1,
+  Type_INT16 = 2,
+  Type_INT32 = 3,
+  Type_INT64 = 4,
+  Type_UINT8 = 5,
+  Type_UINT16 = 6,
+  Type_UINT32 = 7,
+  Type_UINT64 = 8,
+  Type_FLOAT = 9,
+  Type_DOUBLE = 10,
+  Type_UTF8 = 11,
+  Type_BINARY = 12,
+  Type_CATEGORY = 13,
+  Type_TIMESTAMP = 14,
+  Type_DATE = 15,
+  Type_TIME = 16,
+  Type_LARGE_UTF8 = 17,
+  Type_LARGE_BINARY = 18,
+  Type_MIN = Type_BOOL,
+  Type_MAX = Type_LARGE_BINARY
+};
+
+inline const Type (&EnumValuesType())[19] {
+  static const Type values[] = {
+    Type_BOOL,
+    Type_INT8,
+    Type_INT16,
+    Type_INT32,
+    Type_INT64,
+    Type_UINT8,
+    Type_UINT16,
+    Type_UINT32,
+    Type_UINT64,
+    Type_FLOAT,
+    Type_DOUBLE,
+    Type_UTF8,
+    Type_BINARY,
+    Type_CATEGORY,
+    Type_TIMESTAMP,
+    Type_DATE,
+    Type_TIME,
+    Type_LARGE_UTF8,
+    Type_LARGE_BINARY
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesType() {
+  static const char * const names[] = {
+    "BOOL",
+    "INT8",
+    "INT16",
+    "INT32",
+    "INT64",
+    "UINT8",
+    "UINT16",
+    "UINT32",
+    "UINT64",
+    "FLOAT",
+    "DOUBLE",
+    "UTF8",
+    "BINARY",
+    "CATEGORY",
+    "TIMESTAMP",
+    "DATE",
+    "TIME",
+    "LARGE_UTF8",
+    "LARGE_BINARY",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameType(Type e) {
+  if (e < Type_BOOL || e > Type_LARGE_BINARY) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesType()[index];
+}
+
+enum Encoding {
+  Encoding_PLAIN = 0  /// Data is stored dictionary-encoded
+  /// dictionary size: <INT32 Dictionary size>
+  /// dictionary data: <TYPE primitive array>
+  /// dictionary index: <INT32 primitive array>
+  ///
+  /// TODO: do we care about storing the index values in a smaller typeclass
+,
+  Encoding_DICTIONARY = 1,
+  Encoding_MIN = Encoding_PLAIN,
+  Encoding_MAX = Encoding_DICTIONARY
+};
+
+inline const Encoding (&EnumValuesEncoding())[2] {
+  static const Encoding values[] = {
+    Encoding_PLAIN,
+    Encoding_DICTIONARY
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesEncoding() {
+  static const char * const names[] = {
+    "PLAIN",
+    "DICTIONARY",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameEncoding(Encoding e) {
+  if (e < Encoding_PLAIN || e > Encoding_DICTIONARY) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesEncoding()[index];
+}
+
+enum TimeUnit {
+  TimeUnit_SECOND = 0,
+  TimeUnit_MILLISECOND = 1,
+  TimeUnit_MICROSECOND = 2,
+  TimeUnit_NANOSECOND = 3,
+  TimeUnit_MIN = TimeUnit_SECOND,
+  TimeUnit_MAX = TimeUnit_NANOSECOND
+};
+
+inline const TimeUnit (&EnumValuesTimeUnit())[4] {
+  static const TimeUnit values[] = {
+    TimeUnit_SECOND,
+    TimeUnit_MILLISECOND,
+    TimeUnit_MICROSECOND,
+    TimeUnit_NANOSECOND
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesTimeUnit() {
+  static const char * const names[] = {
+    "SECOND",
+    "MILLISECOND",
+    "MICROSECOND",
+    "NANOSECOND",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameTimeUnit(TimeUnit e) {
+  if (e < TimeUnit_SECOND || e > TimeUnit_NANOSECOND) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesTimeUnit()[index];
+}
+
+enum TypeMetadata {
+  TypeMetadata_NONE = 0,
+  TypeMetadata_CategoryMetadata = 1,
+  TypeMetadata_TimestampMetadata = 2,
+  TypeMetadata_DateMetadata = 3,
+  TypeMetadata_TimeMetadata = 4,
+  TypeMetadata_MIN = TypeMetadata_NONE,
+  TypeMetadata_MAX = TypeMetadata_TimeMetadata
+};
+
+inline const TypeMetadata (&EnumValuesTypeMetadata())[5] {
+  static const TypeMetadata values[] = {
+    TypeMetadata_NONE,
+    TypeMetadata_CategoryMetadata,
+    TypeMetadata_TimestampMetadata,
+    TypeMetadata_DateMetadata,
+    TypeMetadata_TimeMetadata
+  };
+  return values;
+}
+
+inline const char * const *EnumNamesTypeMetadata() {
+  static const char * const names[] = {
+    "NONE",
+    "CategoryMetadata",
+    "TimestampMetadata",
+    "DateMetadata",
+    "TimeMetadata",
+    nullptr
+  };
+  return names;
+}
+
+inline const char *EnumNameTypeMetadata(TypeMetadata e) {
+  if (e < TypeMetadata_NONE || e > TypeMetadata_TimeMetadata) return "";
+  const size_t index = static_cast<size_t>(e);
+  return EnumNamesTypeMetadata()[index];
+}
+
+template<typename T> struct TypeMetadataTraits {
+  static const TypeMetadata enum_value = TypeMetadata_NONE;
+};
+
+template<> struct TypeMetadataTraits<CategoryMetadata> {
+  static const TypeMetadata enum_value = TypeMetadata_CategoryMetadata;
+};
+
+template<> struct TypeMetadataTraits<TimestampMetadata> {
+  static const TypeMetadata enum_value = TypeMetadata_TimestampMetadata;
+};
+
+template<> struct TypeMetadataTraits<DateMetadata> {
+  static const TypeMetadata enum_value = TypeMetadata_DateMetadata;
+};
+
+template<> struct TypeMetadataTraits<TimeMetadata> {
+  static const TypeMetadata enum_value = TypeMetadata_TimeMetadata;
+};
+
+bool VerifyTypeMetadata(flatbuffers::Verifier &verifier, const void *obj, TypeMetadata type);
+bool VerifyTypeMetadataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
+
+struct PrimitiveArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_TYPE = 4,
+    VT_ENCODING = 6,
+    VT_OFFSET = 8,
+    VT_LENGTH = 10,
+    VT_NULL_COUNT = 12,
+    VT_TOTAL_BYTES = 14
+  };
+  Type type() const {
+    return static_cast<Type>(GetField<int8_t>(VT_TYPE, 0));
+  }
+  Encoding encoding() const {
+    return static_cast<Encoding>(GetField<int8_t>(VT_ENCODING, 0));
+  }
+  /// Relative memory offset of the start of the array data excluding the size
+  /// of the metadata
+  int64_t offset() const {
+    return GetField<int64_t>(VT_OFFSET, 0);
+  }
+  /// The number of logical values in the array
+  int64_t length() const {
+    return GetField<int64_t>(VT_LENGTH, 0);
+  }
+  /// The number of observed nulls
+  int64_t null_count() const {
+    return GetField<int64_t>(VT_NULL_COUNT, 0);
+  }
+  /// The total size of the actual data in the file
+  int64_t total_bytes() const {
+    return GetField<int64_t>(VT_TOTAL_BYTES, 0);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int8_t>(verifier, VT_TYPE) &&
+           VerifyField<int8_t>(verifier, VT_ENCODING) &&
+           VerifyField<int64_t>(verifier, VT_OFFSET) &&
+           VerifyField<int64_t>(verifier, VT_LENGTH) &&
+           VerifyField<int64_t>(verifier, VT_NULL_COUNT) &&
+           VerifyField<int64_t>(verifier, VT_TOTAL_BYTES) &&
+           verifier.EndTable();
+  }
+};
+
+struct PrimitiveArrayBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_type(Type type) {
+    fbb_.AddElement<int8_t>(PrimitiveArray::VT_TYPE, static_cast<int8_t>(type), 0);
+  }
+  void add_encoding(Encoding encoding) {
+    fbb_.AddElement<int8_t>(PrimitiveArray::VT_ENCODING, static_cast<int8_t>(encoding), 0);
+  }
+  void add_offset(int64_t offset) {
+    fbb_.AddElement<int64_t>(PrimitiveArray::VT_OFFSET, offset, 0);
+  }
+  void add_length(int64_t length) {
+    fbb_.AddElement<int64_t>(PrimitiveArray::VT_LENGTH, length, 0);
+  }
+  void add_null_count(int64_t null_count) {
+    fbb_.AddElement<int64_t>(PrimitiveArray::VT_NULL_COUNT, null_count, 0);
+  }
+  void add_total_bytes(int64_t total_bytes) {
+    fbb_.AddElement<int64_t>(PrimitiveArray::VT_TOTAL_BYTES, total_bytes, 0);
+  }
+  explicit PrimitiveArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  PrimitiveArrayBuilder &operator=(const PrimitiveArrayBuilder &);
+  flatbuffers::Offset<PrimitiveArray> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<PrimitiveArray>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<PrimitiveArray> CreatePrimitiveArray(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    Type type = Type_BOOL,
+    Encoding encoding = Encoding_PLAIN,
+    int64_t offset = 0,
+    int64_t length = 0,
+    int64_t null_count = 0,
+    int64_t total_bytes = 0) {
+  PrimitiveArrayBuilder builder_(_fbb);
+  builder_.add_total_bytes(total_bytes);
+  builder_.add_null_count(null_count);
+  builder_.add_length(length);
+  builder_.add_offset(offset);
+  builder_.add_encoding(encoding);
+  builder_.add_type(type);
+  return builder_.Finish();
+}
+
+struct CategoryMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_LEVELS = 4,
+    VT_ORDERED = 6
+  };
+  /// The category codes are presumed to be integers that are valid indexes into
+  /// the levels array
+  const PrimitiveArray *levels() const {
+    return GetPointer<const PrimitiveArray *>(VT_LEVELS);
+  }
+  bool ordered() const {
+    return GetField<uint8_t>(VT_ORDERED, 0) != 0;
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_LEVELS) &&
+           verifier.VerifyTable(levels()) &&
+           VerifyField<uint8_t>(verifier, VT_ORDERED) &&
+           verifier.EndTable();
+  }
+};
+
+struct CategoryMetadataBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_levels(flatbuffers::Offset<PrimitiveArray> levels) {
+    fbb_.AddOffset(CategoryMetadata::VT_LEVELS, levels);
+  }
+  void add_ordered(bool ordered) {
+    fbb_.AddElement<uint8_t>(CategoryMetadata::VT_ORDERED, static_cast<uint8_t>(ordered), 0);
+  }
+  explicit CategoryMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  CategoryMetadataBuilder &operator=(const CategoryMetadataBuilder &);
+  flatbuffers::Offset<CategoryMetadata> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<CategoryMetadata>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<CategoryMetadata> CreateCategoryMetadata(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<PrimitiveArray> levels = 0,
+    bool ordered = false) {
+  CategoryMetadataBuilder builder_(_fbb);
+  builder_.add_levels(levels);
+  builder_.add_ordered(ordered);
+  return builder_.Finish();
+}
+
+struct TimestampMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4,
+    VT_TIMEZONE = 6
+  };
+  TimeUnit unit() const {
+    return static_cast<TimeUnit>(GetField<int8_t>(VT_UNIT, 0));
+  }
+  /// Timestamp data is assumed to be UTC, but the time zone is stored here for
+  /// presentation as localized
+  const flatbuffers::String *timezone() const {
+    return GetPointer<const flatbuffers::String *>(VT_TIMEZONE);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int8_t>(verifier, VT_UNIT) &&
+           VerifyOffset(verifier, VT_TIMEZONE) &&
+           verifier.VerifyString(timezone()) &&
+           verifier.EndTable();
+  }
+};
+
+struct TimestampMetadataBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(TimeUnit unit) {
+    fbb_.AddElement<int8_t>(TimestampMetadata::VT_UNIT, static_cast<int8_t>(unit), 0);
+  }
+  void add_timezone(flatbuffers::Offset<flatbuffers::String> timezone) {
+    fbb_.AddOffset(TimestampMetadata::VT_TIMEZONE, timezone);
+  }
+  explicit TimestampMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TimestampMetadataBuilder &operator=(const TimestampMetadataBuilder &);
+  flatbuffers::Offset<TimestampMetadata> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<TimestampMetadata>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadata(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_SECOND,
+    flatbuffers::Offset<flatbuffers::String> timezone = 0) {
+  TimestampMetadataBuilder builder_(_fbb);
+  builder_.add_timezone(timezone);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<TimestampMetadata> CreateTimestampMetadataDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_SECOND,
+    const char *timezone = nullptr) {
+  auto timezone__ = timezone ? _fbb.CreateString(timezone) : 0;
+  return arrow::ipc::feather::fbs::CreateTimestampMetadata(
+      _fbb,
+      unit,
+      timezone__);
+}
+
+struct DateMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct DateMetadataBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit DateMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  DateMetadataBuilder &operator=(const DateMetadataBuilder &);
+  flatbuffers::Offset<DateMetadata> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<DateMetadata>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<DateMetadata> CreateDateMetadata(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  DateMetadataBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
+struct TimeMetadata FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_UNIT = 4
+  };
+  TimeUnit unit() const {
+    return static_cast<TimeUnit>(GetField<int8_t>(VT_UNIT, 0));
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyField<int8_t>(verifier, VT_UNIT) &&
+           verifier.EndTable();
+  }
+};
+
+struct TimeMetadataBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_unit(TimeUnit unit) {
+    fbb_.AddElement<int8_t>(TimeMetadata::VT_UNIT, static_cast<int8_t>(unit), 0);
+  }
+  explicit TimeMetadataBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  TimeMetadataBuilder &operator=(const TimeMetadataBuilder &);
+  flatbuffers::Offset<TimeMetadata> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<TimeMetadata>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<TimeMetadata> CreateTimeMetadata(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    TimeUnit unit = TimeUnit_SECOND) {
+  TimeMetadataBuilder builder_(_fbb);
+  builder_.add_unit(unit);
+  return builder_.Finish();
+}
+
+struct Column FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_NAME = 4,
+    VT_VALUES = 6,
+    VT_METADATA_TYPE = 8,
+    VT_METADATA = 10,
+    VT_USER_METADATA = 12
+  };
+  const flatbuffers::String *name() const {
+    return GetPointer<const flatbuffers::String *>(VT_NAME);
+  }
+  const PrimitiveArray *values() const {
+    return GetPointer<const PrimitiveArray *>(VT_VALUES);
+  }
+  TypeMetadata metadata_type() const {
+    return static_cast<TypeMetadata>(GetField<uint8_t>(VT_METADATA_TYPE, 0));
+  }
+  const void *metadata() const {
+    return GetPointer<const void *>(VT_METADATA);
+  }
+  template<typename T> const T *metadata_as() const;
+  const CategoryMetadata *metadata_as_CategoryMetadata() const {
+    return metadata_type() == TypeMetadata_CategoryMetadata ? static_cast<const CategoryMetadata *>(metadata()) : nullptr;
+  }
+  const TimestampMetadata *metadata_as_TimestampMetadata() const {
+    return metadata_type() == TypeMetadata_TimestampMetadata ? static_cast<const TimestampMetadata *>(metadata()) : nullptr;
+  }
+  const DateMetadata *metadata_as_DateMetadata() const {
+    return metadata_type() == TypeMetadata_DateMetadata ? static_cast<const DateMetadata *>(metadata()) : nullptr;
+  }
+  const TimeMetadata *metadata_as_TimeMetadata() const {
+    return metadata_type() == TypeMetadata_TimeMetadata ? static_cast<const TimeMetadata *>(metadata()) : nullptr;
+  }
+  /// This should (probably) be JSON
+  const flatbuffers::String *user_metadata() const {
+    return GetPointer<const flatbuffers::String *>(VT_USER_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_NAME) &&
+           verifier.VerifyString(name()) &&
+           VerifyOffset(verifier, VT_VALUES) &&
+           verifier.VerifyTable(values()) &&
+           VerifyField<uint8_t>(verifier, VT_METADATA_TYPE) &&
+           VerifyOffset(verifier, VT_METADATA) &&
+           VerifyTypeMetadata(verifier, metadata(), metadata_type()) &&
+           VerifyOffset(verifier, VT_USER_METADATA) &&
+           verifier.VerifyString(user_metadata()) &&
+           verifier.EndTable();
+  }
+};
+
+template<> inline const CategoryMetadata *Column::metadata_as<CategoryMetadata>() const {
+  return metadata_as_CategoryMetadata();
+}
+
+template<> inline const TimestampMetadata *Column::metadata_as<TimestampMetadata>() const {
+  return metadata_as_TimestampMetadata();
+}
+
+template<> inline const DateMetadata *Column::metadata_as<DateMetadata>() const {
+  return metadata_as_DateMetadata();
+}
+
+template<> inline const TimeMetadata *Column::metadata_as<TimeMetadata>() const {
+  return metadata_as_TimeMetadata();
+}
+
+struct ColumnBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_name(flatbuffers::Offset<flatbuffers::String> name) {
+    fbb_.AddOffset(Column::VT_NAME, name);
+  }
+  void add_values(flatbuffers::Offset<PrimitiveArray> values) {
+    fbb_.AddOffset(Column::VT_VALUES, values);
+  }
+  void add_metadata_type(TypeMetadata metadata_type) {
+    fbb_.AddElement<uint8_t>(Column::VT_METADATA_TYPE, static_cast<uint8_t>(metadata_type), 0);
+  }
+  void add_metadata(flatbuffers::Offset<void> metadata) {
+    fbb_.AddOffset(Column::VT_METADATA, metadata);
+  }
+  void add_user_metadata(flatbuffers::Offset<flatbuffers::String> user_metadata) {
+    fbb_.AddOffset(Column::VT_USER_METADATA, user_metadata);
+  }
+  explicit ColumnBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  ColumnBuilder &operator=(const ColumnBuilder &);
+  flatbuffers::Offset<Column> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<Column>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<Column> CreateColumn(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> name = 0,
+    flatbuffers::Offset<PrimitiveArray> values = 0,
+    TypeMetadata metadata_type = TypeMetadata_NONE,
+    flatbuffers::Offset<void> metadata = 0,
+    flatbuffers::Offset<flatbuffers::String> user_metadata = 0) {
+  ColumnBuilder builder_(_fbb);
+  builder_.add_user_metadata(user_metadata);
+  builder_.add_metadata(metadata);
+  builder_.add_values(values);
+  builder_.add_name(name);
+  builder_.add_metadata_type(metadata_type);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<Column> CreateColumnDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *name = nullptr,
+    flatbuffers::Offset<PrimitiveArray> values = 0,
+    TypeMetadata metadata_type = TypeMetadata_NONE,
+    flatbuffers::Offset<void> metadata = 0,
+    const char *user_metadata = nullptr) {
+  auto name__ = name ? _fbb.CreateString(name) : 0;
+  auto user_metadata__ = user_metadata ? _fbb.CreateString(user_metadata) : 0;
+  return arrow::ipc::feather::fbs::CreateColumn(
+      _fbb,
+      name__,
+      values,
+      metadata_type,
+      metadata,
+      user_metadata__);
+}
+
+struct CTable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
+    VT_DESCRIPTION = 4,
+    VT_NUM_ROWS = 6,
+    VT_COLUMNS = 8,
+    VT_VERSION = 10,
+    VT_METADATA = 12
+  };
+  /// Some text (or a name) metadata about what the file is, optional
+  const flatbuffers::String *description() const {
+    return GetPointer<const flatbuffers::String *>(VT_DESCRIPTION);
+  }
+  int64_t num_rows() const {
+    return GetField<int64_t>(VT_NUM_ROWS, 0);
+  }
+  const flatbuffers::Vector<flatbuffers::Offset<Column>> *columns() const {
+    return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<Column>> *>(VT_COLUMNS);
+  }
+  /// Version number of the Feather format
+  int32_t version() const {
+    return GetField<int32_t>(VT_VERSION, 0);
+  }
+  /// Table metadata (likely JSON), not yet used
+  const flatbuffers::String *metadata() const {
+    return GetPointer<const flatbuffers::String *>(VT_METADATA);
+  }
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           VerifyOffset(verifier, VT_DESCRIPTION) &&
+           verifier.VerifyString(description()) &&
+           VerifyField<int64_t>(verifier, VT_NUM_ROWS) &&
+           VerifyOffset(verifier, VT_COLUMNS) &&
+           verifier.VerifyVector(columns()) &&
+           verifier.VerifyVectorOfTables(columns()) &&
+           VerifyField<int32_t>(verifier, VT_VERSION) &&
+           VerifyOffset(verifier, VT_METADATA) &&
+           verifier.VerifyString(metadata()) &&
+           verifier.EndTable();
+  }
+};
+
+struct CTableBuilder {
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  void add_description(flatbuffers::Offset<flatbuffers::String> description) {
+    fbb_.AddOffset(CTable::VT_DESCRIPTION, description);
+  }
+  void add_num_rows(int64_t num_rows) {
+    fbb_.AddElement<int64_t>(CTable::VT_NUM_ROWS, num_rows, 0);
+  }
+  void add_columns(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Column>>> columns) {
+    fbb_.AddOffset(CTable::VT_COLUMNS, columns);
+  }
+  void add_version(int32_t version) {
+    fbb_.AddElement<int32_t>(CTable::VT_VERSION, version, 0);
+  }
+  void add_metadata(flatbuffers::Offset<flatbuffers::String> metadata) {
+    fbb_.AddOffset(CTable::VT_METADATA, metadata);
+  }
+  explicit CTableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  CTableBuilder &operator=(const CTableBuilder &);
+  flatbuffers::Offset<CTable> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<CTable>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<CTable> CreateCTable(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    flatbuffers::Offset<flatbuffers::String> description = 0,
+    int64_t num_rows = 0,
+    flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<Column>>> columns = 0,
+    int32_t version = 0,
+    flatbuffers::Offset<flatbuffers::String> metadata = 0) {
+  CTableBuilder builder_(_fbb);
+  builder_.add_num_rows(num_rows);
+  builder_.add_metadata(metadata);
+  builder_.add_version(version);
+  builder_.add_columns(columns);
+  builder_.add_description(description);
+  return builder_.Finish();
+}
+
+inline flatbuffers::Offset<CTable> CreateCTableDirect(
+    flatbuffers::FlatBufferBuilder &_fbb,
+    const char *description = nullptr,
+    int64_t num_rows = 0,
+    const std::vector<flatbuffers::Offset<Column>> *columns = nullptr,
+    int32_t version = 0,
+    const char *metadata = nullptr) {
+  auto description__ = description ? _fbb.CreateString(description) : 0;
+  auto columns__ = columns ? _fbb.CreateVector<flatbuffers::Offset<Column>>(*columns) : 0;
+  auto metadata__ = metadata ? _fbb.CreateString(metadata) : 0;
+  return arrow::ipc::feather::fbs::CreateCTable(
+      _fbb,
+      description__,
+      num_rows,
+      columns__,
+      version,
+      metadata__);
+}
+
+inline bool VerifyTypeMetadata(flatbuffers::Verifier &verifier, const void *obj, TypeMetadata type) {
+  switch (type) {
+    case TypeMetadata_NONE: {
+      return true;
+    }
+    case TypeMetadata_CategoryMetadata: {
+      auto ptr = reinterpret_cast<const CategoryMetadata *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case TypeMetadata_TimestampMetadata: {
+      auto ptr = reinterpret_cast<const TimestampMetadata *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case TypeMetadata_DateMetadata: {
+      auto ptr = reinterpret_cast<const DateMetadata *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    case TypeMetadata_TimeMetadata: {
+      auto ptr = reinterpret_cast<const TimeMetadata *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
+    default: return false;
+  }
+}
+
+inline bool VerifyTypeMetadataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
+  if (!values || !types) return !values && !types;
+  if (values->size() != types->size()) return false;
+  for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
+    if (!VerifyTypeMetadata(
+        verifier,  values->Get(i), types->GetEnum<TypeMetadata>(i))) {
+      return false;
+    }
+  }
+  return true;
+}
+
+inline const arrow::ipc::feather::fbs::CTable *GetCTable(const void *buf) {
+  return flatbuffers::GetRoot<arrow::ipc::feather::fbs::CTable>(buf);
+}
+
+inline const arrow::ipc::feather::fbs::CTable *GetSizePrefixedCTable(const void *buf) {
+  return flatbuffers::GetSizePrefixedRoot<arrow::ipc::feather::fbs::CTable>(buf);
+}
+
+inline bool VerifyCTableBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifyBuffer<arrow::ipc::feather::fbs::CTable>(nullptr);
+}
+
+inline bool VerifySizePrefixedCTableBuffer(
+    flatbuffers::Verifier &verifier) {
+  return verifier.VerifySizePrefixedBuffer<arrow::ipc::feather::fbs::CTable>(nullptr);
+}
+
+inline void FinishCTableBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<arrow::ipc::feather::fbs::CTable> root) {
+  fbb.Finish(root);
+}
+
+inline void FinishSizePrefixedCTableBuffer(
+    flatbuffers::FlatBufferBuilder &fbb,
+    flatbuffers::Offset<arrow::ipc::feather::fbs::CTable> root) {
+  fbb.FinishSizePrefixed(root);
+}
+
+}  // namespace fbs
+}  // namespace feather
+}  // namespace ipc
+}  // namespace arrow
+
+#endif  // FLATBUFFERS_GENERATED_FEATHER_ARROW_IPC_FEATHER_FBS_H_
diff --git a/contrib/arrow-cmake/cpp/src/arrow/util/config.h b/contrib/arrow-cmake/cpp/src/arrow/util/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..c803ebb526334e36f574d85b871acb4719619e3b
--- /dev/null
+++ b/contrib/arrow-cmake/cpp/src/arrow/util/config.h
@@ -0,0 +1,24 @@
+// 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.
+
+#define ARROW_VERSION_MAJOR 
+#define ARROW_VERSION_MINOR 
+#define ARROW_VERSION_PATCH 
+#define ARROW_VERSION ((ARROW_VERSION_MAJOR * 1000) + ARROW_VERSION_MINOR) * 1000 + ARROW_VERSION_PATCH
+
+/* #undef DOUBLE_CONVERSION_HAS_CASE_INSENSIBILITY */
+/* #undef GRPCPP_PP_INCLUDE */
diff --git a/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.cpp b/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.cpp
index e1775208368ed04699e5ad2ceb2d0b29c5f05916..8efba22eb0e0d455b742c04b493e856b3fde768a 100644
--- a/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.cpp
+++ b/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.11.0)
+ * Autogenerated by Thrift Compiler (0.12.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
diff --git a/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.h b/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.h
index b4fbf3ab99eebdb7102966c3d5b7bba359ec8f41..a84198bfa44b34efb461ccad5e9d0ecfa8620218 100644
--- a/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.h
+++ b/contrib/arrow-cmake/cpp/src/parquet/parquet_constants.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.11.0)
+ * Autogenerated by Thrift Compiler (0.12.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
diff --git a/contrib/arrow-cmake/cpp/src/parquet/parquet_types.cpp b/contrib/arrow-cmake/cpp/src/parquet/parquet_types.cpp
index f9780d268f3359e91337e0fda2a23e0526b6ab49..9ad7468956761de45c9dab6606ccd396696d124b 100644
--- a/contrib/arrow-cmake/cpp/src/parquet/parquet_types.cpp
+++ b/contrib/arrow-cmake/cpp/src/parquet/parquet_types.cpp
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.11.0)
+ * Autogenerated by Thrift Compiler (0.12.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -1167,6 +1167,74 @@ void MicroSeconds::printTo(std::ostream& out) const {
 }
 
 
+NanoSeconds::~NanoSeconds() throw() {
+}
+
+std::ostream& operator<<(std::ostream& out, const NanoSeconds& obj)
+{
+  obj.printTo(out);
+  return out;
+}
+
+
+uint32_t NanoSeconds::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    xfer += iprot->skip(ftype);
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NanoSeconds::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+  xfer += oprot->writeStructBegin("NanoSeconds");
+
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(NanoSeconds &a, NanoSeconds &b) {
+  using ::std::swap;
+  (void) a;
+  (void) b;
+}
+
+NanoSeconds::NanoSeconds(const NanoSeconds& other22) {
+  (void) other22;
+}
+NanoSeconds& NanoSeconds::operator=(const NanoSeconds& other23) {
+  (void) other23;
+  return *this;
+}
+void NanoSeconds::printTo(std::ostream& out) const {
+  using ::apache::thrift::to_string;
+  out << "NanoSeconds(";
+  out << ")";
+}
+
+
 TimeUnit::~TimeUnit() throw() {
 }
 
@@ -1180,6 +1248,11 @@ void TimeUnit::__set_MICROS(const MicroSeconds& val) {
   this->MICROS = val;
 __isset.MICROS = true;
 }
+
+void TimeUnit::__set_NANOS(const NanoSeconds& val) {
+  this->NANOS = val;
+__isset.NANOS = true;
+}
 std::ostream& operator<<(std::ostream& out, const TimeUnit& obj)
 {
   obj.printTo(out);
@@ -1224,6 +1297,14 @@ uint32_t TimeUnit::read(::apache::thrift::protocol::TProtocol* iprot) {
           xfer += iprot->skip(ftype);
         }
         break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->NANOS.read(iprot);
+          this->__isset.NANOS = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -1251,6 +1332,11 @@ uint32_t TimeUnit::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += this->MICROS.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
+  if (this->__isset.NANOS) {
+    xfer += oprot->writeFieldBegin("NANOS", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->NANOS.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -1260,18 +1346,21 @@ void swap(TimeUnit &a, TimeUnit &b) {
   using ::std::swap;
   swap(a.MILLIS, b.MILLIS);
   swap(a.MICROS, b.MICROS);
+  swap(a.NANOS, b.NANOS);
   swap(a.__isset, b.__isset);
 }
 
-TimeUnit::TimeUnit(const TimeUnit& other22) {
-  MILLIS = other22.MILLIS;
-  MICROS = other22.MICROS;
-  __isset = other22.__isset;
+TimeUnit::TimeUnit(const TimeUnit& other24) {
+  MILLIS = other24.MILLIS;
+  MICROS = other24.MICROS;
+  NANOS = other24.NANOS;
+  __isset = other24.__isset;
 }
-TimeUnit& TimeUnit::operator=(const TimeUnit& other23) {
-  MILLIS = other23.MILLIS;
-  MICROS = other23.MICROS;
-  __isset = other23.__isset;
+TimeUnit& TimeUnit::operator=(const TimeUnit& other25) {
+  MILLIS = other25.MILLIS;
+  MICROS = other25.MICROS;
+  NANOS = other25.NANOS;
+  __isset = other25.__isset;
   return *this;
 }
 void TimeUnit::printTo(std::ostream& out) const {
@@ -1279,6 +1368,7 @@ void TimeUnit::printTo(std::ostream& out) const {
   out << "TimeUnit(";
   out << "MILLIS="; (__isset.MILLIS ? (out << to_string(MILLIS)) : (out << "<null>"));
   out << ", " << "MICROS="; (__isset.MICROS ? (out << to_string(MICROS)) : (out << "<null>"));
+  out << ", " << "NANOS="; (__isset.NANOS ? (out << to_string(NANOS)) : (out << "<null>"));
   out << ")";
 }
 
@@ -1380,13 +1470,13 @@ void swap(TimestampType &a, TimestampType &b) {
   swap(a.unit, b.unit);
 }
 
-TimestampType::TimestampType(const TimestampType& other24) {
-  isAdjustedToUTC = other24.isAdjustedToUTC;
-  unit = other24.unit;
+TimestampType::TimestampType(const TimestampType& other26) {
+  isAdjustedToUTC = other26.isAdjustedToUTC;
+  unit = other26.unit;
 }
-TimestampType& TimestampType::operator=(const TimestampType& other25) {
-  isAdjustedToUTC = other25.isAdjustedToUTC;
-  unit = other25.unit;
+TimestampType& TimestampType::operator=(const TimestampType& other27) {
+  isAdjustedToUTC = other27.isAdjustedToUTC;
+  unit = other27.unit;
   return *this;
 }
 void TimestampType::printTo(std::ostream& out) const {
@@ -1495,13 +1585,13 @@ void swap(TimeType &a, TimeType &b) {
   swap(a.unit, b.unit);
 }
 
-TimeType::TimeType(const TimeType& other26) {
-  isAdjustedToUTC = other26.isAdjustedToUTC;
-  unit = other26.unit;
+TimeType::TimeType(const TimeType& other28) {
+  isAdjustedToUTC = other28.isAdjustedToUTC;
+  unit = other28.unit;
 }
-TimeType& TimeType::operator=(const TimeType& other27) {
-  isAdjustedToUTC = other27.isAdjustedToUTC;
-  unit = other27.unit;
+TimeType& TimeType::operator=(const TimeType& other29) {
+  isAdjustedToUTC = other29.isAdjustedToUTC;
+  unit = other29.unit;
   return *this;
 }
 void TimeType::printTo(std::ostream& out) const {
@@ -1610,13 +1700,13 @@ void swap(IntType &a, IntType &b) {
   swap(a.isSigned, b.isSigned);
 }
 
-IntType::IntType(const IntType& other28) {
-  bitWidth = other28.bitWidth;
-  isSigned = other28.isSigned;
+IntType::IntType(const IntType& other30) {
+  bitWidth = other30.bitWidth;
+  isSigned = other30.isSigned;
 }
-IntType& IntType::operator=(const IntType& other29) {
-  bitWidth = other29.bitWidth;
-  isSigned = other29.isSigned;
+IntType& IntType::operator=(const IntType& other31) {
+  bitWidth = other31.bitWidth;
+  isSigned = other31.isSigned;
   return *this;
 }
 void IntType::printTo(std::ostream& out) const {
@@ -1682,11 +1772,11 @@ void swap(JsonType &a, JsonType &b) {
   (void) b;
 }
 
-JsonType::JsonType(const JsonType& other30) {
-  (void) other30;
+JsonType::JsonType(const JsonType& other32) {
+  (void) other32;
 }
-JsonType& JsonType::operator=(const JsonType& other31) {
-  (void) other31;
+JsonType& JsonType::operator=(const JsonType& other33) {
+  (void) other33;
   return *this;
 }
 void JsonType::printTo(std::ostream& out) const {
@@ -1750,11 +1840,11 @@ void swap(BsonType &a, BsonType &b) {
   (void) b;
 }
 
-BsonType::BsonType(const BsonType& other32) {
-  (void) other32;
+BsonType::BsonType(const BsonType& other34) {
+  (void) other34;
 }
-BsonType& BsonType::operator=(const BsonType& other33) {
-  (void) other33;
+BsonType& BsonType::operator=(const BsonType& other35) {
+  (void) other35;
   return *this;
 }
 void BsonType::printTo(std::ostream& out) const {
@@ -1827,6 +1917,11 @@ void LogicalType::__set_BSON(const BsonType& val) {
   this->BSON = val;
 __isset.BSON = true;
 }
+
+void LogicalType::__set_UUID(const UUIDType& val) {
+  this->UUID = val;
+__isset.UUID = true;
+}
 std::ostream& operator<<(std::ostream& out, const LogicalType& obj)
 {
   obj.printTo(out);
@@ -1951,6 +2046,14 @@ uint32_t LogicalType::read(::apache::thrift::protocol::TProtocol* iprot) {
           xfer += iprot->skip(ftype);
         }
         break;
+      case 14:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->UUID.read(iprot);
+          this->__isset.UUID = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -2028,6 +2131,11 @@ uint32_t LogicalType::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += this->BSON.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
+  if (this->__isset.UUID) {
+    xfer += oprot->writeFieldBegin("UUID", ::apache::thrift::protocol::T_STRUCT, 14);
+    xfer += this->UUID.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -2047,38 +2155,41 @@ void swap(LogicalType &a, LogicalType &b) {
   swap(a.UNKNOWN, b.UNKNOWN);
   swap(a.JSON, b.JSON);
   swap(a.BSON, b.BSON);
+  swap(a.UUID, b.UUID);
   swap(a.__isset, b.__isset);
 }
 
-LogicalType::LogicalType(const LogicalType& other34) {
-  STRING = other34.STRING;
-  MAP = other34.MAP;
-  LIST = other34.LIST;
-  ENUM = other34.ENUM;
-  DECIMAL = other34.DECIMAL;
-  DATE = other34.DATE;
-  TIME = other34.TIME;
-  TIMESTAMP = other34.TIMESTAMP;
-  INTEGER = other34.INTEGER;
-  UNKNOWN = other34.UNKNOWN;
-  JSON = other34.JSON;
-  BSON = other34.BSON;
-  __isset = other34.__isset;
-}
-LogicalType& LogicalType::operator=(const LogicalType& other35) {
-  STRING = other35.STRING;
-  MAP = other35.MAP;
-  LIST = other35.LIST;
-  ENUM = other35.ENUM;
-  DECIMAL = other35.DECIMAL;
-  DATE = other35.DATE;
-  TIME = other35.TIME;
-  TIMESTAMP = other35.TIMESTAMP;
-  INTEGER = other35.INTEGER;
-  UNKNOWN = other35.UNKNOWN;
-  JSON = other35.JSON;
-  BSON = other35.BSON;
-  __isset = other35.__isset;
+LogicalType::LogicalType(const LogicalType& other36) {
+  STRING = other36.STRING;
+  MAP = other36.MAP;
+  LIST = other36.LIST;
+  ENUM = other36.ENUM;
+  DECIMAL = other36.DECIMAL;
+  DATE = other36.DATE;
+  TIME = other36.TIME;
+  TIMESTAMP = other36.TIMESTAMP;
+  INTEGER = other36.INTEGER;
+  UNKNOWN = other36.UNKNOWN;
+  JSON = other36.JSON;
+  BSON = other36.BSON;
+  UUID = other36.UUID;
+  __isset = other36.__isset;
+}
+LogicalType& LogicalType::operator=(const LogicalType& other37) {
+  STRING = other37.STRING;
+  MAP = other37.MAP;
+  LIST = other37.LIST;
+  ENUM = other37.ENUM;
+  DECIMAL = other37.DECIMAL;
+  DATE = other37.DATE;
+  TIME = other37.TIME;
+  TIMESTAMP = other37.TIMESTAMP;
+  INTEGER = other37.INTEGER;
+  UNKNOWN = other37.UNKNOWN;
+  JSON = other37.JSON;
+  BSON = other37.BSON;
+  UUID = other37.UUID;
+  __isset = other37.__isset;
   return *this;
 }
 void LogicalType::printTo(std::ostream& out) const {
@@ -2096,6 +2207,7 @@ void LogicalType::printTo(std::ostream& out) const {
   out << ", " << "UNKNOWN="; (__isset.UNKNOWN ? (out << to_string(UNKNOWN)) : (out << "<null>"));
   out << ", " << "JSON="; (__isset.JSON ? (out << to_string(JSON)) : (out << "<null>"));
   out << ", " << "BSON="; (__isset.BSON ? (out << to_string(BSON)) : (out << "<null>"));
+  out << ", " << "UUID="; (__isset.UUID ? (out << to_string(UUID)) : (out << "<null>"));
   out << ")";
 }
 
@@ -2183,9 +2295,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast36;
-          xfer += iprot->readI32(ecast36);
-          this->type = (Type::type)ecast36;
+          int32_t ecast38;
+          xfer += iprot->readI32(ecast38);
+          this->type = (Type::type)ecast38;
           this->__isset.type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2201,9 +2313,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast37;
-          xfer += iprot->readI32(ecast37);
-          this->repetition_type = (FieldRepetitionType::type)ecast37;
+          int32_t ecast39;
+          xfer += iprot->readI32(ecast39);
+          this->repetition_type = (FieldRepetitionType::type)ecast39;
           this->__isset.repetition_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2227,9 +2339,9 @@ uint32_t SchemaElement::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 6:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast38;
-          xfer += iprot->readI32(ecast38);
-          this->converted_type = (ConvertedType::type)ecast38;
+          int32_t ecast40;
+          xfer += iprot->readI32(ecast40);
+          this->converted_type = (ConvertedType::type)ecast40;
           this->__isset.converted_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2355,31 +2467,31 @@ void swap(SchemaElement &a, SchemaElement &b) {
   swap(a.__isset, b.__isset);
 }
 
-SchemaElement::SchemaElement(const SchemaElement& other39) {
-  type = other39.type;
-  type_length = other39.type_length;
-  repetition_type = other39.repetition_type;
-  name = other39.name;
-  num_children = other39.num_children;
-  converted_type = other39.converted_type;
-  scale = other39.scale;
-  precision = other39.precision;
-  field_id = other39.field_id;
-  logicalType = other39.logicalType;
-  __isset = other39.__isset;
-}
-SchemaElement& SchemaElement::operator=(const SchemaElement& other40) {
-  type = other40.type;
-  type_length = other40.type_length;
-  repetition_type = other40.repetition_type;
-  name = other40.name;
-  num_children = other40.num_children;
-  converted_type = other40.converted_type;
-  scale = other40.scale;
-  precision = other40.precision;
-  field_id = other40.field_id;
-  logicalType = other40.logicalType;
-  __isset = other40.__isset;
+SchemaElement::SchemaElement(const SchemaElement& other41) {
+  type = other41.type;
+  type_length = other41.type_length;
+  repetition_type = other41.repetition_type;
+  name = other41.name;
+  num_children = other41.num_children;
+  converted_type = other41.converted_type;
+  scale = other41.scale;
+  precision = other41.precision;
+  field_id = other41.field_id;
+  logicalType = other41.logicalType;
+  __isset = other41.__isset;
+}
+SchemaElement& SchemaElement::operator=(const SchemaElement& other42) {
+  type = other42.type;
+  type_length = other42.type_length;
+  repetition_type = other42.repetition_type;
+  name = other42.name;
+  num_children = other42.num_children;
+  converted_type = other42.converted_type;
+  scale = other42.scale;
+  precision = other42.precision;
+  field_id = other42.field_id;
+  logicalType = other42.logicalType;
+  __isset = other42.__isset;
   return *this;
 }
 void SchemaElement::printTo(std::ostream& out) const {
@@ -2465,9 +2577,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast41;
-          xfer += iprot->readI32(ecast41);
-          this->encoding = (Encoding::type)ecast41;
+          int32_t ecast43;
+          xfer += iprot->readI32(ecast43);
+          this->encoding = (Encoding::type)ecast43;
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2475,9 +2587,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 3:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast42;
-          xfer += iprot->readI32(ecast42);
-          this->definition_level_encoding = (Encoding::type)ecast42;
+          int32_t ecast44;
+          xfer += iprot->readI32(ecast44);
+          this->definition_level_encoding = (Encoding::type)ecast44;
           isset_definition_level_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2485,9 +2597,9 @@ uint32_t DataPageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast43;
-          xfer += iprot->readI32(ecast43);
-          this->repetition_level_encoding = (Encoding::type)ecast43;
+          int32_t ecast45;
+          xfer += iprot->readI32(ecast45);
+          this->repetition_level_encoding = (Encoding::type)ecast45;
           isset_repetition_level_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2562,21 +2674,21 @@ void swap(DataPageHeader &a, DataPageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-DataPageHeader::DataPageHeader(const DataPageHeader& other44) {
-  num_values = other44.num_values;
-  encoding = other44.encoding;
-  definition_level_encoding = other44.definition_level_encoding;
-  repetition_level_encoding = other44.repetition_level_encoding;
-  statistics = other44.statistics;
-  __isset = other44.__isset;
-}
-DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other45) {
-  num_values = other45.num_values;
-  encoding = other45.encoding;
-  definition_level_encoding = other45.definition_level_encoding;
-  repetition_level_encoding = other45.repetition_level_encoding;
-  statistics = other45.statistics;
-  __isset = other45.__isset;
+DataPageHeader::DataPageHeader(const DataPageHeader& other46) {
+  num_values = other46.num_values;
+  encoding = other46.encoding;
+  definition_level_encoding = other46.definition_level_encoding;
+  repetition_level_encoding = other46.repetition_level_encoding;
+  statistics = other46.statistics;
+  __isset = other46.__isset;
+}
+DataPageHeader& DataPageHeader::operator=(const DataPageHeader& other47) {
+  num_values = other47.num_values;
+  encoding = other47.encoding;
+  definition_level_encoding = other47.definition_level_encoding;
+  repetition_level_encoding = other47.repetition_level_encoding;
+  statistics = other47.statistics;
+  __isset = other47.__isset;
   return *this;
 }
 void DataPageHeader::printTo(std::ostream& out) const {
@@ -2645,11 +2757,11 @@ void swap(IndexPageHeader &a, IndexPageHeader &b) {
   (void) b;
 }
 
-IndexPageHeader::IndexPageHeader(const IndexPageHeader& other46) {
-  (void) other46;
+IndexPageHeader::IndexPageHeader(const IndexPageHeader& other48) {
+  (void) other48;
 }
-IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other47) {
-  (void) other47;
+IndexPageHeader& IndexPageHeader::operator=(const IndexPageHeader& other49) {
+  (void) other49;
   return *this;
 }
 void IndexPageHeader::printTo(std::ostream& out) const {
@@ -2715,9 +2827,9 @@ uint32_t DictionaryPageHeader::read(::apache::thrift::protocol::TProtocol* iprot
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast48;
-          xfer += iprot->readI32(ecast48);
-          this->encoding = (Encoding::type)ecast48;
+          int32_t ecast50;
+          xfer += iprot->readI32(ecast50);
+          this->encoding = (Encoding::type)ecast50;
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -2778,17 +2890,17 @@ void swap(DictionaryPageHeader &a, DictionaryPageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other49) {
-  num_values = other49.num_values;
-  encoding = other49.encoding;
-  is_sorted = other49.is_sorted;
-  __isset = other49.__isset;
+DictionaryPageHeader::DictionaryPageHeader(const DictionaryPageHeader& other51) {
+  num_values = other51.num_values;
+  encoding = other51.encoding;
+  is_sorted = other51.is_sorted;
+  __isset = other51.__isset;
 }
-DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other50) {
-  num_values = other50.num_values;
-  encoding = other50.encoding;
-  is_sorted = other50.is_sorted;
-  __isset = other50.__isset;
+DictionaryPageHeader& DictionaryPageHeader::operator=(const DictionaryPageHeader& other52) {
+  num_values = other52.num_values;
+  encoding = other52.encoding;
+  is_sorted = other52.is_sorted;
+  __isset = other52.__isset;
   return *this;
 }
 void DictionaryPageHeader::printTo(std::ostream& out) const {
@@ -2898,9 +3010,9 @@ uint32_t DataPageHeaderV2::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast51;
-          xfer += iprot->readI32(ecast51);
-          this->encoding = (Encoding::type)ecast51;
+          int32_t ecast53;
+          xfer += iprot->readI32(ecast53);
+          this->encoding = (Encoding::type)ecast53;
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3019,27 +3131,27 @@ void swap(DataPageHeaderV2 &a, DataPageHeaderV2 &b) {
   swap(a.__isset, b.__isset);
 }
 
-DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other52) {
-  num_values = other52.num_values;
-  num_nulls = other52.num_nulls;
-  num_rows = other52.num_rows;
-  encoding = other52.encoding;
-  definition_levels_byte_length = other52.definition_levels_byte_length;
-  repetition_levels_byte_length = other52.repetition_levels_byte_length;
-  is_compressed = other52.is_compressed;
-  statistics = other52.statistics;
-  __isset = other52.__isset;
-}
-DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other53) {
-  num_values = other53.num_values;
-  num_nulls = other53.num_nulls;
-  num_rows = other53.num_rows;
-  encoding = other53.encoding;
-  definition_levels_byte_length = other53.definition_levels_byte_length;
-  repetition_levels_byte_length = other53.repetition_levels_byte_length;
-  is_compressed = other53.is_compressed;
-  statistics = other53.statistics;
-  __isset = other53.__isset;
+DataPageHeaderV2::DataPageHeaderV2(const DataPageHeaderV2& other54) {
+  num_values = other54.num_values;
+  num_nulls = other54.num_nulls;
+  num_rows = other54.num_rows;
+  encoding = other54.encoding;
+  definition_levels_byte_length = other54.definition_levels_byte_length;
+  repetition_levels_byte_length = other54.repetition_levels_byte_length;
+  is_compressed = other54.is_compressed;
+  statistics = other54.statistics;
+  __isset = other54.__isset;
+}
+DataPageHeaderV2& DataPageHeaderV2::operator=(const DataPageHeaderV2& other55) {
+  num_values = other55.num_values;
+  num_nulls = other55.num_nulls;
+  num_rows = other55.num_rows;
+  encoding = other55.encoding;
+  definition_levels_byte_length = other55.definition_levels_byte_length;
+  repetition_levels_byte_length = other55.repetition_levels_byte_length;
+  is_compressed = other55.is_compressed;
+  statistics = other55.statistics;
+  __isset = other55.__isset;
   return *this;
 }
 void DataPageHeaderV2::printTo(std::ostream& out) const {
@@ -3130,9 +3242,9 @@ uint32_t PageHeader::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast54;
-          xfer += iprot->readI32(ecast54);
-          this->type = (PageType::type)ecast54;
+          int32_t ecast56;
+          xfer += iprot->readI32(ecast56);
+          this->type = (PageType::type)ecast56;
           isset_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3272,27 +3384,27 @@ void swap(PageHeader &a, PageHeader &b) {
   swap(a.__isset, b.__isset);
 }
 
-PageHeader::PageHeader(const PageHeader& other55) {
-  type = other55.type;
-  uncompressed_page_size = other55.uncompressed_page_size;
-  compressed_page_size = other55.compressed_page_size;
-  crc = other55.crc;
-  data_page_header = other55.data_page_header;
-  index_page_header = other55.index_page_header;
-  dictionary_page_header = other55.dictionary_page_header;
-  data_page_header_v2 = other55.data_page_header_v2;
-  __isset = other55.__isset;
+PageHeader::PageHeader(const PageHeader& other57) {
+  type = other57.type;
+  uncompressed_page_size = other57.uncompressed_page_size;
+  compressed_page_size = other57.compressed_page_size;
+  crc = other57.crc;
+  data_page_header = other57.data_page_header;
+  index_page_header = other57.index_page_header;
+  dictionary_page_header = other57.dictionary_page_header;
+  data_page_header_v2 = other57.data_page_header_v2;
+  __isset = other57.__isset;
 }
-PageHeader& PageHeader::operator=(const PageHeader& other56) {
-  type = other56.type;
-  uncompressed_page_size = other56.uncompressed_page_size;
-  compressed_page_size = other56.compressed_page_size;
-  crc = other56.crc;
-  data_page_header = other56.data_page_header;
-  index_page_header = other56.index_page_header;
-  dictionary_page_header = other56.dictionary_page_header;
-  data_page_header_v2 = other56.data_page_header_v2;
-  __isset = other56.__isset;
+PageHeader& PageHeader::operator=(const PageHeader& other58) {
+  type = other58.type;
+  uncompressed_page_size = other58.uncompressed_page_size;
+  compressed_page_size = other58.compressed_page_size;
+  crc = other58.crc;
+  data_page_header = other58.data_page_header;
+  index_page_header = other58.index_page_header;
+  dictionary_page_header = other58.dictionary_page_header;
+  data_page_header_v2 = other58.data_page_header_v2;
+  __isset = other58.__isset;
   return *this;
 }
 void PageHeader::printTo(std::ostream& out) const {
@@ -3407,15 +3519,15 @@ void swap(KeyValue &a, KeyValue &b) {
   swap(a.__isset, b.__isset);
 }
 
-KeyValue::KeyValue(const KeyValue& other57) {
-  key = other57.key;
-  value = other57.value;
-  __isset = other57.__isset;
+KeyValue::KeyValue(const KeyValue& other59) {
+  key = other59.key;
+  value = other59.value;
+  __isset = other59.__isset;
 }
-KeyValue& KeyValue::operator=(const KeyValue& other58) {
-  key = other58.key;
-  value = other58.value;
-  __isset = other58.__isset;
+KeyValue& KeyValue::operator=(const KeyValue& other60) {
+  key = other60.key;
+  value = other60.value;
+  __isset = other60.__isset;
   return *this;
 }
 void KeyValue::printTo(std::ostream& out) const {
@@ -3544,15 +3656,15 @@ void swap(SortingColumn &a, SortingColumn &b) {
   swap(a.nulls_first, b.nulls_first);
 }
 
-SortingColumn::SortingColumn(const SortingColumn& other59) {
-  column_idx = other59.column_idx;
-  descending = other59.descending;
-  nulls_first = other59.nulls_first;
+SortingColumn::SortingColumn(const SortingColumn& other61) {
+  column_idx = other61.column_idx;
+  descending = other61.descending;
+  nulls_first = other61.nulls_first;
 }
-SortingColumn& SortingColumn::operator=(const SortingColumn& other60) {
-  column_idx = other60.column_idx;
-  descending = other60.descending;
-  nulls_first = other60.nulls_first;
+SortingColumn& SortingColumn::operator=(const SortingColumn& other62) {
+  column_idx = other62.column_idx;
+  descending = other62.descending;
+  nulls_first = other62.nulls_first;
   return *this;
 }
 void SortingColumn::printTo(std::ostream& out) const {
@@ -3613,9 +3725,9 @@ uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast61;
-          xfer += iprot->readI32(ecast61);
-          this->page_type = (PageType::type)ecast61;
+          int32_t ecast63;
+          xfer += iprot->readI32(ecast63);
+          this->page_type = (PageType::type)ecast63;
           isset_page_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3623,9 +3735,9 @@ uint32_t PageEncodingStats::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast62;
-          xfer += iprot->readI32(ecast62);
-          this->encoding = (Encoding::type)ecast62;
+          int32_t ecast64;
+          xfer += iprot->readI32(ecast64);
+          this->encoding = (Encoding::type)ecast64;
           isset_encoding = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3686,15 +3798,15 @@ void swap(PageEncodingStats &a, PageEncodingStats &b) {
   swap(a.count, b.count);
 }
 
-PageEncodingStats::PageEncodingStats(const PageEncodingStats& other63) {
-  page_type = other63.page_type;
-  encoding = other63.encoding;
-  count = other63.count;
+PageEncodingStats::PageEncodingStats(const PageEncodingStats& other65) {
+  page_type = other65.page_type;
+  encoding = other65.encoding;
+  count = other65.count;
 }
-PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other64) {
-  page_type = other64.page_type;
-  encoding = other64.encoding;
-  count = other64.count;
+PageEncodingStats& PageEncodingStats::operator=(const PageEncodingStats& other66) {
+  page_type = other66.page_type;
+  encoding = other66.encoding;
+  count = other66.count;
   return *this;
 }
 void PageEncodingStats::printTo(std::ostream& out) const {
@@ -3805,9 +3917,9 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast65;
-          xfer += iprot->readI32(ecast65);
-          this->type = (Type::type)ecast65;
+          int32_t ecast67;
+          xfer += iprot->readI32(ecast67);
+          this->type = (Type::type)ecast67;
           isset_type = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3817,16 +3929,16 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->encodings.clear();
-            uint32_t _size66;
-            ::apache::thrift::protocol::TType _etype69;
-            xfer += iprot->readListBegin(_etype69, _size66);
-            this->encodings.resize(_size66);
-            uint32_t _i70;
-            for (_i70 = 0; _i70 < _size66; ++_i70)
+            uint32_t _size68;
+            ::apache::thrift::protocol::TType _etype71;
+            xfer += iprot->readListBegin(_etype71, _size68);
+            this->encodings.resize(_size68);
+            uint32_t _i72;
+            for (_i72 = 0; _i72 < _size68; ++_i72)
             {
-              int32_t ecast71;
-              xfer += iprot->readI32(ecast71);
-              this->encodings[_i70] = (Encoding::type)ecast71;
+              int32_t ecast73;
+              xfer += iprot->readI32(ecast73);
+              this->encodings[_i72] = (Encoding::type)ecast73;
             }
             xfer += iprot->readListEnd();
           }
@@ -3839,14 +3951,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->path_in_schema.clear();
-            uint32_t _size72;
-            ::apache::thrift::protocol::TType _etype75;
-            xfer += iprot->readListBegin(_etype75, _size72);
-            this->path_in_schema.resize(_size72);
-            uint32_t _i76;
-            for (_i76 = 0; _i76 < _size72; ++_i76)
+            uint32_t _size74;
+            ::apache::thrift::protocol::TType _etype77;
+            xfer += iprot->readListBegin(_etype77, _size74);
+            this->path_in_schema.resize(_size74);
+            uint32_t _i78;
+            for (_i78 = 0; _i78 < _size74; ++_i78)
             {
-              xfer += iprot->readString(this->path_in_schema[_i76]);
+              xfer += iprot->readString(this->path_in_schema[_i78]);
             }
             xfer += iprot->readListEnd();
           }
@@ -3857,9 +3969,9 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast77;
-          xfer += iprot->readI32(ecast77);
-          this->codec = (CompressionCodec::type)ecast77;
+          int32_t ecast79;
+          xfer += iprot->readI32(ecast79);
+          this->codec = (CompressionCodec::type)ecast79;
           isset_codec = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -3893,14 +4005,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->key_value_metadata.clear();
-            uint32_t _size78;
-            ::apache::thrift::protocol::TType _etype81;
-            xfer += iprot->readListBegin(_etype81, _size78);
-            this->key_value_metadata.resize(_size78);
-            uint32_t _i82;
-            for (_i82 = 0; _i82 < _size78; ++_i82)
+            uint32_t _size80;
+            ::apache::thrift::protocol::TType _etype83;
+            xfer += iprot->readListBegin(_etype83, _size80);
+            this->key_value_metadata.resize(_size80);
+            uint32_t _i84;
+            for (_i84 = 0; _i84 < _size80; ++_i84)
             {
-              xfer += this->key_value_metadata[_i82].read(iprot);
+              xfer += this->key_value_metadata[_i84].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -3945,14 +4057,14 @@ uint32_t ColumnMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->encoding_stats.clear();
-            uint32_t _size83;
-            ::apache::thrift::protocol::TType _etype86;
-            xfer += iprot->readListBegin(_etype86, _size83);
-            this->encoding_stats.resize(_size83);
-            uint32_t _i87;
-            for (_i87 = 0; _i87 < _size83; ++_i87)
+            uint32_t _size85;
+            ::apache::thrift::protocol::TType _etype88;
+            xfer += iprot->readListBegin(_etype88, _size85);
+            this->encoding_stats.resize(_size85);
+            uint32_t _i89;
+            for (_i89 = 0; _i89 < _size85; ++_i89)
             {
-              xfer += this->encoding_stats[_i87].read(iprot);
+              xfer += this->encoding_stats[_i89].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -4001,10 +4113,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldBegin("encodings", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->encodings.size()));
-    std::vector<Encoding::type> ::const_iterator _iter88;
-    for (_iter88 = this->encodings.begin(); _iter88 != this->encodings.end(); ++_iter88)
+    std::vector<Encoding::type> ::const_iterator _iter90;
+    for (_iter90 = this->encodings.begin(); _iter90 != this->encodings.end(); ++_iter90)
     {
-      xfer += oprot->writeI32((int32_t)(*_iter88));
+      xfer += oprot->writeI32((int32_t)(*_iter90));
     }
     xfer += oprot->writeListEnd();
   }
@@ -4013,10 +4125,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
   xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter89;
-    for (_iter89 = this->path_in_schema.begin(); _iter89 != this->path_in_schema.end(); ++_iter89)
+    std::vector<std::string> ::const_iterator _iter91;
+    for (_iter91 = this->path_in_schema.begin(); _iter91 != this->path_in_schema.end(); ++_iter91)
     {
-      xfer += oprot->writeString((*_iter89));
+      xfer += oprot->writeString((*_iter91));
     }
     xfer += oprot->writeListEnd();
   }
@@ -4042,10 +4154,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 8);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter90;
-      for (_iter90 = this->key_value_metadata.begin(); _iter90 != this->key_value_metadata.end(); ++_iter90)
+      std::vector<KeyValue> ::const_iterator _iter92;
+      for (_iter92 = this->key_value_metadata.begin(); _iter92 != this->key_value_metadata.end(); ++_iter92)
       {
-        xfer += (*_iter90).write(oprot);
+        xfer += (*_iter92).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -4074,10 +4186,10 @@ uint32_t ColumnMetaData::write(::apache::thrift::protocol::TProtocol* oprot) con
     xfer += oprot->writeFieldBegin("encoding_stats", ::apache::thrift::protocol::T_LIST, 13);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->encoding_stats.size()));
-      std::vector<PageEncodingStats> ::const_iterator _iter91;
-      for (_iter91 = this->encoding_stats.begin(); _iter91 != this->encoding_stats.end(); ++_iter91)
+      std::vector<PageEncodingStats> ::const_iterator _iter93;
+      for (_iter93 = this->encoding_stats.begin(); _iter93 != this->encoding_stats.end(); ++_iter93)
       {
-        xfer += (*_iter91).write(oprot);
+        xfer += (*_iter93).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -4106,37 +4218,37 @@ void swap(ColumnMetaData &a, ColumnMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnMetaData::ColumnMetaData(const ColumnMetaData& other92) {
-  type = other92.type;
-  encodings = other92.encodings;
-  path_in_schema = other92.path_in_schema;
-  codec = other92.codec;
-  num_values = other92.num_values;
-  total_uncompressed_size = other92.total_uncompressed_size;
-  total_compressed_size = other92.total_compressed_size;
-  key_value_metadata = other92.key_value_metadata;
-  data_page_offset = other92.data_page_offset;
-  index_page_offset = other92.index_page_offset;
-  dictionary_page_offset = other92.dictionary_page_offset;
-  statistics = other92.statistics;
-  encoding_stats = other92.encoding_stats;
-  __isset = other92.__isset;
-}
-ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other93) {
-  type = other93.type;
-  encodings = other93.encodings;
-  path_in_schema = other93.path_in_schema;
-  codec = other93.codec;
-  num_values = other93.num_values;
-  total_uncompressed_size = other93.total_uncompressed_size;
-  total_compressed_size = other93.total_compressed_size;
-  key_value_metadata = other93.key_value_metadata;
-  data_page_offset = other93.data_page_offset;
-  index_page_offset = other93.index_page_offset;
-  dictionary_page_offset = other93.dictionary_page_offset;
-  statistics = other93.statistics;
-  encoding_stats = other93.encoding_stats;
-  __isset = other93.__isset;
+ColumnMetaData::ColumnMetaData(const ColumnMetaData& other94) {
+  type = other94.type;
+  encodings = other94.encodings;
+  path_in_schema = other94.path_in_schema;
+  codec = other94.codec;
+  num_values = other94.num_values;
+  total_uncompressed_size = other94.total_uncompressed_size;
+  total_compressed_size = other94.total_compressed_size;
+  key_value_metadata = other94.key_value_metadata;
+  data_page_offset = other94.data_page_offset;
+  index_page_offset = other94.index_page_offset;
+  dictionary_page_offset = other94.dictionary_page_offset;
+  statistics = other94.statistics;
+  encoding_stats = other94.encoding_stats;
+  __isset = other94.__isset;
+}
+ColumnMetaData& ColumnMetaData::operator=(const ColumnMetaData& other95) {
+  type = other95.type;
+  encodings = other95.encodings;
+  path_in_schema = other95.path_in_schema;
+  codec = other95.codec;
+  num_values = other95.num_values;
+  total_uncompressed_size = other95.total_uncompressed_size;
+  total_compressed_size = other95.total_compressed_size;
+  key_value_metadata = other95.key_value_metadata;
+  data_page_offset = other95.data_page_offset;
+  index_page_offset = other95.index_page_offset;
+  dictionary_page_offset = other95.dictionary_page_offset;
+  statistics = other95.statistics;
+  encoding_stats = other95.encoding_stats;
+  __isset = other95.__isset;
   return *this;
 }
 void ColumnMetaData::printTo(std::ostream& out) const {
@@ -4213,11 +4325,11 @@ void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b) {
   (void) b;
 }
 
-EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other94) {
-  (void) other94;
+EncryptionWithFooterKey::EncryptionWithFooterKey(const EncryptionWithFooterKey& other96) {
+  (void) other96;
 }
-EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other95) {
-  (void) other95;
+EncryptionWithFooterKey& EncryptionWithFooterKey::operator=(const EncryptionWithFooterKey& other97) {
+  (void) other97;
   return *this;
 }
 void EncryptionWithFooterKey::printTo(std::ostream& out) const {
@@ -4235,9 +4347,9 @@ void EncryptionWithColumnKey::__set_path_in_schema(const std::vector<std::string
   this->path_in_schema = val;
 }
 
-void EncryptionWithColumnKey::__set_column_key_metadata(const std::string& val) {
-  this->column_key_metadata = val;
-__isset.column_key_metadata = true;
+void EncryptionWithColumnKey::__set_key_metadata(const std::string& val) {
+  this->key_metadata = val;
+__isset.key_metadata = true;
 }
 std::ostream& operator<<(std::ostream& out, const EncryptionWithColumnKey& obj)
 {
@@ -4272,14 +4384,14 @@ uint32_t EncryptionWithColumnKey::read(::apache::thrift::protocol::TProtocol* ip
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->path_in_schema.clear();
-            uint32_t _size96;
-            ::apache::thrift::protocol::TType _etype99;
-            xfer += iprot->readListBegin(_etype99, _size96);
-            this->path_in_schema.resize(_size96);
-            uint32_t _i100;
-            for (_i100 = 0; _i100 < _size96; ++_i100)
+            uint32_t _size98;
+            ::apache::thrift::protocol::TType _etype101;
+            xfer += iprot->readListBegin(_etype101, _size98);
+            this->path_in_schema.resize(_size98);
+            uint32_t _i102;
+            for (_i102 = 0; _i102 < _size98; ++_i102)
             {
-              xfer += iprot->readString(this->path_in_schema[_i100]);
+              xfer += iprot->readString(this->path_in_schema[_i102]);
             }
             xfer += iprot->readListEnd();
           }
@@ -4290,8 +4402,8 @@ uint32_t EncryptionWithColumnKey::read(::apache::thrift::protocol::TProtocol* ip
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->column_key_metadata);
-          this->__isset.column_key_metadata = true;
+          xfer += iprot->readBinary(this->key_metadata);
+          this->__isset.key_metadata = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -4318,18 +4430,18 @@ uint32_t EncryptionWithColumnKey::write(::apache::thrift::protocol::TProtocol* o
   xfer += oprot->writeFieldBegin("path_in_schema", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter101;
-    for (_iter101 = this->path_in_schema.begin(); _iter101 != this->path_in_schema.end(); ++_iter101)
+    std::vector<std::string> ::const_iterator _iter103;
+    for (_iter103 = this->path_in_schema.begin(); _iter103 != this->path_in_schema.end(); ++_iter103)
     {
-      xfer += oprot->writeString((*_iter101));
+      xfer += oprot->writeString((*_iter103));
     }
     xfer += oprot->writeListEnd();
   }
   xfer += oprot->writeFieldEnd();
 
-  if (this->__isset.column_key_metadata) {
-    xfer += oprot->writeFieldBegin("column_key_metadata", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->column_key_metadata);
+  if (this->__isset.key_metadata) {
+    xfer += oprot->writeFieldBegin("key_metadata", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->key_metadata);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -4340,26 +4452,26 @@ uint32_t EncryptionWithColumnKey::write(::apache::thrift::protocol::TProtocol* o
 void swap(EncryptionWithColumnKey &a, EncryptionWithColumnKey &b) {
   using ::std::swap;
   swap(a.path_in_schema, b.path_in_schema);
-  swap(a.column_key_metadata, b.column_key_metadata);
+  swap(a.key_metadata, b.key_metadata);
   swap(a.__isset, b.__isset);
 }
 
-EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other102) {
-  path_in_schema = other102.path_in_schema;
-  column_key_metadata = other102.column_key_metadata;
-  __isset = other102.__isset;
+EncryptionWithColumnKey::EncryptionWithColumnKey(const EncryptionWithColumnKey& other104) {
+  path_in_schema = other104.path_in_schema;
+  key_metadata = other104.key_metadata;
+  __isset = other104.__isset;
 }
-EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other103) {
-  path_in_schema = other103.path_in_schema;
-  column_key_metadata = other103.column_key_metadata;
-  __isset = other103.__isset;
+EncryptionWithColumnKey& EncryptionWithColumnKey::operator=(const EncryptionWithColumnKey& other105) {
+  path_in_schema = other105.path_in_schema;
+  key_metadata = other105.key_metadata;
+  __isset = other105.__isset;
   return *this;
 }
 void EncryptionWithColumnKey::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
   out << "EncryptionWithColumnKey(";
   out << "path_in_schema=" << to_string(path_in_schema);
-  out << ", " << "column_key_metadata="; (__isset.column_key_metadata ? (out << to_string(column_key_metadata)) : (out << "<null>"));
+  out << ", " << "key_metadata="; (__isset.key_metadata ? (out << to_string(key_metadata)) : (out << "<null>"));
   out << ")";
 }
 
@@ -4460,15 +4572,15 @@ void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other104) {
-  ENCRYPTION_WITH_FOOTER_KEY = other104.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other104.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other104.__isset;
+ColumnCryptoMetaData::ColumnCryptoMetaData(const ColumnCryptoMetaData& other106) {
+  ENCRYPTION_WITH_FOOTER_KEY = other106.ENCRYPTION_WITH_FOOTER_KEY;
+  ENCRYPTION_WITH_COLUMN_KEY = other106.ENCRYPTION_WITH_COLUMN_KEY;
+  __isset = other106.__isset;
 }
-ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other105) {
-  ENCRYPTION_WITH_FOOTER_KEY = other105.ENCRYPTION_WITH_FOOTER_KEY;
-  ENCRYPTION_WITH_COLUMN_KEY = other105.ENCRYPTION_WITH_COLUMN_KEY;
-  __isset = other105.__isset;
+ColumnCryptoMetaData& ColumnCryptoMetaData::operator=(const ColumnCryptoMetaData& other107) {
+  ENCRYPTION_WITH_FOOTER_KEY = other107.ENCRYPTION_WITH_FOOTER_KEY;
+  ENCRYPTION_WITH_COLUMN_KEY = other107.ENCRYPTION_WITH_COLUMN_KEY;
+  __isset = other107.__isset;
   return *this;
 }
 void ColumnCryptoMetaData::printTo(std::ostream& out) const {
@@ -4518,9 +4630,14 @@ void ColumnChunk::__set_column_index_length(const int32_t val) {
 __isset.column_index_length = true;
 }
 
-void ColumnChunk::__set_crypto_meta_data(const ColumnCryptoMetaData& val) {
-  this->crypto_meta_data = val;
-__isset.crypto_meta_data = true;
+void ColumnChunk::__set_crypto_metadata(const ColumnCryptoMetaData& val) {
+  this->crypto_metadata = val;
+__isset.crypto_metadata = true;
+}
+
+void ColumnChunk::__set_encrypted_column_metadata(const std::string& val) {
+  this->encrypted_column_metadata = val;
+__isset.encrypted_column_metadata = true;
 }
 std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj)
 {
@@ -4609,8 +4726,16 @@ uint32_t ColumnChunk::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 8:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->crypto_meta_data.read(iprot);
-          this->__isset.crypto_meta_data = true;
+          xfer += this->crypto_metadata.read(iprot);
+          this->__isset.crypto_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->encrypted_column_metadata);
+          this->__isset.encrypted_column_metadata = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -4668,9 +4793,14 @@ uint32_t ColumnChunk::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeI32(this->column_index_length);
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.crypto_meta_data) {
-    xfer += oprot->writeFieldBegin("crypto_meta_data", ::apache::thrift::protocol::T_STRUCT, 8);
-    xfer += this->crypto_meta_data.write(oprot);
+  if (this->__isset.crypto_metadata) {
+    xfer += oprot->writeFieldBegin("crypto_metadata", ::apache::thrift::protocol::T_STRUCT, 8);
+    xfer += this->crypto_metadata.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.encrypted_column_metadata) {
+    xfer += oprot->writeFieldBegin("encrypted_column_metadata", ::apache::thrift::protocol::T_STRING, 9);
+    xfer += oprot->writeBinary(this->encrypted_column_metadata);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -4687,31 +4817,34 @@ void swap(ColumnChunk &a, ColumnChunk &b) {
   swap(a.offset_index_length, b.offset_index_length);
   swap(a.column_index_offset, b.column_index_offset);
   swap(a.column_index_length, b.column_index_length);
-  swap(a.crypto_meta_data, b.crypto_meta_data);
+  swap(a.crypto_metadata, b.crypto_metadata);
+  swap(a.encrypted_column_metadata, b.encrypted_column_metadata);
   swap(a.__isset, b.__isset);
 }
 
-ColumnChunk::ColumnChunk(const ColumnChunk& other106) {
-  file_path = other106.file_path;
-  file_offset = other106.file_offset;
-  meta_data = other106.meta_data;
-  offset_index_offset = other106.offset_index_offset;
-  offset_index_length = other106.offset_index_length;
-  column_index_offset = other106.column_index_offset;
-  column_index_length = other106.column_index_length;
-  crypto_meta_data = other106.crypto_meta_data;
-  __isset = other106.__isset;
-}
-ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other107) {
-  file_path = other107.file_path;
-  file_offset = other107.file_offset;
-  meta_data = other107.meta_data;
-  offset_index_offset = other107.offset_index_offset;
-  offset_index_length = other107.offset_index_length;
-  column_index_offset = other107.column_index_offset;
-  column_index_length = other107.column_index_length;
-  crypto_meta_data = other107.crypto_meta_data;
-  __isset = other107.__isset;
+ColumnChunk::ColumnChunk(const ColumnChunk& other108) {
+  file_path = other108.file_path;
+  file_offset = other108.file_offset;
+  meta_data = other108.meta_data;
+  offset_index_offset = other108.offset_index_offset;
+  offset_index_length = other108.offset_index_length;
+  column_index_offset = other108.column_index_offset;
+  column_index_length = other108.column_index_length;
+  crypto_metadata = other108.crypto_metadata;
+  encrypted_column_metadata = other108.encrypted_column_metadata;
+  __isset = other108.__isset;
+}
+ColumnChunk& ColumnChunk::operator=(const ColumnChunk& other109) {
+  file_path = other109.file_path;
+  file_offset = other109.file_offset;
+  meta_data = other109.meta_data;
+  offset_index_offset = other109.offset_index_offset;
+  offset_index_length = other109.offset_index_length;
+  column_index_offset = other109.column_index_offset;
+  column_index_length = other109.column_index_length;
+  crypto_metadata = other109.crypto_metadata;
+  encrypted_column_metadata = other109.encrypted_column_metadata;
+  __isset = other109.__isset;
   return *this;
 }
 void ColumnChunk::printTo(std::ostream& out) const {
@@ -4724,7 +4857,8 @@ void ColumnChunk::printTo(std::ostream& out) const {
   out << ", " << "offset_index_length="; (__isset.offset_index_length ? (out << to_string(offset_index_length)) : (out << "<null>"));
   out << ", " << "column_index_offset="; (__isset.column_index_offset ? (out << to_string(column_index_offset)) : (out << "<null>"));
   out << ", " << "column_index_length="; (__isset.column_index_length ? (out << to_string(column_index_length)) : (out << "<null>"));
-  out << ", " << "crypto_meta_data="; (__isset.crypto_meta_data ? (out << to_string(crypto_meta_data)) : (out << "<null>"));
+  out << ", " << "crypto_metadata="; (__isset.crypto_metadata ? (out << to_string(crypto_metadata)) : (out << "<null>"));
+  out << ", " << "encrypted_column_metadata="; (__isset.encrypted_column_metadata ? (out << to_string(encrypted_column_metadata)) : (out << "<null>"));
   out << ")";
 }
 
@@ -4759,6 +4893,11 @@ void RowGroup::__set_total_compressed_size(const int64_t val) {
   this->total_compressed_size = val;
 __isset.total_compressed_size = true;
 }
+
+void RowGroup::__set_ordinal(const int16_t val) {
+  this->ordinal = val;
+__isset.ordinal = true;
+}
 std::ostream& operator<<(std::ostream& out, const RowGroup& obj)
 {
   obj.printTo(out);
@@ -4794,14 +4933,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->columns.clear();
-            uint32_t _size108;
-            ::apache::thrift::protocol::TType _etype111;
-            xfer += iprot->readListBegin(_etype111, _size108);
-            this->columns.resize(_size108);
-            uint32_t _i112;
-            for (_i112 = 0; _i112 < _size108; ++_i112)
+            uint32_t _size110;
+            ::apache::thrift::protocol::TType _etype113;
+            xfer += iprot->readListBegin(_etype113, _size110);
+            this->columns.resize(_size110);
+            uint32_t _i114;
+            for (_i114 = 0; _i114 < _size110; ++_i114)
             {
-              xfer += this->columns[_i112].read(iprot);
+              xfer += this->columns[_i114].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -4830,14 +4969,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->sorting_columns.clear();
-            uint32_t _size113;
-            ::apache::thrift::protocol::TType _etype116;
-            xfer += iprot->readListBegin(_etype116, _size113);
-            this->sorting_columns.resize(_size113);
-            uint32_t _i117;
-            for (_i117 = 0; _i117 < _size113; ++_i117)
+            uint32_t _size115;
+            ::apache::thrift::protocol::TType _etype118;
+            xfer += iprot->readListBegin(_etype118, _size115);
+            this->sorting_columns.resize(_size115);
+            uint32_t _i119;
+            for (_i119 = 0; _i119 < _size115; ++_i119)
             {
-              xfer += this->sorting_columns[_i117].read(iprot);
+              xfer += this->sorting_columns[_i119].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -4862,6 +5001,14 @@ uint32_t RowGroup::read(::apache::thrift::protocol::TProtocol* iprot) {
           xfer += iprot->skip(ftype);
         }
         break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_I16) {
+          xfer += iprot->readI16(this->ordinal);
+          this->__isset.ordinal = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
       default:
         xfer += iprot->skip(ftype);
         break;
@@ -4888,10 +5035,10 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
   xfer += oprot->writeFieldBegin("columns", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<ColumnChunk> ::const_iterator _iter118;
-    for (_iter118 = this->columns.begin(); _iter118 != this->columns.end(); ++_iter118)
+    std::vector<ColumnChunk> ::const_iterator _iter120;
+    for (_iter120 = this->columns.begin(); _iter120 != this->columns.end(); ++_iter120)
     {
-      xfer += (*_iter118).write(oprot);
+      xfer += (*_iter120).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -4909,10 +5056,10 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeFieldBegin("sorting_columns", ::apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sorting_columns.size()));
-      std::vector<SortingColumn> ::const_iterator _iter119;
-      for (_iter119 = this->sorting_columns.begin(); _iter119 != this->sorting_columns.end(); ++_iter119)
+      std::vector<SortingColumn> ::const_iterator _iter121;
+      for (_iter121 = this->sorting_columns.begin(); _iter121 != this->sorting_columns.end(); ++_iter121)
       {
-        xfer += (*_iter119).write(oprot);
+        xfer += (*_iter121).write(oprot);
       }
       xfer += oprot->writeListEnd();
     }
@@ -4928,6 +5075,11 @@ uint32_t RowGroup::write(::apache::thrift::protocol::TProtocol* oprot) const {
     xfer += oprot->writeI64(this->total_compressed_size);
     xfer += oprot->writeFieldEnd();
   }
+  if (this->__isset.ordinal) {
+    xfer += oprot->writeFieldBegin("ordinal", ::apache::thrift::protocol::T_I16, 7);
+    xfer += oprot->writeI16(this->ordinal);
+    xfer += oprot->writeFieldEnd();
+  }
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -4941,26 +5093,29 @@ void swap(RowGroup &a, RowGroup &b) {
   swap(a.sorting_columns, b.sorting_columns);
   swap(a.file_offset, b.file_offset);
   swap(a.total_compressed_size, b.total_compressed_size);
+  swap(a.ordinal, b.ordinal);
   swap(a.__isset, b.__isset);
 }
 
-RowGroup::RowGroup(const RowGroup& other120) {
-  columns = other120.columns;
-  total_byte_size = other120.total_byte_size;
-  num_rows = other120.num_rows;
-  sorting_columns = other120.sorting_columns;
-  file_offset = other120.file_offset;
-  total_compressed_size = other120.total_compressed_size;
-  __isset = other120.__isset;
-}
-RowGroup& RowGroup::operator=(const RowGroup& other121) {
-  columns = other121.columns;
-  total_byte_size = other121.total_byte_size;
-  num_rows = other121.num_rows;
-  sorting_columns = other121.sorting_columns;
-  file_offset = other121.file_offset;
-  total_compressed_size = other121.total_compressed_size;
-  __isset = other121.__isset;
+RowGroup::RowGroup(const RowGroup& other122) {
+  columns = other122.columns;
+  total_byte_size = other122.total_byte_size;
+  num_rows = other122.num_rows;
+  sorting_columns = other122.sorting_columns;
+  file_offset = other122.file_offset;
+  total_compressed_size = other122.total_compressed_size;
+  ordinal = other122.ordinal;
+  __isset = other122.__isset;
+}
+RowGroup& RowGroup::operator=(const RowGroup& other123) {
+  columns = other123.columns;
+  total_byte_size = other123.total_byte_size;
+  num_rows = other123.num_rows;
+  sorting_columns = other123.sorting_columns;
+  file_offset = other123.file_offset;
+  total_compressed_size = other123.total_compressed_size;
+  ordinal = other123.ordinal;
+  __isset = other123.__isset;
   return *this;
 }
 void RowGroup::printTo(std::ostream& out) const {
@@ -4972,6 +5127,7 @@ void RowGroup::printTo(std::ostream& out) const {
   out << ", " << "sorting_columns="; (__isset.sorting_columns ? (out << to_string(sorting_columns)) : (out << "<null>"));
   out << ", " << "file_offset="; (__isset.file_offset ? (out << to_string(file_offset)) : (out << "<null>"));
   out << ", " << "total_compressed_size="; (__isset.total_compressed_size ? (out << to_string(total_compressed_size)) : (out << "<null>"));
+  out << ", " << "ordinal="; (__isset.ordinal ? (out << to_string(ordinal)) : (out << "<null>"));
   out << ")";
 }
 
@@ -5030,11 +5186,11 @@ void swap(TypeDefinedOrder &a, TypeDefinedOrder &b) {
   (void) b;
 }
 
-TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other122) {
-  (void) other122;
+TypeDefinedOrder::TypeDefinedOrder(const TypeDefinedOrder& other124) {
+  (void) other124;
 }
-TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other123) {
-  (void) other123;
+TypeDefinedOrder& TypeDefinedOrder::operator=(const TypeDefinedOrder& other125) {
+  (void) other125;
   return *this;
 }
 void TypeDefinedOrder::printTo(std::ostream& out) const {
@@ -5121,13 +5277,13 @@ void swap(ColumnOrder &a, ColumnOrder &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnOrder::ColumnOrder(const ColumnOrder& other124) {
-  TYPE_ORDER = other124.TYPE_ORDER;
-  __isset = other124.__isset;
+ColumnOrder::ColumnOrder(const ColumnOrder& other126) {
+  TYPE_ORDER = other126.TYPE_ORDER;
+  __isset = other126.__isset;
 }
-ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other125) {
-  TYPE_ORDER = other125.TYPE_ORDER;
-  __isset = other125.__isset;
+ColumnOrder& ColumnOrder::operator=(const ColumnOrder& other127) {
+  TYPE_ORDER = other127.TYPE_ORDER;
+  __isset = other127.__isset;
   return *this;
 }
 void ColumnOrder::printTo(std::ostream& out) const {
@@ -5255,15 +5411,15 @@ void swap(PageLocation &a, PageLocation &b) {
   swap(a.first_row_index, b.first_row_index);
 }
 
-PageLocation::PageLocation(const PageLocation& other126) {
-  offset = other126.offset;
-  compressed_page_size = other126.compressed_page_size;
-  first_row_index = other126.first_row_index;
+PageLocation::PageLocation(const PageLocation& other128) {
+  offset = other128.offset;
+  compressed_page_size = other128.compressed_page_size;
+  first_row_index = other128.first_row_index;
 }
-PageLocation& PageLocation::operator=(const PageLocation& other127) {
-  offset = other127.offset;
-  compressed_page_size = other127.compressed_page_size;
-  first_row_index = other127.first_row_index;
+PageLocation& PageLocation::operator=(const PageLocation& other129) {
+  offset = other129.offset;
+  compressed_page_size = other129.compressed_page_size;
+  first_row_index = other129.first_row_index;
   return *this;
 }
 void PageLocation::printTo(std::ostream& out) const {
@@ -5316,14 +5472,14 @@ uint32_t OffsetIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->page_locations.clear();
-            uint32_t _size128;
-            ::apache::thrift::protocol::TType _etype131;
-            xfer += iprot->readListBegin(_etype131, _size128);
-            this->page_locations.resize(_size128);
-            uint32_t _i132;
-            for (_i132 = 0; _i132 < _size128; ++_i132)
+            uint32_t _size130;
+            ::apache::thrift::protocol::TType _etype133;
+            xfer += iprot->readListBegin(_etype133, _size130);
+            this->page_locations.resize(_size130);
+            uint32_t _i134;
+            for (_i134 = 0; _i134 < _size130; ++_i134)
             {
-              xfer += this->page_locations[_i132].read(iprot);
+              xfer += this->page_locations[_i134].read(iprot);
             }
             xfer += iprot->readListEnd();
           }
@@ -5354,10 +5510,10 @@ uint32_t OffsetIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("page_locations", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->page_locations.size()));
-    std::vector<PageLocation> ::const_iterator _iter133;
-    for (_iter133 = this->page_locations.begin(); _iter133 != this->page_locations.end(); ++_iter133)
+    std::vector<PageLocation> ::const_iterator _iter135;
+    for (_iter135 = this->page_locations.begin(); _iter135 != this->page_locations.end(); ++_iter135)
     {
-      xfer += (*_iter133).write(oprot);
+      xfer += (*_iter135).write(oprot);
     }
     xfer += oprot->writeListEnd();
   }
@@ -5373,11 +5529,11 @@ void swap(OffsetIndex &a, OffsetIndex &b) {
   swap(a.page_locations, b.page_locations);
 }
 
-OffsetIndex::OffsetIndex(const OffsetIndex& other134) {
-  page_locations = other134.page_locations;
+OffsetIndex::OffsetIndex(const OffsetIndex& other136) {
+  page_locations = other136.page_locations;
 }
-OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other135) {
-  page_locations = other135.page_locations;
+OffsetIndex& OffsetIndex::operator=(const OffsetIndex& other137) {
+  page_locations = other137.page_locations;
   return *this;
 }
 void OffsetIndex::printTo(std::ostream& out) const {
@@ -5448,14 +5604,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->null_pages.clear();
-            uint32_t _size136;
-            ::apache::thrift::protocol::TType _etype139;
-            xfer += iprot->readListBegin(_etype139, _size136);
-            this->null_pages.resize(_size136);
-            uint32_t _i140;
-            for (_i140 = 0; _i140 < _size136; ++_i140)
+            uint32_t _size138;
+            ::apache::thrift::protocol::TType _etype141;
+            xfer += iprot->readListBegin(_etype141, _size138);
+            this->null_pages.resize(_size138);
+            uint32_t _i142;
+            for (_i142 = 0; _i142 < _size138; ++_i142)
             {
-              xfer += iprot->readBool(this->null_pages[_i140]);
+              xfer += iprot->readBool(this->null_pages[_i142]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5468,14 +5624,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->min_values.clear();
-            uint32_t _size141;
-            ::apache::thrift::protocol::TType _etype144;
-            xfer += iprot->readListBegin(_etype144, _size141);
-            this->min_values.resize(_size141);
-            uint32_t _i145;
-            for (_i145 = 0; _i145 < _size141; ++_i145)
+            uint32_t _size143;
+            ::apache::thrift::protocol::TType _etype146;
+            xfer += iprot->readListBegin(_etype146, _size143);
+            this->min_values.resize(_size143);
+            uint32_t _i147;
+            for (_i147 = 0; _i147 < _size143; ++_i147)
             {
-              xfer += iprot->readBinary(this->min_values[_i145]);
+              xfer += iprot->readBinary(this->min_values[_i147]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5488,14 +5644,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->max_values.clear();
-            uint32_t _size146;
-            ::apache::thrift::protocol::TType _etype149;
-            xfer += iprot->readListBegin(_etype149, _size146);
-            this->max_values.resize(_size146);
-            uint32_t _i150;
-            for (_i150 = 0; _i150 < _size146; ++_i150)
+            uint32_t _size148;
+            ::apache::thrift::protocol::TType _etype151;
+            xfer += iprot->readListBegin(_etype151, _size148);
+            this->max_values.resize(_size148);
+            uint32_t _i152;
+            for (_i152 = 0; _i152 < _size148; ++_i152)
             {
-              xfer += iprot->readBinary(this->max_values[_i150]);
+              xfer += iprot->readBinary(this->max_values[_i152]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5506,9 +5662,9 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         break;
       case 4:
         if (ftype == ::apache::thrift::protocol::T_I32) {
-          int32_t ecast151;
-          xfer += iprot->readI32(ecast151);
-          this->boundary_order = (BoundaryOrder::type)ecast151;
+          int32_t ecast153;
+          xfer += iprot->readI32(ecast153);
+          this->boundary_order = (BoundaryOrder::type)ecast153;
           isset_boundary_order = true;
         } else {
           xfer += iprot->skip(ftype);
@@ -5518,14 +5674,14 @@ uint32_t ColumnIndex::read(::apache::thrift::protocol::TProtocol* iprot) {
         if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->null_counts.clear();
-            uint32_t _size152;
-            ::apache::thrift::protocol::TType _etype155;
-            xfer += iprot->readListBegin(_etype155, _size152);
-            this->null_counts.resize(_size152);
-            uint32_t _i156;
-            for (_i156 = 0; _i156 < _size152; ++_i156)
+            uint32_t _size154;
+            ::apache::thrift::protocol::TType _etype157;
+            xfer += iprot->readListBegin(_etype157, _size154);
+            this->null_counts.resize(_size154);
+            uint32_t _i158;
+            for (_i158 = 0; _i158 < _size154; ++_i158)
             {
-              xfer += iprot->readI64(this->null_counts[_i156]);
+              xfer += iprot->readI64(this->null_counts[_i158]);
             }
             xfer += iprot->readListEnd();
           }
@@ -5562,10 +5718,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("null_pages", ::apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->null_pages.size()));
-    std::vector<bool> ::const_iterator _iter157;
-    for (_iter157 = this->null_pages.begin(); _iter157 != this->null_pages.end(); ++_iter157)
+    std::vector<bool> ::const_iterator _iter159;
+    for (_iter159 = this->null_pages.begin(); _iter159 != this->null_pages.end(); ++_iter159)
     {
-      xfer += oprot->writeBool((*_iter157));
+      xfer += oprot->writeBool((*_iter159));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5574,10 +5730,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("min_values", ::apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->min_values.size()));
-    std::vector<std::string> ::const_iterator _iter158;
-    for (_iter158 = this->min_values.begin(); _iter158 != this->min_values.end(); ++_iter158)
+    std::vector<std::string> ::const_iterator _iter160;
+    for (_iter160 = this->min_values.begin(); _iter160 != this->min_values.end(); ++_iter160)
     {
-      xfer += oprot->writeBinary((*_iter158));
+      xfer += oprot->writeBinary((*_iter160));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5586,10 +5742,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
   xfer += oprot->writeFieldBegin("max_values", ::apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->max_values.size()));
-    std::vector<std::string> ::const_iterator _iter159;
-    for (_iter159 = this->max_values.begin(); _iter159 != this->max_values.end(); ++_iter159)
+    std::vector<std::string> ::const_iterator _iter161;
+    for (_iter161 = this->max_values.begin(); _iter161 != this->max_values.end(); ++_iter161)
     {
-      xfer += oprot->writeBinary((*_iter159));
+      xfer += oprot->writeBinary((*_iter161));
     }
     xfer += oprot->writeListEnd();
   }
@@ -5603,10 +5759,10 @@ uint32_t ColumnIndex::write(::apache::thrift::protocol::TProtocol* oprot) const
     xfer += oprot->writeFieldBegin("null_counts", ::apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->null_counts.size()));
-      std::vector<int64_t> ::const_iterator _iter160;
-      for (_iter160 = this->null_counts.begin(); _iter160 != this->null_counts.end(); ++_iter160)
+      std::vector<int64_t> ::const_iterator _iter162;
+      for (_iter162 = this->null_counts.begin(); _iter162 != this->null_counts.end(); ++_iter162)
       {
-        xfer += oprot->writeI64((*_iter160));
+        xfer += oprot->writeI64((*_iter162));
       }
       xfer += oprot->writeListEnd();
     }
@@ -5627,21 +5783,21 @@ void swap(ColumnIndex &a, ColumnIndex &b) {
   swap(a.__isset, b.__isset);
 }
 
-ColumnIndex::ColumnIndex(const ColumnIndex& other161) {
-  null_pages = other161.null_pages;
-  min_values = other161.min_values;
-  max_values = other161.max_values;
-  boundary_order = other161.boundary_order;
-  null_counts = other161.null_counts;
-  __isset = other161.__isset;
-}
-ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other162) {
-  null_pages = other162.null_pages;
-  min_values = other162.min_values;
-  max_values = other162.max_values;
-  boundary_order = other162.boundary_order;
-  null_counts = other162.null_counts;
-  __isset = other162.__isset;
+ColumnIndex::ColumnIndex(const ColumnIndex& other163) {
+  null_pages = other163.null_pages;
+  min_values = other163.min_values;
+  max_values = other163.max_values;
+  boundary_order = other163.boundary_order;
+  null_counts = other163.null_counts;
+  __isset = other163.__isset;
+}
+ColumnIndex& ColumnIndex::operator=(const ColumnIndex& other164) {
+  null_pages = other164.null_pages;
+  min_values = other164.min_values;
+  max_values = other164.max_values;
+  boundary_order = other164.boundary_order;
+  null_counts = other164.null_counts;
+  __isset = other164.__isset;
   return *this;
 }
 void ColumnIndex::printTo(std::ostream& out) const {
@@ -5656,48 +5812,32 @@ void ColumnIndex::printTo(std::ostream& out) const {
 }
 
 
-FileMetaData::~FileMetaData() throw() {
-}
-
-
-void FileMetaData::__set_version(const int32_t val) {
-  this->version = val;
-}
-
-void FileMetaData::__set_schema(const std::vector<SchemaElement> & val) {
-  this->schema = val;
-}
-
-void FileMetaData::__set_num_rows(const int64_t val) {
-  this->num_rows = val;
+AesGcmV1::~AesGcmV1() throw() {
 }
 
-void FileMetaData::__set_row_groups(const std::vector<RowGroup> & val) {
-  this->row_groups = val;
-}
 
-void FileMetaData::__set_key_value_metadata(const std::vector<KeyValue> & val) {
-  this->key_value_metadata = val;
-__isset.key_value_metadata = true;
+void AesGcmV1::__set_aad_prefix(const std::string& val) {
+  this->aad_prefix = val;
+__isset.aad_prefix = true;
 }
 
-void FileMetaData::__set_created_by(const std::string& val) {
-  this->created_by = val;
-__isset.created_by = true;
+void AesGcmV1::__set_aad_file_unique(const std::string& val) {
+  this->aad_file_unique = val;
+__isset.aad_file_unique = true;
 }
 
-void FileMetaData::__set_column_orders(const std::vector<ColumnOrder> & val) {
-  this->column_orders = val;
-__isset.column_orders = true;
+void AesGcmV1::__set_supply_aad_prefix(const bool val) {
+  this->supply_aad_prefix = val;
+__isset.supply_aad_prefix = true;
 }
-std::ostream& operator<<(std::ostream& out, const FileMetaData& obj)
+std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj)
 {
   obj.printTo(out);
   return out;
 }
 
 
-uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AesGcmV1::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -5709,10 +5849,6 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   using ::apache::thrift::protocol::TProtocolException;
 
-  bool isset_version = false;
-  bool isset_schema = false;
-  bool isset_num_rows = false;
-  bool isset_row_groups = false;
 
   while (true)
   {
@@ -5723,105 +5859,25 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_I32) {
-          xfer += iprot->readI32(this->version);
-          isset_version = true;
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->aad_prefix);
+          this->__isset.aad_prefix = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->schema.clear();
-            uint32_t _size163;
-            ::apache::thrift::protocol::TType _etype166;
-            xfer += iprot->readListBegin(_etype166, _size163);
-            this->schema.resize(_size163);
-            uint32_t _i167;
-            for (_i167 = 0; _i167 < _size163; ++_i167)
-            {
-              xfer += this->schema[_i167].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_schema = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->num_rows);
-          isset_num_rows = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->row_groups.clear();
-            uint32_t _size168;
-            ::apache::thrift::protocol::TType _etype171;
-            xfer += iprot->readListBegin(_etype171, _size168);
-            this->row_groups.resize(_size168);
-            uint32_t _i172;
-            for (_i172 = 0; _i172 < _size168; ++_i172)
-            {
-              xfer += this->row_groups[_i172].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          isset_row_groups = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 5:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->key_value_metadata.clear();
-            uint32_t _size173;
-            ::apache::thrift::protocol::TType _etype176;
-            xfer += iprot->readListBegin(_etype176, _size173);
-            this->key_value_metadata.resize(_size173);
-            uint32_t _i177;
-            for (_i177 = 0; _i177 < _size173; ++_i177)
-            {
-              xfer += this->key_value_metadata[_i177].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.key_value_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 6:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readString(this->created_by);
-          this->__isset.created_by = true;
+          xfer += iprot->readBinary(this->aad_file_unique);
+          this->__isset.aad_file_unique = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
-      case 7:
-        if (ftype == ::apache::thrift::protocol::T_LIST) {
-          {
-            this->column_orders.clear();
-            uint32_t _size178;
-            ::apache::thrift::protocol::TType _etype181;
-            xfer += iprot->readListBegin(_etype181, _size178);
-            this->column_orders.resize(_size178);
-            uint32_t _i182;
-            for (_i182 = 0; _i182 < _size178; ++_i182)
-            {
-              xfer += this->column_orders[_i182].read(iprot);
-            }
-            xfer += iprot->readListEnd();
-          }
-          this->__isset.column_orders = true;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->supply_aad_prefix);
+          this->__isset.supply_aad_prefix = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -5835,83 +5891,27 @@ uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   xfer += iprot->readStructEnd();
 
-  if (!isset_version)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_schema)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_num_rows)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_row_groups)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
-uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AesGcmV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("FileMetaData");
-
-  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 1);
-  xfer += oprot->writeI32(this->version);
-  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeStructBegin("AesGcmV1");
 
-  xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_LIST, 2);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
-    std::vector<SchemaElement> ::const_iterator _iter183;
-    for (_iter183 = this->schema.begin(); _iter183 != this->schema.end(); ++_iter183)
-    {
-      xfer += (*_iter183).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I64, 3);
-  xfer += oprot->writeI64(this->num_rows);
-  xfer += oprot->writeFieldEnd();
-
-  xfer += oprot->writeFieldBegin("row_groups", ::apache::thrift::protocol::T_LIST, 4);
-  {
-    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
-    std::vector<RowGroup> ::const_iterator _iter184;
-    for (_iter184 = this->row_groups.begin(); _iter184 != this->row_groups.end(); ++_iter184)
-    {
-      xfer += (*_iter184).write(oprot);
-    }
-    xfer += oprot->writeListEnd();
-  }
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.key_value_metadata) {
-    xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 5);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter185;
-      for (_iter185 = this->key_value_metadata.begin(); _iter185 != this->key_value_metadata.end(); ++_iter185)
-      {
-        xfer += (*_iter185).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
+  if (this->__isset.aad_prefix) {
+    xfer += oprot->writeFieldBegin("aad_prefix", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeBinary(this->aad_prefix);
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.created_by) {
-    xfer += oprot->writeFieldBegin("created_by", ::apache::thrift::protocol::T_STRING, 6);
-    xfer += oprot->writeString(this->created_by);
+  if (this->__isset.aad_file_unique) {
+    xfer += oprot->writeFieldBegin("aad_file_unique", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->aad_file_unique);
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.column_orders) {
-    xfer += oprot->writeFieldBegin("column_orders", ::apache::thrift::protocol::T_LIST, 7);
-    {
-      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_orders.size()));
-      std::vector<ColumnOrder> ::const_iterator _iter186;
-      for (_iter186 = this->column_orders.begin(); _iter186 != this->column_orders.end(); ++_iter186)
-      {
-        xfer += (*_iter186).write(oprot);
-      }
-      xfer += oprot->writeListEnd();
-    }
+  if (this->__isset.supply_aad_prefix) {
+    xfer += oprot->writeFieldBegin("supply_aad_prefix", ::apache::thrift::protocol::T_BOOL, 3);
+    xfer += oprot->writeBool(this->supply_aad_prefix);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -5919,74 +5919,63 @@ uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const
   return xfer;
 }
 
-void swap(FileMetaData &a, FileMetaData &b) {
+void swap(AesGcmV1 &a, AesGcmV1 &b) {
   using ::std::swap;
-  swap(a.version, b.version);
-  swap(a.schema, b.schema);
-  swap(a.num_rows, b.num_rows);
-  swap(a.row_groups, b.row_groups);
-  swap(a.key_value_metadata, b.key_value_metadata);
-  swap(a.created_by, b.created_by);
-  swap(a.column_orders, b.column_orders);
+  swap(a.aad_prefix, b.aad_prefix);
+  swap(a.aad_file_unique, b.aad_file_unique);
+  swap(a.supply_aad_prefix, b.supply_aad_prefix);
   swap(a.__isset, b.__isset);
 }
 
-FileMetaData::FileMetaData(const FileMetaData& other187) {
-  version = other187.version;
-  schema = other187.schema;
-  num_rows = other187.num_rows;
-  row_groups = other187.row_groups;
-  key_value_metadata = other187.key_value_metadata;
-  created_by = other187.created_by;
-  column_orders = other187.column_orders;
-  __isset = other187.__isset;
-}
-FileMetaData& FileMetaData::operator=(const FileMetaData& other188) {
-  version = other188.version;
-  schema = other188.schema;
-  num_rows = other188.num_rows;
-  row_groups = other188.row_groups;
-  key_value_metadata = other188.key_value_metadata;
-  created_by = other188.created_by;
-  column_orders = other188.column_orders;
-  __isset = other188.__isset;
+AesGcmV1::AesGcmV1(const AesGcmV1& other165) {
+  aad_prefix = other165.aad_prefix;
+  aad_file_unique = other165.aad_file_unique;
+  supply_aad_prefix = other165.supply_aad_prefix;
+  __isset = other165.__isset;
+}
+AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other166) {
+  aad_prefix = other166.aad_prefix;
+  aad_file_unique = other166.aad_file_unique;
+  supply_aad_prefix = other166.supply_aad_prefix;
+  __isset = other166.__isset;
   return *this;
 }
-void FileMetaData::printTo(std::ostream& out) const {
+void AesGcmV1::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "FileMetaData(";
-  out << "version=" << to_string(version);
-  out << ", " << "schema=" << to_string(schema);
-  out << ", " << "num_rows=" << to_string(num_rows);
-  out << ", " << "row_groups=" << to_string(row_groups);
-  out << ", " << "key_value_metadata="; (__isset.key_value_metadata ? (out << to_string(key_value_metadata)) : (out << "<null>"));
-  out << ", " << "created_by="; (__isset.created_by ? (out << to_string(created_by)) : (out << "<null>"));
-  out << ", " << "column_orders="; (__isset.column_orders ? (out << to_string(column_orders)) : (out << "<null>"));
+  out << "AesGcmV1(";
+  out << "aad_prefix="; (__isset.aad_prefix ? (out << to_string(aad_prefix)) : (out << "<null>"));
+  out << ", " << "aad_file_unique="; (__isset.aad_file_unique ? (out << to_string(aad_file_unique)) : (out << "<null>"));
+  out << ", " << "supply_aad_prefix="; (__isset.supply_aad_prefix ? (out << to_string(supply_aad_prefix)) : (out << "<null>"));
   out << ")";
 }
 
 
-AesGcmV1::~AesGcmV1() throw() {
+AesGcmCtrV1::~AesGcmCtrV1() throw() {
 }
 
 
-void AesGcmV1::__set_aad_metadata(const std::string& val) {
-  this->aad_metadata = val;
-__isset.aad_metadata = true;
+void AesGcmCtrV1::__set_aad_prefix(const std::string& val) {
+  this->aad_prefix = val;
+__isset.aad_prefix = true;
 }
 
-void AesGcmV1::__set_iv_prefix(const std::string& val) {
-  this->iv_prefix = val;
-__isset.iv_prefix = true;
+void AesGcmCtrV1::__set_aad_file_unique(const std::string& val) {
+  this->aad_file_unique = val;
+__isset.aad_file_unique = true;
 }
-std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj)
+
+void AesGcmCtrV1::__set_supply_aad_prefix(const bool val) {
+  this->supply_aad_prefix = val;
+__isset.supply_aad_prefix = true;
+}
+std::ostream& operator<<(std::ostream& out, const AesGcmCtrV1& obj)
 {
   obj.printTo(out);
   return out;
 }
 
 
-uint32_t AesGcmV1::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t AesGcmCtrV1::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -6009,16 +5998,24 @@ uint32_t AesGcmV1::read(::apache::thrift::protocol::TProtocol* iprot) {
     {
       case 1:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->aad_metadata);
-          this->__isset.aad_metadata = true;
+          xfer += iprot->readBinary(this->aad_prefix);
+          this->__isset.aad_prefix = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->iv_prefix);
-          this->__isset.iv_prefix = true;
+          xfer += iprot->readBinary(this->aad_file_unique);
+          this->__isset.aad_file_unique = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->supply_aad_prefix);
+          this->__isset.supply_aad_prefix = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -6035,19 +6032,24 @@ uint32_t AesGcmV1::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t AesGcmV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t AesGcmCtrV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("AesGcmV1");
+  xfer += oprot->writeStructBegin("AesGcmCtrV1");
 
-  if (this->__isset.aad_metadata) {
-    xfer += oprot->writeFieldBegin("aad_metadata", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeBinary(this->aad_metadata);
+  if (this->__isset.aad_prefix) {
+    xfer += oprot->writeFieldBegin("aad_prefix", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeBinary(this->aad_prefix);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.aad_file_unique) {
+    xfer += oprot->writeFieldBegin("aad_file_unique", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->aad_file_unique);
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.iv_prefix) {
-    xfer += oprot->writeFieldBegin("iv_prefix", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->iv_prefix);
+  if (this->__isset.supply_aad_prefix) {
+    xfer += oprot->writeFieldBegin("supply_aad_prefix", ::apache::thrift::protocol::T_BOOL, 3);
+    xfer += oprot->writeBool(this->supply_aad_prefix);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -6055,59 +6057,58 @@ uint32_t AesGcmV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
   return xfer;
 }
 
-void swap(AesGcmV1 &a, AesGcmV1 &b) {
+void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b) {
   using ::std::swap;
-  swap(a.aad_metadata, b.aad_metadata);
-  swap(a.iv_prefix, b.iv_prefix);
+  swap(a.aad_prefix, b.aad_prefix);
+  swap(a.aad_file_unique, b.aad_file_unique);
+  swap(a.supply_aad_prefix, b.supply_aad_prefix);
   swap(a.__isset, b.__isset);
 }
 
-AesGcmV1::AesGcmV1(const AesGcmV1& other189) {
-  aad_metadata = other189.aad_metadata;
-  iv_prefix = other189.iv_prefix;
-  __isset = other189.__isset;
+AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other167) {
+  aad_prefix = other167.aad_prefix;
+  aad_file_unique = other167.aad_file_unique;
+  supply_aad_prefix = other167.supply_aad_prefix;
+  __isset = other167.__isset;
 }
-AesGcmV1& AesGcmV1::operator=(const AesGcmV1& other190) {
-  aad_metadata = other190.aad_metadata;
-  iv_prefix = other190.iv_prefix;
-  __isset = other190.__isset;
+AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other168) {
+  aad_prefix = other168.aad_prefix;
+  aad_file_unique = other168.aad_file_unique;
+  supply_aad_prefix = other168.supply_aad_prefix;
+  __isset = other168.__isset;
   return *this;
 }
-void AesGcmV1::printTo(std::ostream& out) const {
+void AesGcmCtrV1::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "AesGcmV1(";
-  out << "aad_metadata="; (__isset.aad_metadata ? (out << to_string(aad_metadata)) : (out << "<null>"));
-  out << ", " << "iv_prefix="; (__isset.iv_prefix ? (out << to_string(iv_prefix)) : (out << "<null>"));
+  out << "AesGcmCtrV1(";
+  out << "aad_prefix="; (__isset.aad_prefix ? (out << to_string(aad_prefix)) : (out << "<null>"));
+  out << ", " << "aad_file_unique="; (__isset.aad_file_unique ? (out << to_string(aad_file_unique)) : (out << "<null>"));
+  out << ", " << "supply_aad_prefix="; (__isset.supply_aad_prefix ? (out << to_string(supply_aad_prefix)) : (out << "<null>"));
   out << ")";
 }
 
 
-AesGcmCtrV1::~AesGcmCtrV1() throw() {
+EncryptionAlgorithm::~EncryptionAlgorithm() throw() {
 }
 
 
-void AesGcmCtrV1::__set_aad_metadata(const std::string& val) {
-  this->aad_metadata = val;
-__isset.aad_metadata = true;
-}
-
-void AesGcmCtrV1::__set_gcm_iv_prefix(const std::string& val) {
-  this->gcm_iv_prefix = val;
-__isset.gcm_iv_prefix = true;
+void EncryptionAlgorithm::__set_AES_GCM_V1(const AesGcmV1& val) {
+  this->AES_GCM_V1 = val;
+__isset.AES_GCM_V1 = true;
 }
 
-void AesGcmCtrV1::__set_ctr_iv_prefix(const std::string& val) {
-  this->ctr_iv_prefix = val;
-__isset.ctr_iv_prefix = true;
+void EncryptionAlgorithm::__set_AES_GCM_CTR_V1(const AesGcmCtrV1& val) {
+  this->AES_GCM_CTR_V1 = val;
+__isset.AES_GCM_CTR_V1 = true;
 }
-std::ostream& operator<<(std::ostream& out, const AesGcmCtrV1& obj)
+std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj)
 {
   obj.printTo(out);
   return out;
 }
 
 
-uint32_t AesGcmCtrV1::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t EncryptionAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -6129,25 +6130,17 @@ uint32_t AesGcmCtrV1::read(::apache::thrift::protocol::TProtocol* iprot) {
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->aad_metadata);
-          this->__isset.aad_metadata = true;
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->AES_GCM_V1.read(iprot);
+          this->__isset.AES_GCM_V1 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->gcm_iv_prefix);
-          this->__isset.gcm_iv_prefix = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
-        if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->ctr_iv_prefix);
-          this->__isset.ctr_iv_prefix = true;
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->AES_GCM_CTR_V1.read(iprot);
+          this->__isset.AES_GCM_CTR_V1 = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -6164,24 +6157,19 @@ uint32_t AesGcmCtrV1::read(::apache::thrift::protocol::TProtocol* iprot) {
   return xfer;
 }
 
-uint32_t AesGcmCtrV1::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t EncryptionAlgorithm::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("AesGcmCtrV1");
+  xfer += oprot->writeStructBegin("EncryptionAlgorithm");
 
-  if (this->__isset.aad_metadata) {
-    xfer += oprot->writeFieldBegin("aad_metadata", ::apache::thrift::protocol::T_STRING, 1);
-    xfer += oprot->writeBinary(this->aad_metadata);
-    xfer += oprot->writeFieldEnd();
-  }
-  if (this->__isset.gcm_iv_prefix) {
-    xfer += oprot->writeFieldBegin("gcm_iv_prefix", ::apache::thrift::protocol::T_STRING, 2);
-    xfer += oprot->writeBinary(this->gcm_iv_prefix);
+  if (this->__isset.AES_GCM_V1) {
+    xfer += oprot->writeFieldBegin("AES_GCM_V1", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->AES_GCM_V1.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.ctr_iv_prefix) {
-    xfer += oprot->writeFieldBegin("ctr_iv_prefix", ::apache::thrift::protocol::T_STRING, 3);
-    xfer += oprot->writeBinary(this->ctr_iv_prefix);
+  if (this->__isset.AES_GCM_CTR_V1) {
+    xfer += oprot->writeFieldBegin("AES_GCM_CTR_V1", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->AES_GCM_CTR_V1.write(oprot);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -6189,58 +6177,85 @@ uint32_t AesGcmCtrV1::write(::apache::thrift::protocol::TProtocol* oprot) const
   return xfer;
 }
 
-void swap(AesGcmCtrV1 &a, AesGcmCtrV1 &b) {
+void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b) {
   using ::std::swap;
-  swap(a.aad_metadata, b.aad_metadata);
-  swap(a.gcm_iv_prefix, b.gcm_iv_prefix);
-  swap(a.ctr_iv_prefix, b.ctr_iv_prefix);
+  swap(a.AES_GCM_V1, b.AES_GCM_V1);
+  swap(a.AES_GCM_CTR_V1, b.AES_GCM_CTR_V1);
   swap(a.__isset, b.__isset);
 }
 
-AesGcmCtrV1::AesGcmCtrV1(const AesGcmCtrV1& other191) {
-  aad_metadata = other191.aad_metadata;
-  gcm_iv_prefix = other191.gcm_iv_prefix;
-  ctr_iv_prefix = other191.ctr_iv_prefix;
-  __isset = other191.__isset;
+EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other169) {
+  AES_GCM_V1 = other169.AES_GCM_V1;
+  AES_GCM_CTR_V1 = other169.AES_GCM_CTR_V1;
+  __isset = other169.__isset;
 }
-AesGcmCtrV1& AesGcmCtrV1::operator=(const AesGcmCtrV1& other192) {
-  aad_metadata = other192.aad_metadata;
-  gcm_iv_prefix = other192.gcm_iv_prefix;
-  ctr_iv_prefix = other192.ctr_iv_prefix;
-  __isset = other192.__isset;
+EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other170) {
+  AES_GCM_V1 = other170.AES_GCM_V1;
+  AES_GCM_CTR_V1 = other170.AES_GCM_CTR_V1;
+  __isset = other170.__isset;
   return *this;
 }
-void AesGcmCtrV1::printTo(std::ostream& out) const {
+void EncryptionAlgorithm::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "AesGcmCtrV1(";
-  out << "aad_metadata="; (__isset.aad_metadata ? (out << to_string(aad_metadata)) : (out << "<null>"));
-  out << ", " << "gcm_iv_prefix="; (__isset.gcm_iv_prefix ? (out << to_string(gcm_iv_prefix)) : (out << "<null>"));
-  out << ", " << "ctr_iv_prefix="; (__isset.ctr_iv_prefix ? (out << to_string(ctr_iv_prefix)) : (out << "<null>"));
+  out << "EncryptionAlgorithm(";
+  out << "AES_GCM_V1="; (__isset.AES_GCM_V1 ? (out << to_string(AES_GCM_V1)) : (out << "<null>"));
+  out << ", " << "AES_GCM_CTR_V1="; (__isset.AES_GCM_CTR_V1 ? (out << to_string(AES_GCM_CTR_V1)) : (out << "<null>"));
   out << ")";
 }
 
 
-EncryptionAlgorithm::~EncryptionAlgorithm() throw() {
+FileMetaData::~FileMetaData() throw() {
 }
 
 
-void EncryptionAlgorithm::__set_AES_GCM_V1(const AesGcmV1& val) {
-  this->AES_GCM_V1 = val;
-__isset.AES_GCM_V1 = true;
+void FileMetaData::__set_version(const int32_t val) {
+  this->version = val;
 }
 
-void EncryptionAlgorithm::__set_AES_GCM_CTR_V1(const AesGcmCtrV1& val) {
-  this->AES_GCM_CTR_V1 = val;
-__isset.AES_GCM_CTR_V1 = true;
+void FileMetaData::__set_schema(const std::vector<SchemaElement> & val) {
+  this->schema = val;
 }
-std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj)
+
+void FileMetaData::__set_num_rows(const int64_t val) {
+  this->num_rows = val;
+}
+
+void FileMetaData::__set_row_groups(const std::vector<RowGroup> & val) {
+  this->row_groups = val;
+}
+
+void FileMetaData::__set_key_value_metadata(const std::vector<KeyValue> & val) {
+  this->key_value_metadata = val;
+__isset.key_value_metadata = true;
+}
+
+void FileMetaData::__set_created_by(const std::string& val) {
+  this->created_by = val;
+__isset.created_by = true;
+}
+
+void FileMetaData::__set_column_orders(const std::vector<ColumnOrder> & val) {
+  this->column_orders = val;
+__isset.column_orders = true;
+}
+
+void FileMetaData::__set_encryption_algorithm(const EncryptionAlgorithm& val) {
+  this->encryption_algorithm = val;
+__isset.encryption_algorithm = true;
+}
+
+void FileMetaData::__set_footer_signing_key_metadata(const std::string& val) {
+  this->footer_signing_key_metadata = val;
+__isset.footer_signing_key_metadata = true;
+}
+std::ostream& operator<<(std::ostream& out, const FileMetaData& obj)
 {
   obj.printTo(out);
   return out;
 }
 
 
-uint32_t EncryptionAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t FileMetaData::read(::apache::thrift::protocol::TProtocol* iprot) {
 
   ::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
   uint32_t xfer = 0;
@@ -6252,6 +6267,10 @@ uint32_t EncryptionAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot)
 
   using ::apache::thrift::protocol::TProtocolException;
 
+  bool isset_version = false;
+  bool isset_schema = false;
+  bool isset_num_rows = false;
+  bool isset_row_groups = false;
 
   while (true)
   {
@@ -6262,17 +6281,121 @@ uint32_t EncryptionAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot)
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->AES_GCM_V1.read(iprot);
-          this->__isset.AES_GCM_V1 = true;
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->version);
+          isset_version = true;
         } else {
           xfer += iprot->skip(ftype);
         }
         break;
       case 2:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->schema.clear();
+            uint32_t _size171;
+            ::apache::thrift::protocol::TType _etype174;
+            xfer += iprot->readListBegin(_etype174, _size171);
+            this->schema.resize(_size171);
+            uint32_t _i175;
+            for (_i175 = 0; _i175 < _size171; ++_i175)
+            {
+              xfer += this->schema[_i175].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_schema = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I64) {
+          xfer += iprot->readI64(this->num_rows);
+          isset_num_rows = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->row_groups.clear();
+            uint32_t _size176;
+            ::apache::thrift::protocol::TType _etype179;
+            xfer += iprot->readListBegin(_etype179, _size176);
+            this->row_groups.resize(_size176);
+            uint32_t _i180;
+            for (_i180 = 0; _i180 < _size176; ++_i180)
+            {
+              xfer += this->row_groups[_i180].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_row_groups = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->key_value_metadata.clear();
+            uint32_t _size181;
+            ::apache::thrift::protocol::TType _etype184;
+            xfer += iprot->readListBegin(_etype184, _size181);
+            this->key_value_metadata.resize(_size181);
+            uint32_t _i185;
+            for (_i185 = 0; _i185 < _size181; ++_i185)
+            {
+              xfer += this->key_value_metadata[_i185].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.key_value_metadata = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 6:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->created_by);
+          this->__isset.created_by = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 7:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->column_orders.clear();
+            uint32_t _size186;
+            ::apache::thrift::protocol::TType _etype189;
+            xfer += iprot->readListBegin(_etype189, _size186);
+            this->column_orders.resize(_size186);
+            uint32_t _i190;
+            for (_i190 = 0; _i190 < _size186; ++_i190)
+            {
+              xfer += this->column_orders[_i190].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.column_orders = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 8:
         if (ftype == ::apache::thrift::protocol::T_STRUCT) {
-          xfer += this->AES_GCM_CTR_V1.read(iprot);
-          this->__isset.AES_GCM_CTR_V1 = true;
+          xfer += this->encryption_algorithm.read(iprot);
+          this->__isset.encryption_algorithm = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 9:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readBinary(this->footer_signing_key_metadata);
+          this->__isset.footer_signing_key_metadata = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -6286,22 +6409,93 @@ uint32_t EncryptionAlgorithm::read(::apache::thrift::protocol::TProtocol* iprot)
 
   xfer += iprot->readStructEnd();
 
+  if (!isset_version)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_schema)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_num_rows)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_row_groups)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
-uint32_t EncryptionAlgorithm::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t FileMetaData::write(::apache::thrift::protocol::TProtocol* oprot) const {
   uint32_t xfer = 0;
   ::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
-  xfer += oprot->writeStructBegin("EncryptionAlgorithm");
+  xfer += oprot->writeStructBegin("FileMetaData");
 
-  if (this->__isset.AES_GCM_V1) {
-    xfer += oprot->writeFieldBegin("AES_GCM_V1", ::apache::thrift::protocol::T_STRUCT, 1);
-    xfer += this->AES_GCM_V1.write(oprot);
+  xfer += oprot->writeFieldBegin("version", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32(this->version);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("schema", ::apache::thrift::protocol::T_LIST, 2);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
+    std::vector<SchemaElement> ::const_iterator _iter191;
+    for (_iter191 = this->schema.begin(); _iter191 != this->schema.end(); ++_iter191)
+    {
+      xfer += (*_iter191).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("num_rows", ::apache::thrift::protocol::T_I64, 3);
+  xfer += oprot->writeI64(this->num_rows);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("row_groups", ::apache::thrift::protocol::T_LIST, 4);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
+    std::vector<RowGroup> ::const_iterator _iter192;
+    for (_iter192 = this->row_groups.begin(); _iter192 != this->row_groups.end(); ++_iter192)
+    {
+      xfer += (*_iter192).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.key_value_metadata) {
+    xfer += oprot->writeFieldBegin("key_value_metadata", ::apache::thrift::protocol::T_LIST, 5);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
+      std::vector<KeyValue> ::const_iterator _iter193;
+      for (_iter193 = this->key_value_metadata.begin(); _iter193 != this->key_value_metadata.end(); ++_iter193)
+      {
+        xfer += (*_iter193).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
     xfer += oprot->writeFieldEnd();
   }
-  if (this->__isset.AES_GCM_CTR_V1) {
-    xfer += oprot->writeFieldBegin("AES_GCM_CTR_V1", ::apache::thrift::protocol::T_STRUCT, 2);
-    xfer += this->AES_GCM_CTR_V1.write(oprot);
+  if (this->__isset.created_by) {
+    xfer += oprot->writeFieldBegin("created_by", ::apache::thrift::protocol::T_STRING, 6);
+    xfer += oprot->writeString(this->created_by);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.column_orders) {
+    xfer += oprot->writeFieldBegin("column_orders", ::apache::thrift::protocol::T_LIST, 7);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_orders.size()));
+      std::vector<ColumnOrder> ::const_iterator _iter194;
+      for (_iter194 = this->column_orders.begin(); _iter194 != this->column_orders.end(); ++_iter194)
+      {
+        xfer += (*_iter194).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.encryption_algorithm) {
+    xfer += oprot->writeFieldBegin("encryption_algorithm", ::apache::thrift::protocol::T_STRUCT, 8);
+    xfer += this->encryption_algorithm.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.footer_signing_key_metadata) {
+    xfer += oprot->writeFieldBegin("footer_signing_key_metadata", ::apache::thrift::protocol::T_STRING, 9);
+    xfer += oprot->writeBinary(this->footer_signing_key_metadata);
     xfer += oprot->writeFieldEnd();
   }
   xfer += oprot->writeFieldStop();
@@ -6309,29 +6503,57 @@ uint32_t EncryptionAlgorithm::write(::apache::thrift::protocol::TProtocol* oprot
   return xfer;
 }
 
-void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b) {
+void swap(FileMetaData &a, FileMetaData &b) {
   using ::std::swap;
-  swap(a.AES_GCM_V1, b.AES_GCM_V1);
-  swap(a.AES_GCM_CTR_V1, b.AES_GCM_CTR_V1);
+  swap(a.version, b.version);
+  swap(a.schema, b.schema);
+  swap(a.num_rows, b.num_rows);
+  swap(a.row_groups, b.row_groups);
+  swap(a.key_value_metadata, b.key_value_metadata);
+  swap(a.created_by, b.created_by);
+  swap(a.column_orders, b.column_orders);
+  swap(a.encryption_algorithm, b.encryption_algorithm);
+  swap(a.footer_signing_key_metadata, b.footer_signing_key_metadata);
   swap(a.__isset, b.__isset);
 }
 
-EncryptionAlgorithm::EncryptionAlgorithm(const EncryptionAlgorithm& other193) {
-  AES_GCM_V1 = other193.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other193.AES_GCM_CTR_V1;
-  __isset = other193.__isset;
+FileMetaData::FileMetaData(const FileMetaData& other195) {
+  version = other195.version;
+  schema = other195.schema;
+  num_rows = other195.num_rows;
+  row_groups = other195.row_groups;
+  key_value_metadata = other195.key_value_metadata;
+  created_by = other195.created_by;
+  column_orders = other195.column_orders;
+  encryption_algorithm = other195.encryption_algorithm;
+  footer_signing_key_metadata = other195.footer_signing_key_metadata;
+  __isset = other195.__isset;
 }
-EncryptionAlgorithm& EncryptionAlgorithm::operator=(const EncryptionAlgorithm& other194) {
-  AES_GCM_V1 = other194.AES_GCM_V1;
-  AES_GCM_CTR_V1 = other194.AES_GCM_CTR_V1;
-  __isset = other194.__isset;
+FileMetaData& FileMetaData::operator=(const FileMetaData& other196) {
+  version = other196.version;
+  schema = other196.schema;
+  num_rows = other196.num_rows;
+  row_groups = other196.row_groups;
+  key_value_metadata = other196.key_value_metadata;
+  created_by = other196.created_by;
+  column_orders = other196.column_orders;
+  encryption_algorithm = other196.encryption_algorithm;
+  footer_signing_key_metadata = other196.footer_signing_key_metadata;
+  __isset = other196.__isset;
   return *this;
 }
-void EncryptionAlgorithm::printTo(std::ostream& out) const {
+void FileMetaData::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
-  out << "EncryptionAlgorithm(";
-  out << "AES_GCM_V1="; (__isset.AES_GCM_V1 ? (out << to_string(AES_GCM_V1)) : (out << "<null>"));
-  out << ", " << "AES_GCM_CTR_V1="; (__isset.AES_GCM_CTR_V1 ? (out << to_string(AES_GCM_CTR_V1)) : (out << "<null>"));
+  out << "FileMetaData(";
+  out << "version=" << to_string(version);
+  out << ", " << "schema=" << to_string(schema);
+  out << ", " << "num_rows=" << to_string(num_rows);
+  out << ", " << "row_groups=" << to_string(row_groups);
+  out << ", " << "key_value_metadata="; (__isset.key_value_metadata ? (out << to_string(key_value_metadata)) : (out << "<null>"));
+  out << ", " << "created_by="; (__isset.created_by ? (out << to_string(created_by)) : (out << "<null>"));
+  out << ", " << "column_orders="; (__isset.column_orders ? (out << to_string(column_orders)) : (out << "<null>"));
+  out << ", " << "encryption_algorithm="; (__isset.encryption_algorithm ? (out << to_string(encryption_algorithm)) : (out << "<null>"));
+  out << ", " << "footer_signing_key_metadata="; (__isset.footer_signing_key_metadata ? (out << to_string(footer_signing_key_metadata)) : (out << "<null>"));
   out << ")";
 }
 
@@ -6344,17 +6566,9 @@ void FileCryptoMetaData::__set_encryption_algorithm(const EncryptionAlgorithm& v
   this->encryption_algorithm = val;
 }
 
-void FileCryptoMetaData::__set_encrypted_footer(const bool val) {
-  this->encrypted_footer = val;
-}
-
-void FileCryptoMetaData::__set_footer_key_metadata(const std::string& val) {
-  this->footer_key_metadata = val;
-__isset.footer_key_metadata = true;
-}
-
-void FileCryptoMetaData::__set_footer_offset(const int64_t val) {
-  this->footer_offset = val;
+void FileCryptoMetaData::__set_key_metadata(const std::string& val) {
+  this->key_metadata = val;
+__isset.key_metadata = true;
 }
 std::ostream& operator<<(std::ostream& out, const FileCryptoMetaData& obj)
 {
@@ -6376,8 +6590,6 @@ uint32_t FileCryptoMetaData::read(::apache::thrift::protocol::TProtocol* iprot)
   using ::apache::thrift::protocol::TProtocolException;
 
   bool isset_encryption_algorithm = false;
-  bool isset_encrypted_footer = false;
-  bool isset_footer_offset = false;
 
   while (true)
   {
@@ -6396,25 +6608,9 @@ uint32_t FileCryptoMetaData::read(::apache::thrift::protocol::TProtocol* iprot)
         }
         break;
       case 2:
-        if (ftype == ::apache::thrift::protocol::T_BOOL) {
-          xfer += iprot->readBool(this->encrypted_footer);
-          isset_encrypted_footer = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 3:
         if (ftype == ::apache::thrift::protocol::T_STRING) {
-          xfer += iprot->readBinary(this->footer_key_metadata);
-          this->__isset.footer_key_metadata = true;
-        } else {
-          xfer += iprot->skip(ftype);
-        }
-        break;
-      case 4:
-        if (ftype == ::apache::thrift::protocol::T_I64) {
-          xfer += iprot->readI64(this->footer_offset);
-          isset_footer_offset = true;
+          xfer += iprot->readBinary(this->key_metadata);
+          this->__isset.key_metadata = true;
         } else {
           xfer += iprot->skip(ftype);
         }
@@ -6430,10 +6626,6 @@ uint32_t FileCryptoMetaData::read(::apache::thrift::protocol::TProtocol* iprot)
 
   if (!isset_encryption_algorithm)
     throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_encrypted_footer)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
-  if (!isset_footer_offset)
-    throw TProtocolException(TProtocolException::INVALID_DATA);
   return xfer;
 }
 
@@ -6446,19 +6638,11 @@ uint32_t FileCryptoMetaData::write(::apache::thrift::protocol::TProtocol* oprot)
   xfer += this->encryption_algorithm.write(oprot);
   xfer += oprot->writeFieldEnd();
 
-  xfer += oprot->writeFieldBegin("encrypted_footer", ::apache::thrift::protocol::T_BOOL, 2);
-  xfer += oprot->writeBool(this->encrypted_footer);
-  xfer += oprot->writeFieldEnd();
-
-  if (this->__isset.footer_key_metadata) {
-    xfer += oprot->writeFieldBegin("footer_key_metadata", ::apache::thrift::protocol::T_STRING, 3);
-    xfer += oprot->writeBinary(this->footer_key_metadata);
+  if (this->__isset.key_metadata) {
+    xfer += oprot->writeFieldBegin("key_metadata", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeBinary(this->key_metadata);
     xfer += oprot->writeFieldEnd();
   }
-  xfer += oprot->writeFieldBegin("footer_offset", ::apache::thrift::protocol::T_I64, 4);
-  xfer += oprot->writeI64(this->footer_offset);
-  xfer += oprot->writeFieldEnd();
-
   xfer += oprot->writeFieldStop();
   xfer += oprot->writeStructEnd();
   return xfer;
@@ -6467,34 +6651,26 @@ uint32_t FileCryptoMetaData::write(::apache::thrift::protocol::TProtocol* oprot)
 void swap(FileCryptoMetaData &a, FileCryptoMetaData &b) {
   using ::std::swap;
   swap(a.encryption_algorithm, b.encryption_algorithm);
-  swap(a.encrypted_footer, b.encrypted_footer);
-  swap(a.footer_key_metadata, b.footer_key_metadata);
-  swap(a.footer_offset, b.footer_offset);
+  swap(a.key_metadata, b.key_metadata);
   swap(a.__isset, b.__isset);
 }
 
-FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other195) {
-  encryption_algorithm = other195.encryption_algorithm;
-  encrypted_footer = other195.encrypted_footer;
-  footer_key_metadata = other195.footer_key_metadata;
-  footer_offset = other195.footer_offset;
-  __isset = other195.__isset;
+FileCryptoMetaData::FileCryptoMetaData(const FileCryptoMetaData& other197) {
+  encryption_algorithm = other197.encryption_algorithm;
+  key_metadata = other197.key_metadata;
+  __isset = other197.__isset;
 }
-FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other196) {
-  encryption_algorithm = other196.encryption_algorithm;
-  encrypted_footer = other196.encrypted_footer;
-  footer_key_metadata = other196.footer_key_metadata;
-  footer_offset = other196.footer_offset;
-  __isset = other196.__isset;
+FileCryptoMetaData& FileCryptoMetaData::operator=(const FileCryptoMetaData& other198) {
+  encryption_algorithm = other198.encryption_algorithm;
+  key_metadata = other198.key_metadata;
+  __isset = other198.__isset;
   return *this;
 }
 void FileCryptoMetaData::printTo(std::ostream& out) const {
   using ::apache::thrift::to_string;
   out << "FileCryptoMetaData(";
   out << "encryption_algorithm=" << to_string(encryption_algorithm);
-  out << ", " << "encrypted_footer=" << to_string(encrypted_footer);
-  out << ", " << "footer_key_metadata="; (__isset.footer_key_metadata ? (out << to_string(footer_key_metadata)) : (out << "<null>"));
-  out << ", " << "footer_offset=" << to_string(footer_offset);
+  out << ", " << "key_metadata="; (__isset.key_metadata ? (out << to_string(key_metadata)) : (out << "<null>"));
   out << ")";
 }
 
diff --git a/contrib/arrow-cmake/cpp/src/parquet/parquet_types.h b/contrib/arrow-cmake/cpp/src/parquet/parquet_types.h
index a10e49be826b9bc35790d57103e13858267a9b45..65e9e8226bbc2d5d58abb5848013c0c160480d6b 100644
--- a/contrib/arrow-cmake/cpp/src/parquet/parquet_types.h
+++ b/contrib/arrow-cmake/cpp/src/parquet/parquet_types.h
@@ -1,5 +1,5 @@
 /**
- * Autogenerated by Thrift Compiler (0.11.0)
+ * Autogenerated by Thrift Compiler (0.12.0)
  *
  * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  *  @generated
@@ -17,7 +17,7 @@
 
 #include <thrift/stdcxx.h>
 
-#include "parquet/util/windows_compatibility.h"
+#include "parquet/windows_compatibility.h"
 
 namespace parquet { namespace format {
 
@@ -161,6 +161,8 @@ class MilliSeconds;
 
 class MicroSeconds;
 
+class NanoSeconds;
+
 class TimeUnit;
 
 class TimestampType;
@@ -215,14 +217,14 @@ class OffsetIndex;
 
 class ColumnIndex;
 
-class FileMetaData;
-
 class AesGcmV1;
 
 class AesGcmCtrV1;
 
 class EncryptionAlgorithm;
 
+class FileMetaData;
+
 class FileCryptoMetaData;
 
 typedef struct _Statistics__isset {
@@ -629,10 +631,42 @@ void swap(MicroSeconds &a, MicroSeconds &b);
 
 std::ostream& operator<<(std::ostream& out, const MicroSeconds& obj);
 
+
+class NanoSeconds : public virtual ::apache::thrift::TBase {
+ public:
+
+  NanoSeconds(const NanoSeconds&);
+  NanoSeconds& operator=(const NanoSeconds&);
+  NanoSeconds() {
+  }
+
+  virtual ~NanoSeconds() throw();
+
+  bool operator == (const NanoSeconds & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const NanoSeconds &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const NanoSeconds & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(NanoSeconds &a, NanoSeconds &b);
+
+std::ostream& operator<<(std::ostream& out, const NanoSeconds& obj);
+
 typedef struct _TimeUnit__isset {
-  _TimeUnit__isset() : MILLIS(false), MICROS(false) {}
+  _TimeUnit__isset() : MILLIS(false), MICROS(false), NANOS(false) {}
   bool MILLIS :1;
   bool MICROS :1;
+  bool NANOS :1;
 } _TimeUnit__isset;
 
 class TimeUnit : public virtual ::apache::thrift::TBase {
@@ -646,6 +680,7 @@ class TimeUnit : public virtual ::apache::thrift::TBase {
   virtual ~TimeUnit() throw();
   MilliSeconds MILLIS;
   MicroSeconds MICROS;
+  NanoSeconds NANOS;
 
   _TimeUnit__isset __isset;
 
@@ -653,6 +688,8 @@ class TimeUnit : public virtual ::apache::thrift::TBase {
 
   void __set_MICROS(const MicroSeconds& val);
 
+  void __set_NANOS(const NanoSeconds& val);
+
   bool operator == (const TimeUnit & rhs) const
   {
     if (__isset.MILLIS != rhs.__isset.MILLIS)
@@ -663,6 +700,10 @@ class TimeUnit : public virtual ::apache::thrift::TBase {
       return false;
     else if (__isset.MICROS && !(MICROS == rhs.MICROS))
       return false;
+    if (__isset.NANOS != rhs.__isset.NANOS)
+      return false;
+    else if (__isset.NANOS && !(NANOS == rhs.NANOS))
+      return false;
     return true;
   }
   bool operator != (const TimeUnit &rhs) const {
@@ -867,7 +908,7 @@ void swap(BsonType &a, BsonType &b);
 std::ostream& operator<<(std::ostream& out, const BsonType& obj);
 
 typedef struct _LogicalType__isset {
-  _LogicalType__isset() : STRING(false), MAP(false), LIST(false), ENUM(false), DECIMAL(false), DATE(false), TIME(false), TIMESTAMP(false), INTEGER(false), UNKNOWN(false), JSON(false), BSON(false) {}
+  _LogicalType__isset() : STRING(false), MAP(false), LIST(false), ENUM(false), DECIMAL(false), DATE(false), TIME(false), TIMESTAMP(false), INTEGER(false), UNKNOWN(false), JSON(false), BSON(false), UUID(false) {}
   bool STRING :1;
   bool MAP :1;
   bool LIST :1;
@@ -880,6 +921,7 @@ typedef struct _LogicalType__isset {
   bool UNKNOWN :1;
   bool JSON :1;
   bool BSON :1;
+  bool UUID :1;
 } _LogicalType__isset;
 
 class LogicalType : public virtual ::apache::thrift::TBase {
@@ -903,6 +945,7 @@ class LogicalType : public virtual ::apache::thrift::TBase {
   NullType UNKNOWN;
   JsonType JSON;
   BsonType BSON;
+  UUIDType UUID;
 
   _LogicalType__isset __isset;
 
@@ -930,6 +973,8 @@ class LogicalType : public virtual ::apache::thrift::TBase {
 
   void __set_BSON(const BsonType& val);
 
+  void __set_UUID(const UUIDType& val);
+
   bool operator == (const LogicalType & rhs) const
   {
     if (__isset.STRING != rhs.__isset.STRING)
@@ -980,6 +1025,10 @@ class LogicalType : public virtual ::apache::thrift::TBase {
       return false;
     else if (__isset.BSON && !(BSON == rhs.BSON))
       return false;
+    if (__isset.UUID != rhs.__isset.UUID)
+      return false;
+    else if (__isset.UUID && !(UUID == rhs.UUID))
+      return false;
     return true;
   }
   bool operator != (const LogicalType &rhs) const {
@@ -1722,8 +1771,8 @@ void swap(EncryptionWithFooterKey &a, EncryptionWithFooterKey &b);
 std::ostream& operator<<(std::ostream& out, const EncryptionWithFooterKey& obj);
 
 typedef struct _EncryptionWithColumnKey__isset {
-  _EncryptionWithColumnKey__isset() : column_key_metadata(false) {}
-  bool column_key_metadata :1;
+  _EncryptionWithColumnKey__isset() : key_metadata(false) {}
+  bool key_metadata :1;
 } _EncryptionWithColumnKey__isset;
 
 class EncryptionWithColumnKey : public virtual ::apache::thrift::TBase {
@@ -1731,26 +1780,26 @@ class EncryptionWithColumnKey : public virtual ::apache::thrift::TBase {
 
   EncryptionWithColumnKey(const EncryptionWithColumnKey&);
   EncryptionWithColumnKey& operator=(const EncryptionWithColumnKey&);
-  EncryptionWithColumnKey() : column_key_metadata() {
+  EncryptionWithColumnKey() : key_metadata() {
   }
 
   virtual ~EncryptionWithColumnKey() throw();
   std::vector<std::string>  path_in_schema;
-  std::string column_key_metadata;
+  std::string key_metadata;
 
   _EncryptionWithColumnKey__isset __isset;
 
   void __set_path_in_schema(const std::vector<std::string> & val);
 
-  void __set_column_key_metadata(const std::string& val);
+  void __set_key_metadata(const std::string& val);
 
   bool operator == (const EncryptionWithColumnKey & rhs) const
   {
     if (!(path_in_schema == rhs.path_in_schema))
       return false;
-    if (__isset.column_key_metadata != rhs.__isset.column_key_metadata)
+    if (__isset.key_metadata != rhs.__isset.key_metadata)
       return false;
-    else if (__isset.column_key_metadata && !(column_key_metadata == rhs.column_key_metadata))
+    else if (__isset.key_metadata && !(key_metadata == rhs.key_metadata))
       return false;
     return true;
   }
@@ -1823,14 +1872,15 @@ void swap(ColumnCryptoMetaData &a, ColumnCryptoMetaData &b);
 std::ostream& operator<<(std::ostream& out, const ColumnCryptoMetaData& obj);
 
 typedef struct _ColumnChunk__isset {
-  _ColumnChunk__isset() : file_path(false), meta_data(false), offset_index_offset(false), offset_index_length(false), column_index_offset(false), column_index_length(false), crypto_meta_data(false) {}
+  _ColumnChunk__isset() : file_path(false), meta_data(false), offset_index_offset(false), offset_index_length(false), column_index_offset(false), column_index_length(false), crypto_metadata(false), encrypted_column_metadata(false) {}
   bool file_path :1;
   bool meta_data :1;
   bool offset_index_offset :1;
   bool offset_index_length :1;
   bool column_index_offset :1;
   bool column_index_length :1;
-  bool crypto_meta_data :1;
+  bool crypto_metadata :1;
+  bool encrypted_column_metadata :1;
 } _ColumnChunk__isset;
 
 class ColumnChunk : public virtual ::apache::thrift::TBase {
@@ -1838,7 +1888,7 @@ class ColumnChunk : public virtual ::apache::thrift::TBase {
 
   ColumnChunk(const ColumnChunk&);
   ColumnChunk& operator=(const ColumnChunk&);
-  ColumnChunk() : file_path(), file_offset(0), offset_index_offset(0), offset_index_length(0), column_index_offset(0), column_index_length(0) {
+  ColumnChunk() : file_path(), file_offset(0), offset_index_offset(0), offset_index_length(0), column_index_offset(0), column_index_length(0), encrypted_column_metadata() {
   }
 
   virtual ~ColumnChunk() throw();
@@ -1849,7 +1899,8 @@ class ColumnChunk : public virtual ::apache::thrift::TBase {
   int32_t offset_index_length;
   int64_t column_index_offset;
   int32_t column_index_length;
-  ColumnCryptoMetaData crypto_meta_data;
+  ColumnCryptoMetaData crypto_metadata;
+  std::string encrypted_column_metadata;
 
   _ColumnChunk__isset __isset;
 
@@ -1867,7 +1918,9 @@ class ColumnChunk : public virtual ::apache::thrift::TBase {
 
   void __set_column_index_length(const int32_t val);
 
-  void __set_crypto_meta_data(const ColumnCryptoMetaData& val);
+  void __set_crypto_metadata(const ColumnCryptoMetaData& val);
+
+  void __set_encrypted_column_metadata(const std::string& val);
 
   bool operator == (const ColumnChunk & rhs) const
   {
@@ -1897,9 +1950,13 @@ class ColumnChunk : public virtual ::apache::thrift::TBase {
       return false;
     else if (__isset.column_index_length && !(column_index_length == rhs.column_index_length))
       return false;
-    if (__isset.crypto_meta_data != rhs.__isset.crypto_meta_data)
+    if (__isset.crypto_metadata != rhs.__isset.crypto_metadata)
+      return false;
+    else if (__isset.crypto_metadata && !(crypto_metadata == rhs.crypto_metadata))
       return false;
-    else if (__isset.crypto_meta_data && !(crypto_meta_data == rhs.crypto_meta_data))
+    if (__isset.encrypted_column_metadata != rhs.__isset.encrypted_column_metadata)
+      return false;
+    else if (__isset.encrypted_column_metadata && !(encrypted_column_metadata == rhs.encrypted_column_metadata))
       return false;
     return true;
   }
@@ -1920,10 +1977,11 @@ void swap(ColumnChunk &a, ColumnChunk &b);
 std::ostream& operator<<(std::ostream& out, const ColumnChunk& obj);
 
 typedef struct _RowGroup__isset {
-  _RowGroup__isset() : sorting_columns(false), file_offset(false), total_compressed_size(false) {}
+  _RowGroup__isset() : sorting_columns(false), file_offset(false), total_compressed_size(false), ordinal(false) {}
   bool sorting_columns :1;
   bool file_offset :1;
   bool total_compressed_size :1;
+  bool ordinal :1;
 } _RowGroup__isset;
 
 class RowGroup : public virtual ::apache::thrift::TBase {
@@ -1931,7 +1989,7 @@ class RowGroup : public virtual ::apache::thrift::TBase {
 
   RowGroup(const RowGroup&);
   RowGroup& operator=(const RowGroup&);
-  RowGroup() : total_byte_size(0), num_rows(0), file_offset(0), total_compressed_size(0) {
+  RowGroup() : total_byte_size(0), num_rows(0), file_offset(0), total_compressed_size(0), ordinal(0) {
   }
 
   virtual ~RowGroup() throw();
@@ -1941,6 +1999,7 @@ class RowGroup : public virtual ::apache::thrift::TBase {
   std::vector<SortingColumn>  sorting_columns;
   int64_t file_offset;
   int64_t total_compressed_size;
+  int16_t ordinal;
 
   _RowGroup__isset __isset;
 
@@ -1956,6 +2015,8 @@ class RowGroup : public virtual ::apache::thrift::TBase {
 
   void __set_total_compressed_size(const int64_t val);
 
+  void __set_ordinal(const int16_t val);
+
   bool operator == (const RowGroup & rhs) const
   {
     if (!(columns == rhs.columns))
@@ -1976,6 +2037,10 @@ class RowGroup : public virtual ::apache::thrift::TBase {
       return false;
     else if (__isset.total_compressed_size && !(total_compressed_size == rhs.total_compressed_size))
       return false;
+    if (__isset.ordinal != rhs.__isset.ordinal)
+      return false;
+    else if (__isset.ordinal && !(ordinal == rhs.ordinal))
+      return false;
     return true;
   }
   bool operator != (const RowGroup &rhs) const {
@@ -2215,90 +2280,11 @@ void swap(ColumnIndex &a, ColumnIndex &b);
 
 std::ostream& operator<<(std::ostream& out, const ColumnIndex& obj);
 
-typedef struct _FileMetaData__isset {
-  _FileMetaData__isset() : key_value_metadata(false), created_by(false), column_orders(false) {}
-  bool key_value_metadata :1;
-  bool created_by :1;
-  bool column_orders :1;
-} _FileMetaData__isset;
-
-class FileMetaData : public virtual ::apache::thrift::TBase {
- public:
-
-  FileMetaData(const FileMetaData&);
-  FileMetaData& operator=(const FileMetaData&);
-  FileMetaData() : version(0), num_rows(0), created_by() {
-  }
-
-  virtual ~FileMetaData() throw();
-  int32_t version;
-  std::vector<SchemaElement>  schema;
-  int64_t num_rows;
-  std::vector<RowGroup>  row_groups;
-  std::vector<KeyValue>  key_value_metadata;
-  std::string created_by;
-  std::vector<ColumnOrder>  column_orders;
-
-  _FileMetaData__isset __isset;
-
-  void __set_version(const int32_t val);
-
-  void __set_schema(const std::vector<SchemaElement> & val);
-
-  void __set_num_rows(const int64_t val);
-
-  void __set_row_groups(const std::vector<RowGroup> & val);
-
-  void __set_key_value_metadata(const std::vector<KeyValue> & val);
-
-  void __set_created_by(const std::string& val);
-
-  void __set_column_orders(const std::vector<ColumnOrder> & val);
-
-  bool operator == (const FileMetaData & rhs) const
-  {
-    if (!(version == rhs.version))
-      return false;
-    if (!(schema == rhs.schema))
-      return false;
-    if (!(num_rows == rhs.num_rows))
-      return false;
-    if (!(row_groups == rhs.row_groups))
-      return false;
-    if (__isset.key_value_metadata != rhs.__isset.key_value_metadata)
-      return false;
-    else if (__isset.key_value_metadata && !(key_value_metadata == rhs.key_value_metadata))
-      return false;
-    if (__isset.created_by != rhs.__isset.created_by)
-      return false;
-    else if (__isset.created_by && !(created_by == rhs.created_by))
-      return false;
-    if (__isset.column_orders != rhs.__isset.column_orders)
-      return false;
-    else if (__isset.column_orders && !(column_orders == rhs.column_orders))
-      return false;
-    return true;
-  }
-  bool operator != (const FileMetaData &rhs) const {
-    return !(*this == rhs);
-  }
-
-  bool operator < (const FileMetaData & ) const;
-
-  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
-  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
-
-  virtual void printTo(std::ostream& out) const;
-};
-
-void swap(FileMetaData &a, FileMetaData &b);
-
-std::ostream& operator<<(std::ostream& out, const FileMetaData& obj);
-
 typedef struct _AesGcmV1__isset {
-  _AesGcmV1__isset() : aad_metadata(false), iv_prefix(false) {}
-  bool aad_metadata :1;
-  bool iv_prefix :1;
+  _AesGcmV1__isset() : aad_prefix(false), aad_file_unique(false), supply_aad_prefix(false) {}
+  bool aad_prefix :1;
+  bool aad_file_unique :1;
+  bool supply_aad_prefix :1;
 } _AesGcmV1__isset;
 
 class AesGcmV1 : public virtual ::apache::thrift::TBase {
@@ -2306,28 +2292,35 @@ class AesGcmV1 : public virtual ::apache::thrift::TBase {
 
   AesGcmV1(const AesGcmV1&);
   AesGcmV1& operator=(const AesGcmV1&);
-  AesGcmV1() : aad_metadata(), iv_prefix() {
+  AesGcmV1() : aad_prefix(), aad_file_unique(), supply_aad_prefix(0) {
   }
 
   virtual ~AesGcmV1() throw();
-  std::string aad_metadata;
-  std::string iv_prefix;
+  std::string aad_prefix;
+  std::string aad_file_unique;
+  bool supply_aad_prefix;
 
   _AesGcmV1__isset __isset;
 
-  void __set_aad_metadata(const std::string& val);
+  void __set_aad_prefix(const std::string& val);
+
+  void __set_aad_file_unique(const std::string& val);
 
-  void __set_iv_prefix(const std::string& val);
+  void __set_supply_aad_prefix(const bool val);
 
   bool operator == (const AesGcmV1 & rhs) const
   {
-    if (__isset.aad_metadata != rhs.__isset.aad_metadata)
+    if (__isset.aad_prefix != rhs.__isset.aad_prefix)
+      return false;
+    else if (__isset.aad_prefix && !(aad_prefix == rhs.aad_prefix))
       return false;
-    else if (__isset.aad_metadata && !(aad_metadata == rhs.aad_metadata))
+    if (__isset.aad_file_unique != rhs.__isset.aad_file_unique)
       return false;
-    if (__isset.iv_prefix != rhs.__isset.iv_prefix)
+    else if (__isset.aad_file_unique && !(aad_file_unique == rhs.aad_file_unique))
       return false;
-    else if (__isset.iv_prefix && !(iv_prefix == rhs.iv_prefix))
+    if (__isset.supply_aad_prefix != rhs.__isset.supply_aad_prefix)
+      return false;
+    else if (__isset.supply_aad_prefix && !(supply_aad_prefix == rhs.supply_aad_prefix))
       return false;
     return true;
   }
@@ -2348,10 +2341,10 @@ void swap(AesGcmV1 &a, AesGcmV1 &b);
 std::ostream& operator<<(std::ostream& out, const AesGcmV1& obj);
 
 typedef struct _AesGcmCtrV1__isset {
-  _AesGcmCtrV1__isset() : aad_metadata(false), gcm_iv_prefix(false), ctr_iv_prefix(false) {}
-  bool aad_metadata :1;
-  bool gcm_iv_prefix :1;
-  bool ctr_iv_prefix :1;
+  _AesGcmCtrV1__isset() : aad_prefix(false), aad_file_unique(false), supply_aad_prefix(false) {}
+  bool aad_prefix :1;
+  bool aad_file_unique :1;
+  bool supply_aad_prefix :1;
 } _AesGcmCtrV1__isset;
 
 class AesGcmCtrV1 : public virtual ::apache::thrift::TBase {
@@ -2359,35 +2352,35 @@ class AesGcmCtrV1 : public virtual ::apache::thrift::TBase {
 
   AesGcmCtrV1(const AesGcmCtrV1&);
   AesGcmCtrV1& operator=(const AesGcmCtrV1&);
-  AesGcmCtrV1() : aad_metadata(), gcm_iv_prefix(), ctr_iv_prefix() {
+  AesGcmCtrV1() : aad_prefix(), aad_file_unique(), supply_aad_prefix(0) {
   }
 
   virtual ~AesGcmCtrV1() throw();
-  std::string aad_metadata;
-  std::string gcm_iv_prefix;
-  std::string ctr_iv_prefix;
+  std::string aad_prefix;
+  std::string aad_file_unique;
+  bool supply_aad_prefix;
 
   _AesGcmCtrV1__isset __isset;
 
-  void __set_aad_metadata(const std::string& val);
+  void __set_aad_prefix(const std::string& val);
 
-  void __set_gcm_iv_prefix(const std::string& val);
+  void __set_aad_file_unique(const std::string& val);
 
-  void __set_ctr_iv_prefix(const std::string& val);
+  void __set_supply_aad_prefix(const bool val);
 
   bool operator == (const AesGcmCtrV1 & rhs) const
   {
-    if (__isset.aad_metadata != rhs.__isset.aad_metadata)
+    if (__isset.aad_prefix != rhs.__isset.aad_prefix)
       return false;
-    else if (__isset.aad_metadata && !(aad_metadata == rhs.aad_metadata))
+    else if (__isset.aad_prefix && !(aad_prefix == rhs.aad_prefix))
       return false;
-    if (__isset.gcm_iv_prefix != rhs.__isset.gcm_iv_prefix)
+    if (__isset.aad_file_unique != rhs.__isset.aad_file_unique)
       return false;
-    else if (__isset.gcm_iv_prefix && !(gcm_iv_prefix == rhs.gcm_iv_prefix))
+    else if (__isset.aad_file_unique && !(aad_file_unique == rhs.aad_file_unique))
       return false;
-    if (__isset.ctr_iv_prefix != rhs.__isset.ctr_iv_prefix)
+    if (__isset.supply_aad_prefix != rhs.__isset.supply_aad_prefix)
       return false;
-    else if (__isset.ctr_iv_prefix && !(ctr_iv_prefix == rhs.ctr_iv_prefix))
+    else if (__isset.supply_aad_prefix && !(supply_aad_prefix == rhs.supply_aad_prefix))
       return false;
     return true;
   }
@@ -2459,9 +2452,105 @@ void swap(EncryptionAlgorithm &a, EncryptionAlgorithm &b);
 
 std::ostream& operator<<(std::ostream& out, const EncryptionAlgorithm& obj);
 
+typedef struct _FileMetaData__isset {
+  _FileMetaData__isset() : key_value_metadata(false), created_by(false), column_orders(false), encryption_algorithm(false), footer_signing_key_metadata(false) {}
+  bool key_value_metadata :1;
+  bool created_by :1;
+  bool column_orders :1;
+  bool encryption_algorithm :1;
+  bool footer_signing_key_metadata :1;
+} _FileMetaData__isset;
+
+class FileMetaData : public virtual ::apache::thrift::TBase {
+ public:
+
+  FileMetaData(const FileMetaData&);
+  FileMetaData& operator=(const FileMetaData&);
+  FileMetaData() : version(0), num_rows(0), created_by(), footer_signing_key_metadata() {
+  }
+
+  virtual ~FileMetaData() throw();
+  int32_t version;
+  std::vector<SchemaElement>  schema;
+  int64_t num_rows;
+  std::vector<RowGroup>  row_groups;
+  std::vector<KeyValue>  key_value_metadata;
+  std::string created_by;
+  std::vector<ColumnOrder>  column_orders;
+  EncryptionAlgorithm encryption_algorithm;
+  std::string footer_signing_key_metadata;
+
+  _FileMetaData__isset __isset;
+
+  void __set_version(const int32_t val);
+
+  void __set_schema(const std::vector<SchemaElement> & val);
+
+  void __set_num_rows(const int64_t val);
+
+  void __set_row_groups(const std::vector<RowGroup> & val);
+
+  void __set_key_value_metadata(const std::vector<KeyValue> & val);
+
+  void __set_created_by(const std::string& val);
+
+  void __set_column_orders(const std::vector<ColumnOrder> & val);
+
+  void __set_encryption_algorithm(const EncryptionAlgorithm& val);
+
+  void __set_footer_signing_key_metadata(const std::string& val);
+
+  bool operator == (const FileMetaData & rhs) const
+  {
+    if (!(version == rhs.version))
+      return false;
+    if (!(schema == rhs.schema))
+      return false;
+    if (!(num_rows == rhs.num_rows))
+      return false;
+    if (!(row_groups == rhs.row_groups))
+      return false;
+    if (__isset.key_value_metadata != rhs.__isset.key_value_metadata)
+      return false;
+    else if (__isset.key_value_metadata && !(key_value_metadata == rhs.key_value_metadata))
+      return false;
+    if (__isset.created_by != rhs.__isset.created_by)
+      return false;
+    else if (__isset.created_by && !(created_by == rhs.created_by))
+      return false;
+    if (__isset.column_orders != rhs.__isset.column_orders)
+      return false;
+    else if (__isset.column_orders && !(column_orders == rhs.column_orders))
+      return false;
+    if (__isset.encryption_algorithm != rhs.__isset.encryption_algorithm)
+      return false;
+    else if (__isset.encryption_algorithm && !(encryption_algorithm == rhs.encryption_algorithm))
+      return false;
+    if (__isset.footer_signing_key_metadata != rhs.__isset.footer_signing_key_metadata)
+      return false;
+    else if (__isset.footer_signing_key_metadata && !(footer_signing_key_metadata == rhs.footer_signing_key_metadata))
+      return false;
+    return true;
+  }
+  bool operator != (const FileMetaData &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const FileMetaData & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+  virtual void printTo(std::ostream& out) const;
+};
+
+void swap(FileMetaData &a, FileMetaData &b);
+
+std::ostream& operator<<(std::ostream& out, const FileMetaData& obj);
+
 typedef struct _FileCryptoMetaData__isset {
-  _FileCryptoMetaData__isset() : footer_key_metadata(false) {}
-  bool footer_key_metadata :1;
+  _FileCryptoMetaData__isset() : key_metadata(false) {}
+  bool key_metadata :1;
 } _FileCryptoMetaData__isset;
 
 class FileCryptoMetaData : public virtual ::apache::thrift::TBase {
@@ -2469,36 +2558,26 @@ class FileCryptoMetaData : public virtual ::apache::thrift::TBase {
 
   FileCryptoMetaData(const FileCryptoMetaData&);
   FileCryptoMetaData& operator=(const FileCryptoMetaData&);
-  FileCryptoMetaData() : encrypted_footer(0), footer_key_metadata(), footer_offset(0) {
+  FileCryptoMetaData() : key_metadata() {
   }
 
   virtual ~FileCryptoMetaData() throw();
   EncryptionAlgorithm encryption_algorithm;
-  bool encrypted_footer;
-  std::string footer_key_metadata;
-  int64_t footer_offset;
+  std::string key_metadata;
 
   _FileCryptoMetaData__isset __isset;
 
   void __set_encryption_algorithm(const EncryptionAlgorithm& val);
 
-  void __set_encrypted_footer(const bool val);
-
-  void __set_footer_key_metadata(const std::string& val);
-
-  void __set_footer_offset(const int64_t val);
+  void __set_key_metadata(const std::string& val);
 
   bool operator == (const FileCryptoMetaData & rhs) const
   {
     if (!(encryption_algorithm == rhs.encryption_algorithm))
       return false;
-    if (!(encrypted_footer == rhs.encrypted_footer))
-      return false;
-    if (__isset.footer_key_metadata != rhs.__isset.footer_key_metadata)
-      return false;
-    else if (__isset.footer_key_metadata && !(footer_key_metadata == rhs.footer_key_metadata))
+    if (__isset.key_metadata != rhs.__isset.key_metadata)
       return false;
-    if (!(footer_offset == rhs.footer_offset))
+    else if (__isset.key_metadata && !(key_metadata == rhs.key_metadata))
       return false;
     return true;
   }
diff --git a/contrib/flatbuffers b/contrib/flatbuffers
new file mode 160000
index 0000000000000000000000000000000000000000..bf9eb67ab9371755c6bcece13cadc7693bcbf264
--- /dev/null
+++ b/contrib/flatbuffers
@@ -0,0 +1 @@
+Subproject commit bf9eb67ab9371755c6bcece13cadc7693bcbf264
diff --git a/dbms/src/Processors/Formats/Impl/ArrowColumnToCHColumn.cpp b/dbms/src/Processors/Formats/Impl/ArrowColumnToCHColumn.cpp
index b7ff829922bda5ee082d989e19ed3c11dbf0312c..ed9c965a1f54c52510478aa8ddd609b4c1f89e3c 100644
--- a/dbms/src/Processors/Formats/Impl/ArrowColumnToCHColumn.cpp
+++ b/dbms/src/Processors/Formats/Impl/ArrowColumnToCHColumn.cpp
@@ -61,14 +61,14 @@ namespace DB
 
 /// Inserts numeric data right into internal column data to reduce an overhead
     template <typename NumericType, typename VectorType = ColumnVector<NumericType>>
-    static void fillColumnWithNumericData(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithNumericData(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         auto & column_data = static_cast<VectorType &>(*internal_column).getData();
         column_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            std::shared_ptr<arrow::Array> chunk = arrow_column->data()->chunk(chunk_i);
+            std::shared_ptr<arrow::Array> chunk = arrow_column->chunk(chunk_i);
             /// buffers[0] is a null bitmap and buffers[1] are actual values
             std::shared_ptr<arrow::Buffer> buffer = chunk->data()->buffers[1];
 
@@ -80,15 +80,15 @@ namespace DB
 /// Inserts chars and offsets right into internal column data to reduce an overhead.
 /// Internal offsets are shifted by one to the right in comparison with Arrow ones. So the last offset should map to the end of all chars.
 /// Also internal strings are null terminated.
-    static void fillColumnWithStringData(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithStringData(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         PaddedPODArray<UInt8> & column_chars_t = assert_cast<ColumnString &>(*internal_column).getChars();
         PaddedPODArray<UInt64> & column_offsets = assert_cast<ColumnString &>(*internal_column).getOffsets();
 
         size_t chars_t_size = 0;
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            arrow::BinaryArray & chunk = static_cast<arrow::BinaryArray &>(*(arrow_column->data()->chunk(chunk_i)));
+            arrow::BinaryArray & chunk = static_cast<arrow::BinaryArray &>(*(arrow_column->chunk(chunk_i)));
             const size_t chunk_length = chunk.length();
 
             chars_t_size += chunk.value_offset(chunk_length - 1) + chunk.value_length(chunk_length - 1);
@@ -98,9 +98,9 @@ namespace DB
         column_chars_t.reserve(chars_t_size);
         column_offsets.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            arrow::BinaryArray & chunk = static_cast<arrow::BinaryArray &>(*(arrow_column->data()->chunk(chunk_i)));
+            arrow::BinaryArray & chunk = static_cast<arrow::BinaryArray &>(*(arrow_column->chunk(chunk_i)));
             std::shared_ptr<arrow::Buffer> buffer = chunk.value_data();
             const size_t chunk_length = chunk.length();
 
@@ -118,14 +118,14 @@ namespace DB
         }
     }
 
-    static void fillColumnWithBooleanData(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithBooleanData(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         auto & column_data = assert_cast<ColumnVector<UInt8> &>(*internal_column).getData();
         column_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            arrow::BooleanArray & chunk = static_cast<arrow::BooleanArray &>(*(arrow_column->data()->chunk(chunk_i)));
+            arrow::BooleanArray & chunk = static_cast<arrow::BooleanArray &>(*(arrow_column->chunk(chunk_i)));
             /// buffers[0] is a null bitmap and buffers[1] are actual values
             std::shared_ptr<arrow::Buffer> buffer = chunk.data()->buffers[1];
 
@@ -135,14 +135,14 @@ namespace DB
     }
 
 /// Arrow stores Parquet::DATE in Int32, while ClickHouse stores Date in UInt16. Therefore, it should be checked before saving
-    static void fillColumnWithDate32Data(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithDate32Data(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         PaddedPODArray<UInt16> & column_data = assert_cast<ColumnVector<UInt16> &>(*internal_column).getData();
         column_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            arrow::Date32Array & chunk = static_cast<arrow::Date32Array &>(*(arrow_column->data()->chunk(chunk_i)));
+            arrow::Date32Array & chunk = static_cast<arrow::Date32Array &>(*(arrow_column->chunk(chunk_i)));
 
             for (size_t value_i = 0, length = static_cast<size_t>(chunk.length()); value_i < length; ++value_i)
             {
@@ -150,7 +150,7 @@ namespace DB
                 if (days_num > DATE_LUT_MAX_DAY_NUM)
                 {
                     // TODO: will it rollback correctly?
-                    throw Exception{"Input value " + std::to_string(days_num) + " of a column \"" + arrow_column->name()
+                    throw Exception{"Input value " + std::to_string(days_num) + " of a column \"" + internal_column->getName()
                                     + "\" is greater than "
                                       "max allowed Date value, which is "
                                     + std::to_string(DATE_LUT_MAX_DAY_NUM),
@@ -163,14 +163,14 @@ namespace DB
     }
 
 /// Arrow stores Parquet::DATETIME in Int64, while ClickHouse stores DateTime in UInt32. Therefore, it should be checked before saving
-    static void fillColumnWithDate64Data(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithDate64Data(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         auto & column_data = assert_cast<ColumnVector<UInt32> &>(*internal_column).getData();
         column_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            auto & chunk = static_cast<arrow::Date64Array &>(*(arrow_column->data()->chunk(chunk_i)));
+            auto & chunk = static_cast<arrow::Date64Array &>(*(arrow_column->chunk(chunk_i)));
             for (size_t value_i = 0, length = static_cast<size_t>(chunk.length()); value_i < length; ++value_i)
             {
                 auto timestamp = static_cast<UInt32>(chunk.Value(value_i) / 1000); // Always? in ms
@@ -179,14 +179,14 @@ namespace DB
         }
     }
 
-    static void fillColumnWithTimestampData(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithTimestampData(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         auto & column_data = assert_cast<ColumnVector<UInt32> &>(*internal_column).getData();
         column_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            auto & chunk = static_cast<arrow::TimestampArray &>(*(arrow_column->data()->chunk(chunk_i)));
+            auto & chunk = static_cast<arrow::TimestampArray &>(*(arrow_column->chunk(chunk_i)));
             const auto & type = static_cast<const ::arrow::TimestampType &>(*chunk.type());
 
             UInt32 divide = 1;
@@ -215,15 +215,15 @@ namespace DB
         }
     }
 
-    static void fillColumnWithDecimalData(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & internal_column)
+    static void fillColumnWithDecimalData(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & internal_column)
     {
         auto & column = assert_cast<ColumnDecimal<Decimal128> &>(*internal_column);
         auto & column_data = column.getData();
         column_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->data()->num_chunks()); chunk_i < num_chunks; ++chunk_i)
+        for (size_t chunk_i = 0, num_chunks = static_cast<size_t>(arrow_column->num_chunks()); chunk_i < num_chunks; ++chunk_i)
         {
-            auto & chunk = static_cast<arrow::DecimalArray &>(*(arrow_column->data()->chunk(chunk_i)));
+            auto & chunk = static_cast<arrow::DecimalArray &>(*(arrow_column->chunk(chunk_i)));
             for (size_t value_i = 0, length = static_cast<size_t>(chunk.length()); value_i < length; ++value_i)
             {
                 column_data.emplace_back(chunk.IsNull(value_i) ? Decimal128(0) : *reinterpret_cast<const Decimal128 *>(chunk.Value(value_i))); // TODO: copy column
@@ -232,14 +232,14 @@ namespace DB
     }
 
 /// Creates a null bytemap from arrow's null bitmap
-    static void fillByteMapFromArrowColumn(std::shared_ptr<arrow::Column> & arrow_column, MutableColumnPtr & bytemap)
+    static void fillByteMapFromArrowColumn(std::shared_ptr<arrow::ChunkedArray> & arrow_column, MutableColumnPtr & bytemap)
     {
         PaddedPODArray<UInt8> & bytemap_data = assert_cast<ColumnVector<UInt8> &>(*bytemap).getData();
         bytemap_data.reserve(arrow_column->length());
 
-        for (size_t chunk_i = 0; chunk_i != static_cast<size_t>(arrow_column->data()->num_chunks()); ++chunk_i)
+        for (size_t chunk_i = 0; chunk_i != static_cast<size_t>(arrow_column->num_chunks()); ++chunk_i)
         {
-            std::shared_ptr<arrow::Array> chunk = arrow_column->data()->chunk(chunk_i);
+            std::shared_ptr<arrow::Array> chunk = arrow_column->chunk(chunk_i);
 
             for (size_t value_i = 0; value_i != static_cast<size_t>(chunk->length()); ++value_i)
                 bytemap_data.emplace_back(chunk->IsNull(value_i));
@@ -255,7 +255,7 @@ namespace DB
 
         columns_list.reserve(header.rows());
 
-        using NameToColumnPtr = std::unordered_map<std::string, std::shared_ptr<arrow::Column>>;
+        using NameToColumnPtr = std::unordered_map<std::string, std::shared_ptr<arrow::ChunkedArray>>;
         if (!read_status.ok())
             throw Exception{"Error while reading " + format_name + " data: " + read_status.ToString(),
                             ErrorCodes::CANNOT_READ_ALL_DATA};
@@ -270,10 +270,10 @@ namespace DB
         ++row_group_current;
 
         NameToColumnPtr name_to_column_ptr;
-        for (size_t i = 0, num_columns = static_cast<size_t>(table->num_columns()); i < num_columns; ++i)
+        for (const auto& column_name : table->ColumnNames())
         {
-            std::shared_ptr<arrow::Column> arrow_column = table->column(i);
-            name_to_column_ptr[arrow_column->name()] = arrow_column;
+            std::shared_ptr<arrow::ChunkedArray> arrow_column = table->GetColumnByName(column_name);
+            name_to_column_ptr[column_name] = arrow_column;
         }
 
         for (size_t column_i = 0, columns = header.columns(); column_i < columns; ++column_i)
@@ -285,7 +285,7 @@ namespace DB
                 throw Exception{"Column \"" + header_column.name + "\" is not presented in input data",
                                 ErrorCodes::THERE_IS_NO_COLUMN};
 
-            std::shared_ptr<arrow::Column> arrow_column = name_to_column_ptr[header_column.name];
+            std::shared_ptr<arrow::ChunkedArray> arrow_column = name_to_column_ptr[header_column.name];
             arrow::Type::type arrow_type = arrow_column->type()->id();
 
             // TODO: check if a column is const?
@@ -313,7 +313,7 @@ namespace DB
             }
             else
             {
-                throw Exception{"The type \"" + arrow_column->type()->name() + "\" of an input column \"" + arrow_column->name()
+                throw Exception{"The type \"" + arrow_column->type()->name() + "\" of an input column \"" + header_column.name
                         + "\" is not supported for conversion from a " + format_name + " data format",
                         ErrorCodes::CANNOT_CONVERT_TYPE};
             }
@@ -374,7 +374,7 @@ namespace DB
                     throw Exception
                     {
                             "Unsupported " + format_name + " type \"" + arrow_column->type()->name() + "\" of an input column \""
-                            + arrow_column->name() + "\"",
+                            + header_column.name + "\"",
                             ErrorCodes::UNKNOWN_TYPE
                     };
             }
diff --git a/dbms/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp b/dbms/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
index 3c9b50c2c75f15d0669d4273b978efb42b54e724..9e0d76acd1f7e5867e1b64c24dfa51c875150256 100644
--- a/dbms/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ParquetBlockInputFormat.cpp
@@ -45,9 +45,11 @@ namespace DB
 
             buffer = std::make_unique<arrow::Buffer>(file_data);
             // TODO: maybe use parquet::RandomAccessSource?
-            auto reader = parquet::ParquetFileReader::Open(std::make_shared<::arrow::io::BufferReader>(*buffer));
-            file_reader = std::make_unique<parquet::arrow::FileReader>(::arrow::default_memory_pool(),
-                                                                       std::move(reader));
+            auto status = parquet::arrow::FileReader::Make(
+                    ::arrow::default_memory_pool(),
+                    parquet::ParquetFileReader::Open(std::make_shared<::arrow::io::BufferReader>(*buffer)),
+                    &file_reader);
+
             row_group_total = file_reader->num_row_groups();
             row_group_current = 0;
         }
diff --git a/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp b/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
index 855036e05ffe5ebfd13452a06990764e9f023865..161b07a59fadeff1ec797227e6e2b69c4034e23f 100644
--- a/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
+++ b/dbms/src/Processors/Formats/Impl/ParquetBlockOutputFormat.cpp
@@ -21,9 +21,10 @@
 #include <arrow/api.h>
 #include <arrow/io/api.h>
 #include <arrow/util/decimal.h>
+#include <arrow/util/memory.h>
 #include <parquet/arrow/writer.h>
 #include <parquet/exception.h>
-#include <parquet/util/memory.h>
+#include <parquet/deprecated_io.h>
 
 
 namespace DB
@@ -238,22 +239,39 @@ static const PaddedPODArray<UInt8> * extractNullBytemapPtr(ColumnPtr column)
 }
 
 
-class OstreamOutputStream : public parquet::OutputStream
+class OstreamOutputStream : public arrow::io::OutputStream
 {
 public:
-    explicit OstreamOutputStream(WriteBuffer & ostr_) : ostr(ostr_) {}
-    virtual ~OstreamOutputStream() {}
-    virtual void Close() {}
-    virtual int64_t Tell() { return total_length; }
-    virtual void Write(const uint8_t * data, int64_t length)
+    explicit OstreamOutputStream(WriteBuffer & ostr_) : ostr(ostr_) { is_open = true; }
+    ~OstreamOutputStream() override {}
+
+    // FileInterface
+    ::arrow::Status Close() override
+    {
+        is_open = false;
+        return ::arrow::Status::OK();
+    }
+
+    ::arrow::Status Tell(int64_t* position) const override
+    {
+        *position = total_length;
+        return ::arrow::Status::OK();
+    }
+
+    bool closed() const override { return !is_open; }
+
+    // Writable
+    ::arrow::Status Write(const void* data, int64_t length) override
     {
         ostr.write(reinterpret_cast<const char *>(data), length);
         total_length += length;
+        return ::arrow::Status::OK();
     }
 
 private:
     WriteBuffer & ostr;
     int64_t total_length = 0;
+    bool is_open = false;
 
     PARQUET_DISALLOW_COPY_AND_ASSIGN(OstreamOutputStream);
 };
@@ -396,7 +414,6 @@ void ParquetBlockOutputFormat::consume(Chunk chunk)
             arrow::default_memory_pool(),
             sink,
             props, /*parquet::default_writer_properties(),*/
-            parquet::arrow::default_arrow_writer_properties(),
             &file_writer);
         if (!status.ok())
             throw Exception{"Error while opening a table: " + status.ToString(), ErrorCodes::UNKNOWN_EXCEPTION};
diff --git a/dbms/tests/queries/0_stateless/00900_parquet_load.reference b/dbms/tests/queries/0_stateless/00900_parquet_load.reference
index 4e3977e0e967e495eed8f71beb647dd91eba3037..23627bf0f682b84cda16417b20d90d4e1ed9a7d8 100644
--- a/dbms/tests/queries/0_stateless/00900_parquet_load.reference
+++ b/dbms/tests/queries/0_stateless/00900_parquet_load.reference
@@ -171,19 +171,19 @@ Code: 33. DB::Ex---tion: Error while reading Parquet data: IOError: Arrow error:
 Code: 8. DB::Ex---tion: Column "element" is not presented in input data
 
 === Try load data from nested_maps.snappy.parquet
-Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Currently only nesting with Lists is supported.
+Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Reading lists of structs from Parquet files not yet supported: key_value: list<key_value: struct<key: string not null, value: struct<key_value: list<key_value: struct<key: int32 not null, value: bool not null> not null> not null>> not null> not null
 
 === Try load data from nonnullable.impala.parquet
-Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Currently only nesting with Lists is supported.
+Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Reading lists of structs from Parquet files not yet supported: map: list<map: struct<key: string not null, value: int32 not null> not null> not null
 
 === Try load data from nullable.impala.parquet
-Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Currently only nesting with Lists is supported.
+Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Reading lists of structs from Parquet files not yet supported: map: list<map: struct<key: string not null, value: int32> not null> not null
 
 === Try load data from nulls.snappy.parquet
 Code: 8. DB::Ex---tion: Column "b_c_int" is not presented in input data
 
 === Try load data from repeated_no_annotation.parquet
-Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Currently only nesting with Lists is supported.
+Code: 33. DB::Ex---tion: Error while reading Parquet data: NotImplemented: Reading lists of structs from Parquet files not yet supported: phone: list<phone: struct<number: int64 not null, kind: string> not null> not null
 
 === Try load data from userdata1.parquet
 1454486129	1	Amanda	Jordan	ajordan0@com.com	Female	1.197.201.2	6759521864920116	Indonesia	3/8/1971	49756.53	Internal Auditor	1E+02