diff --git a/contrib/arrow-cmake/CMakeLists.txt b/contrib/arrow-cmake/CMakeLists.txt
index ccf3021d143..335106cc7ca 100644
--- a/contrib/arrow-cmake/CMakeLists.txt
+++ b/contrib/arrow-cmake/CMakeLists.txt
@@ -102,10 +102,16 @@ add_subdirectory(${FLATBUFFERS_SRC_DIR} "${FLATBUFFERS_BINARY_DIR}")
 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(ARROW_GENERATED_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/arrow_gen_headers)
+set(FLATBUFFERS_COMPILED_OUT_DIR ${ARROW_GENERATED_INCLUDE_DIR}/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_OUTPUT_FILES
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/File_generated.h"
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/Message_generated.h"
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/feather_generated.h"
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/Schema_generated.h"
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/SparseTensor_generated.h"
+        "${FLATBUFFERS_COMPILED_OUT_DIR}/Tensor_generated.h")
 
 set(FBS_SRC
         ${ARROW_FORMAT_SRC_DIR}/Message.fbs
@@ -137,7 +143,7 @@ add_custom_command(OUTPUT ${FBS_OUTPUT_FILES}
 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. 
+# 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.
@@ -231,12 +237,10 @@ set(ARROW_SRCS
 
         ${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
@@ -249,8 +253,6 @@ set(ARROW_SRCS
 
         ${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
@@ -268,7 +270,6 @@ set(ARROW_SRCS
         ${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
@@ -356,6 +357,8 @@ target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ORC_BUILD_INCLUDE_D
 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})
+target_include_directories(${ARROW_LIBRARY} PRIVATE SYSTEM ${ARROW_GENERATED_INCLUDE_DIR})
+
 # === parquet
 
 set(LIBRARY_DIR ${ClickHouse_SOURCE_DIR}/contrib/arrow/cpp/src/parquet)
diff --git a/contrib/arrow-cmake/cpp/src/arrow/ipc/File_generated.h b/contrib/arrow-cmake/cpp/src/arrow/ipc/File_generated.h
deleted file mode 100644
index 37e2f9c7ea4..00000000000
--- a/contrib/arrow-cmake/cpp/src/arrow/ipc/File_generated.h
+++ /dev/null
@@ -1,181 +0,0 @@
-// 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
deleted file mode 100644
index 734ce9892c2..00000000000
--- a/contrib/arrow-cmake/cpp/src/arrow/ipc/Message_generated.h
+++ /dev/null
@@ -1,508 +0,0 @@
-// 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
deleted file mode 100644
index b4f0e7ea234..00000000000
--- a/contrib/arrow-cmake/cpp/src/arrow/ipc/Schema_generated.h
+++ /dev/null
@@ -1,2045 +0,0 @@
-// 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
deleted file mode 100644
index 94974c58638..00000000000
--- a/contrib/arrow-cmake/cpp/src/arrow/ipc/SparseTensor_generated.h
+++ /dev/null
@@ -1,644 +0,0 @@
-// 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
deleted file mode 100644
index 8483eb116b3..00000000000
--- a/contrib/arrow-cmake/cpp/src/arrow/ipc/Tensor_generated.h
+++ /dev/null
@@ -1,377 +0,0 @@
-// 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
deleted file mode 100644
index 538d3359915..00000000000
--- a/contrib/arrow-cmake/cpp/src/arrow/ipc/feather_generated.h
+++ /dev/null
@@ -1,839 +0,0 @@
-// 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/dbms/programs/server/users.xml b/dbms/programs/server/users.xml
index 9755c29d480..0058ee51184 100644
--- a/dbms/programs/server/users.xml
+++ b/dbms/programs/server/users.xml
@@ -84,25 +84,17 @@
             <!-- Quota for user. -->
             <quota>default</quota>
 
-            <!-- For testing the table filters -->
-            <databases>
+            <!-- Example of row level security policy. -->
+            <!-- <databases>
                 <test>
-                    <!-- Simple expression filter -->
                     <filtered_table1>
                         <filter>a = 1</filter>
                     </filtered_table1>
-
-                    <!-- Complex expression filter -->
                     <filtered_table2>
                         <filter>a + b &lt; 1 or c - d &gt; 5</filter>
                     </filtered_table2>
-
-                    <!-- Filter with ALIAS column -->
-                    <filtered_table3>
-                        <filter>c = 1</filter>
-                    </filtered_table3>
                 </test>
-            </databases>
+            </databases> -->
         </default>
 
         <!-- Example of user with readonly access. -->
diff --git a/dbms/src/Access/AccessControlManager.cpp b/dbms/src/Access/AccessControlManager.cpp
index 1f1a57816a8..249dc54fb09 100644
--- a/dbms/src/Access/AccessControlManager.cpp
+++ b/dbms/src/Access/AccessControlManager.cpp
@@ -3,6 +3,7 @@
 #include <Access/MemoryAccessStorage.h>
 #include <Access/UsersConfigAccessStorage.h>
 #include <Access/QuotaContextFactory.h>
+#include <Access/RowPolicyContextFactory.h>
 
 
 namespace DB
@@ -21,7 +22,8 @@ namespace
 
 AccessControlManager::AccessControlManager()
     : MultipleAccessStorage(createStorages()),
-      quota_context_factory(std::make_unique<QuotaContextFactory>(*this))
+      quota_context_factory(std::make_unique<QuotaContextFactory>(*this)),
+      row_policy_context_factory(std::make_unique<RowPolicyContextFactory>(*this))
 {
 }
 
@@ -49,4 +51,11 @@ std::vector<QuotaUsageInfo> AccessControlManager::getQuotaUsageInfo() const
 {
     return quota_context_factory->getUsageInfo();
 }
+
+
+std::shared_ptr<RowPolicyContext> AccessControlManager::getRowPolicyContext(const String & user_name) const
+{
+    return row_policy_context_factory->createContext(user_name);
+}
+
 }
diff --git a/dbms/src/Access/AccessControlManager.h b/dbms/src/Access/AccessControlManager.h
index 2133717d676..9658dc7161d 100644
--- a/dbms/src/Access/AccessControlManager.h
+++ b/dbms/src/Access/AccessControlManager.h
@@ -22,6 +22,8 @@ namespace DB
 class QuotaContext;
 class QuotaContextFactory;
 struct QuotaUsageInfo;
+class RowPolicyContext;
+class RowPolicyContextFactory;
 
 
 /// Manages access control entities.
@@ -38,8 +40,11 @@ public:
 
     std::vector<QuotaUsageInfo> getQuotaUsageInfo() const;
 
+    std::shared_ptr<RowPolicyContext> getRowPolicyContext(const String & user_name) const;
+
 private:
     std::unique_ptr<QuotaContextFactory> quota_context_factory;
+    std::unique_ptr<RowPolicyContextFactory> row_policy_context_factory;
 };
 
 }
diff --git a/dbms/src/Access/IAccessEntity.cpp b/dbms/src/Access/IAccessEntity.cpp
index 6a2f928ae9e..9b203a74148 100644
--- a/dbms/src/Access/IAccessEntity.cpp
+++ b/dbms/src/Access/IAccessEntity.cpp
@@ -1,5 +1,6 @@
 #include <Access/IAccessEntity.h>
 #include <Access/Quota.h>
+#include <Access/RowPolicy.h>
 #include <common/demangle.h>
 
 
@@ -9,6 +10,8 @@ String IAccessEntity::getTypeName(std::type_index type)
 {
     if (type == typeid(Quota))
         return "Quota";
+    if (type == typeid(RowPolicy))
+        return "Row policy";
     return demangle(type.name());
 }
 
diff --git a/dbms/src/Access/RowPolicy.cpp b/dbms/src/Access/RowPolicy.cpp
new file mode 100644
index 00000000000..391303e46a2
--- /dev/null
+++ b/dbms/src/Access/RowPolicy.cpp
@@ -0,0 +1,111 @@
+#include <Access/RowPolicy.h>
+#include <Interpreters/Context.h>
+#include <Common/quoteString.h>
+#include <boost/range/algorithm/equal.hpp>
+
+
+namespace DB
+{
+namespace
+{
+    void generateFullNameImpl(const String & database_, const String & table_name_, const String & policy_name_, String & full_name_)
+    {
+        full_name_.clear();
+        full_name_.reserve(database_.length() + table_name_.length() + policy_name_.length() + 6);
+        full_name_ += backQuoteIfNeed(policy_name_);
+        full_name_ += " ON ";
+        if (!database_.empty())
+        {
+            full_name_ += backQuoteIfNeed(database_);
+            full_name_ += '.';
+        }
+        full_name_ += backQuoteIfNeed(table_name_);
+    }
+}
+
+
+String RowPolicy::FullNameParts::getFullName() const
+{
+    String full_name;
+    generateFullNameImpl(database, table_name, policy_name, full_name);
+    return full_name;
+}
+
+
+String RowPolicy::FullNameParts::getFullName(const Context & context) const
+{
+    String full_name;
+    generateFullNameImpl(database.empty() ? context.getCurrentDatabase() : database, table_name, policy_name, full_name);
+    return full_name;
+}
+
+
+void RowPolicy::setDatabase(const String & database_)
+{
+    database = database_;
+    generateFullNameImpl(database, table_name, policy_name, full_name);
+}
+
+
+void RowPolicy::setTableName(const String & table_name_)
+{
+    table_name = table_name_;
+    generateFullNameImpl(database, table_name, policy_name, full_name);
+}
+
+
+void RowPolicy::setName(const String & policy_name_)
+{
+    policy_name = policy_name_;
+    generateFullNameImpl(database, table_name, policy_name, full_name);
+}
+
+
+void RowPolicy::setFullName(const String & database_, const String & table_name_, const String & policy_name_)
+{
+    database = database_;
+    table_name = table_name_;
+    policy_name = policy_name_;
+    generateFullNameImpl(database, table_name, policy_name, full_name);
+}
+
+
+bool RowPolicy::equal(const IAccessEntity & other) const
+{
+    if (!IAccessEntity::equal(other))
+        return false;
+    const auto & other_policy = typeid_cast<const RowPolicy &>(other);
+    return (database == other_policy.database) && (table_name == other_policy.table_name) && (policy_name == other_policy.policy_name)
+        && boost::range::equal(conditions, other_policy.conditions) && restrictive == other_policy.restrictive
+        && (roles == other_policy.roles) && (all_roles == other_policy.all_roles) && (except_roles == other_policy.except_roles);
+}
+
+
+const char * RowPolicy::conditionIndexToString(ConditionIndex index)
+{
+    switch (index)
+    {
+        case SELECT_FILTER: return "SELECT_FILTER";
+        case INSERT_CHECK: return "INSERT_CHECK";
+        case UPDATE_FILTER: return "UPDATE_FILTER";
+        case UPDATE_CHECK: return "UPDATE_CHECK";
+        case DELETE_FILTER: return "DELETE_FILTER";
+    }
+    __builtin_unreachable();
+}
+
+
+const char * RowPolicy::conditionIndexToColumnName(ConditionIndex index)
+{
+    switch (index)
+    {
+        case SELECT_FILTER: return "select_filter";
+        case INSERT_CHECK: return "insert_check";
+        case UPDATE_FILTER: return "update_filter";
+        case UPDATE_CHECK: return "update_check";
+        case DELETE_FILTER: return "delete_filter";
+    }
+    __builtin_unreachable();
+}
+
+}
diff --git a/dbms/src/Access/RowPolicy.h b/dbms/src/Access/RowPolicy.h
new file mode 100644
index 00000000000..22681b8875e
--- /dev/null
+++ b/dbms/src/Access/RowPolicy.h
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <Access/IAccessEntity.h>
+
+
+namespace DB
+{
+class Context;
+
+
+/** Represents a row level security policy for a table.
+  */
+struct RowPolicy : public IAccessEntity
+{
+    void setDatabase(const String & database_);
+    void setTableName(const String & table_name_);
+    void setName(const String & policy_name_) override;
+    void setFullName(const String & database_, const String & table_name_, const String & policy_name_);
+
+    String getDatabase() const { return database; }
+    String getTableName() const { return table_name; }
+    String getName() const override { return policy_name; }
+
+    struct FullNameParts
+    {
+        String database;
+        String table_name;
+        String policy_name;
+        String getFullName() const;
+        String getFullName(const Context & context) const;
+    };
+
+    /// Filter is a SQL conditional expression used to figure out which rows should be visible
+    /// for user or available for modification. If the expression returns NULL or false for some rows
+    /// those rows are silently suppressed.
+    /// Check is a SQL condition expression used to check whether a row can be written into
+    /// the table. If the expression returns NULL or false an exception is thrown.
+    /// If a conditional expression here is empty it means no filtering is applied.
+    enum ConditionIndex
+    {
+        SELECT_FILTER,
+        INSERT_CHECK,
+        UPDATE_FILTER,
+        UPDATE_CHECK,
+        DELETE_FILTER,
+    };
+    static constexpr size_t MAX_CONDITION_INDEX = 5;
+    static const char * conditionIndexToString(ConditionIndex index);
+    static const char * conditionIndexToColumnName(ConditionIndex index);
+
+    String conditions[MAX_CONDITION_INDEX];
+
+    /// Sets that the policy is permissive.
+    /// A row is only accessible if at least one of the permissive policies passes,
+    /// in addition to all the restrictive policies.
+    void setPermissive(bool permissive_ = true) { setRestrictive(!permissive_); }
+    bool isPermissive() const { return !isRestrictive(); }
+
+    /// Sets that the policy is restrictive.
+    /// A row is only accessible if at least one of the permissive policies passes,
+    /// in addition to all the restrictive policies.
+    void setRestrictive(bool restrictive_ = true) { restrictive = restrictive_; }
+    bool isRestrictive() const { return restrictive; }
+
+    bool equal(const IAccessEntity & other) const override;
+    std::shared_ptr<IAccessEntity> clone() const override { return cloneImpl<RowPolicy>(); }
+
+    /// Which roles or users should use this quota.
+    Strings roles;
+    bool all_roles = false;
+    Strings except_roles;
+
+private:
+    String database;
+    String table_name;
+    String policy_name;
+    bool restrictive = false;
+};
+
+using RowPolicyPtr = std::shared_ptr<const RowPolicy>;
+}
diff --git a/dbms/src/Access/RowPolicyContext.cpp b/dbms/src/Access/RowPolicyContext.cpp
new file mode 100644
index 00000000000..cb24d0af01b
--- /dev/null
+++ b/dbms/src/Access/RowPolicyContext.cpp
@@ -0,0 +1,59 @@
+#include <Access/RowPolicyContext.h>
+#include <boost/range/adaptor/map.hpp>
+#include <boost/range/algorithm/copy.hpp>
+
+
+namespace DB
+{
+size_t RowPolicyContext::Hash::operator()(const DatabaseAndTableNameRef & database_and_table_name) const
+{
+    return std::hash<StringRef>{}(database_and_table_name.first) - std::hash<StringRef>{}(database_and_table_name.second);
+}
+
+
+RowPolicyContext::RowPolicyContext()
+    : atomic_map_of_mixed_conditions(std::make_shared<MapOfMixedConditions>())
+{
+}
+
+
+RowPolicyContext::~RowPolicyContext() = default;
+
+
+RowPolicyContext::RowPolicyContext(const String & user_name_)
+    : user_name(user_name_)
+{}
+
+
+ASTPtr RowPolicyContext::getCondition(const String & database, const String & table_name, ConditionIndex index) const
+{
+    /// We don't lock `mutex` here.
+    auto map_of_mixed_conditions = std::atomic_load(&atomic_map_of_mixed_conditions);
+    auto it = map_of_mixed_conditions->find({database, table_name});
+    if (it == map_of_mixed_conditions->end())
+        return {};
+    return it->second.mixed_conditions[index];
+}
+
+
+std::vector<UUID> RowPolicyContext::getCurrentPolicyIDs() const
+{
+    /// We don't lock `mutex` here.
+    auto map_of_mixed_conditions = std::atomic_load(&atomic_map_of_mixed_conditions);
+    std::vector<UUID> policy_ids;
+    for (const auto & mixed_conditions : *map_of_mixed_conditions | boost::adaptors::map_values)
+        boost::range::copy(mixed_conditions.policy_ids, std::back_inserter(policy_ids));
+    return policy_ids;
+}
+
+
+std::vector<UUID> RowPolicyContext::getCurrentPolicyIDs(const String & database, const String & table_name) const
+{
+    /// We don't lock `mutex` here.
+    auto map_of_mixed_conditions = std::atomic_load(&atomic_map_of_mixed_conditions);
+    auto it = map_of_mixed_conditions->find({database, table_name});
+    if (it == map_of_mixed_conditions->end())
+        return {};
+    return it->second.policy_ids;
+}
+}
diff --git a/dbms/src/Access/RowPolicyContext.h b/dbms/src/Access/RowPolicyContext.h
new file mode 100644
index 00000000000..776808f74d7
--- /dev/null
+++ b/dbms/src/Access/RowPolicyContext.h
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <Access/RowPolicy.h>
+#include <Core/Types.h>
+#include <Core/UUID.h>
+#include <common/StringRef.h>
+#include <memory>
+#include <unordered_map>
+
+
+namespace DB
+{
+class IAST;
+using ASTPtr = std::shared_ptr<IAST>;
+
+
+/// Provides fast access to row policies' conditions for a specific user and tables.
+class RowPolicyContext
+{
+public:
+    /// Default constructor makes a row policy usage context which restricts nothing.
+    RowPolicyContext();
+
+    ~RowPolicyContext();
+
+    using ConditionIndex = RowPolicy::ConditionIndex;
+
+    /// Returns prepared filter for a specific table and operations.
+    /// The function can return nullptr, that means there is no filters applied.
+    /// The returned filter can be a combination of the filters defined by multiple row policies.
+    ASTPtr getCondition(const String & database, const String & table_name, ConditionIndex index) const;
+
+    /// Returns IDs of all the policies used by the current user.
+    std::vector<UUID> getCurrentPolicyIDs() const;
+
+    /// Returns IDs of the policies used by a concrete table.
+    std::vector<UUID> getCurrentPolicyIDs(const String & database, const String & table_name) const;
+
+private:
+    friend class RowPolicyContextFactory;
+    friend struct ext::shared_ptr_helper<RowPolicyContext>;
+    RowPolicyContext(const String & user_name_); /// RowPolicyContext should be created by RowPolicyContextFactory.
+
+    using DatabaseAndTableName = std::pair<String, String>;
+    using DatabaseAndTableNameRef = std::pair<StringRef, StringRef>;
+    struct Hash
+    {
+        size_t operator()(const DatabaseAndTableNameRef & database_and_table_name) const;
+    };
+    static constexpr size_t MAX_CONDITION_INDEX = RowPolicy::MAX_CONDITION_INDEX;
+    using ParsedConditions = std::array<ASTPtr, MAX_CONDITION_INDEX>;
+    struct MixedConditions
+    {
+        std::unique_ptr<DatabaseAndTableName> database_and_table_name_keeper;
+        ParsedConditions mixed_conditions;
+        std::vector<UUID> policy_ids;
+    };
+    using MapOfMixedConditions = std::unordered_map<DatabaseAndTableNameRef, MixedConditions, Hash>;
+
+    const String user_name;
+    std::shared_ptr<const MapOfMixedConditions> atomic_map_of_mixed_conditions; /// Changed atomically, not protected by `mutex`.
+};
+
+
+using RowPolicyContextPtr = std::shared_ptr<RowPolicyContext>;
+}
diff --git a/dbms/src/Access/RowPolicyContextFactory.cpp b/dbms/src/Access/RowPolicyContextFactory.cpp
new file mode 100644
index 00000000000..e458f06ca94
--- /dev/null
+++ b/dbms/src/Access/RowPolicyContextFactory.cpp
@@ -0,0 +1,314 @@
+#include <Access/RowPolicyContextFactory.h>
+#include <Access/RowPolicyContext.h>
+#include <Access/AccessControlManager.h>
+#include <Parsers/ASTLiteral.h>
+#include <Parsers/ASTFunction.h>
+#include <Parsers/ExpressionListParsers.h>
+#include <Parsers/parseQuery.h>
+#include <Common/Exception.h>
+#include <Common/quoteString.h>
+#include <ext/range.h>
+#include <boost/range/algorithm/copy.hpp>
+#include <boost/range/algorithm_ext/erase.hpp>
+
+
+namespace DB
+{
+namespace
+{
+    bool tryGetLiteralBool(const IAST & ast, bool & value)
+    {
+        try
+        {
+            if (const ASTLiteral * literal = ast.as<ASTLiteral>())
+            {
+                value = !literal->value.isNull() && applyVisitor(FieldVisitorConvertToNumber<bool>(), literal->value);
+                return true;
+            }
+            return false;
+        }
+        catch (...)
+        {
+            return false;
+        }
+    }
+
+    ASTPtr applyFunctionAND(ASTs arguments)
+    {
+        bool const_arguments = true;
+        boost::range::remove_erase_if(arguments, [&](const ASTPtr & argument) -> bool
+        {
+            bool b;
+            if (!tryGetLiteralBool(*argument, b))
+                return false;
+            const_arguments &= b;
+            return true;
+        });
+
+        if (!const_arguments)
+            return std::make_shared<ASTLiteral>(Field{UInt8(0)});
+        if (arguments.empty())
+            return std::make_shared<ASTLiteral>(Field{UInt8(1)});
+        if (arguments.size() == 1)
+            return arguments[0];
+
+        auto function = std::make_shared<ASTFunction>();
+        auto exp_list = std::make_shared<ASTExpressionList>();
+        function->name = "and";
+        function->arguments = exp_list;
+        function->children.push_back(exp_list);
+        exp_list->children = std::move(arguments);
+        return function;
+    }
+
+
+    ASTPtr applyFunctionOR(ASTs arguments)
+    {
+        bool const_arguments = false;
+        boost::range::remove_erase_if(arguments, [&](const ASTPtr & argument) -> bool
+        {
+            bool b;
+            if (!tryGetLiteralBool(*argument, b))
+                return false;
+            const_arguments |= b;
+            return true;
+        });
+
+        if (const_arguments)
+            return std::make_shared<ASTLiteral>(Field{UInt8(1)});
+        if (arguments.empty())
+            return std::make_shared<ASTLiteral>(Field{UInt8(0)});
+        if (arguments.size() == 1)
+            return arguments[0];
+
+        auto function = std::make_shared<ASTFunction>();
+        auto exp_list = std::make_shared<ASTExpressionList>();
+        function->name = "or";
+        function->arguments = exp_list;
+        function->children.push_back(exp_list);
+        exp_list->children = std::move(arguments);
+        return function;
+    }
+
+
+    using ConditionIndex = RowPolicy::ConditionIndex;
+    static constexpr size_t MAX_CONDITION_INDEX = RowPolicy::MAX_CONDITION_INDEX;
+
+
+    /// Accumulates conditions from multiple row policies and joins them using the AND logical operation.
+    class ConditionsMixer
+    {
+    public:
+        void add(const ASTPtr & condition, bool is_restrictive)
+        {
+            if (!condition)
+                return;
+
+            if (is_restrictive)
+                restrictions.push_back(condition);
+            else
+                permissions.push_back(condition);
+        }
+
+        ASTPtr getResult() &&
+        {
+            /// Process permissive conditions.
+            if (!permissions.empty())
+                restrictions.push_back(applyFunctionOR(std::move(permissions)));
+
+            /// Process restrictive conditions.
+            if (!restrictions.empty())
+                return applyFunctionAND(std::move(restrictions));
+            return nullptr;
+        }
+
+    private:
+        ASTs permissions;
+        ASTs restrictions;
+    };
+}
+
+
+void RowPolicyContextFactory::PolicyInfo::setPolicy(const RowPolicyPtr & policy_)
+{
+    policy = policy_;
+
+    boost::range::copy(policy->roles, std::inserter(roles, roles.end()));
+    all_roles = policy->all_roles;
+    boost::range::copy(policy->except_roles, std::inserter(except_roles, except_roles.end()));
+
+    for (auto index : ext::range_with_static_cast<ConditionIndex>(0, MAX_CONDITION_INDEX))
+    {
+        const String & condition = policy->conditions[index];
+        auto previous_range = std::pair(std::begin(policy->conditions), std::begin(policy->conditions) + index);
+        auto previous_it = std::find(previous_range.first, previous_range.second, condition);
+        if (previous_it != previous_range.second)
+        {
+            /// The condition is already parsed before.
+            parsed_conditions[index] = parsed_conditions[previous_it - previous_range.first];
+        }
+        else
+        {
+            /// Try to parse the condition.
+            try
+            {
+                ParserExpression parser;
+                parsed_conditions[index] = parseQuery(parser, condition, 0);
+            }
+            catch (...)
+            {
+                tryLogCurrentException(
+                    &Poco::Logger::get("RowPolicy"),
+                    String("Could not parse the condition ") + RowPolicy::conditionIndexToString(index) + " of row policy "
+                        + backQuote(policy->getFullName()));
+            }
+        }
+    }
+}
+
+
+bool RowPolicyContextFactory::PolicyInfo::canUseWithContext(const RowPolicyContext & context) const
+{
+    if (roles.count(context.user_name))
+        return true;
+
+    if (all_roles && !except_roles.count(context.user_name))
+        return true;
+
+    return false;
+}
+
+
+RowPolicyContextFactory::RowPolicyContextFactory(const AccessControlManager & access_control_manager_)
+    : access_control_manager(access_control_manager_)
+{
+}
+
+RowPolicyContextFactory::~RowPolicyContextFactory() = default;
+
+
+RowPolicyContextPtr RowPolicyContextFactory::createContext(const String & user_name)
+{
+    std::lock_guard lock{mutex};
+    ensureAllRowPoliciesRead();
+    auto context = ext::shared_ptr_helper<RowPolicyContext>::create(user_name);
+    contexts.push_back(context);
+    mixConditionsForContext(*context);
+    return context;
+}
+
+
+void RowPolicyContextFactory::ensureAllRowPoliciesRead()
+{
+    /// `mutex` is already locked.
+    if (all_policies_read)
+        return;
+    all_policies_read = true;
+
+    subscription = access_control_manager.subscribeForChanges<RowPolicy>(
+        [&](const UUID & id, const AccessEntityPtr & entity)
+        {
+            if (entity)
+                rowPolicyAddedOrChanged(id, typeid_cast<RowPolicyPtr>(entity));
+            else
+                rowPolicyRemoved(id);
+        });
+
+    for (const UUID & id : access_control_manager.findAll<RowPolicy>())
+    {
+        auto quota = access_control_manager.tryRead<RowPolicy>(id);
+        if (quota)
+            all_policies.emplace(id, PolicyInfo(quota));
+    }
+}
+
+
+void RowPolicyContextFactory::rowPolicyAddedOrChanged(const UUID & policy_id, const RowPolicyPtr & new_policy)
+{
+    std::lock_guard lock{mutex};
+    auto it = all_policies.find(policy_id);
+    if (it == all_policies.end())
+    {
+        it = all_policies.emplace(policy_id, PolicyInfo(new_policy)).first;
+    }
+    else
+    {
+        if (it->second.policy == new_policy)
+            return;
+    }
+
+    auto & info = it->second;
+    info.setPolicy(new_policy);
+    mixConditionsForAllContexts();
+}
+
+
+void RowPolicyContextFactory::rowPolicyRemoved(const UUID & policy_id)
+{
+    std::lock_guard lock{mutex};
+    all_policies.erase(policy_id);
+    mixConditionsForAllContexts();
+}
+
+
+void RowPolicyContextFactory::mixConditionsForAllContexts()
+{
+    /// `mutex` is already locked.
+    boost::range::remove_erase_if(
+        contexts,
+        [&](const std::weak_ptr<RowPolicyContext> & weak)
+        {
+            auto context = weak.lock();
+            if (!context)
+                return true; // remove from the `contexts` list.
+            mixConditionsForContext(*context);
+            return false; // keep in the `contexts` list.
+        });
+}
+
+
+void RowPolicyContextFactory::mixConditionsForContext(RowPolicyContext & context)
+{
+    /// `mutex` is already locked.
+    struct Mixers
+    {
+        ConditionsMixer mixers[MAX_CONDITION_INDEX];
+        std::vector<UUID> policy_ids;
+    };
+    using MapOfMixedConditions = RowPolicyContext::MapOfMixedConditions;
+    using DatabaseAndTableName = RowPolicyContext::DatabaseAndTableName;
+    using DatabaseAndTableNameRef = RowPolicyContext::DatabaseAndTableNameRef;
+    using Hash = RowPolicyContext::Hash;
+
+    std::unordered_map<DatabaseAndTableName, Mixers, Hash> map_of_mixers;
+
+    for (const auto & [policy_id, info] : all_policies)
+    {
+        if (info.canUseWithContext(context))
+        {
+            const auto & policy = *info.policy;
+            auto & mixers = map_of_mixers[std::pair{policy.getDatabase(), policy.getTableName()}];
+            mixers.policy_ids.push_back(policy_id);
+            for (auto index : ext::range(0, MAX_CONDITION_INDEX))
+                mixers.mixers[index].add(info.parsed_conditions[index], policy.isRestrictive());
+        }
+    }
+
+    auto map_of_mixed_conditions = std::make_shared<MapOfMixedConditions>();
+    for (auto & [database_and_table_name, mixers] : map_of_mixers)
+    {
+        auto database_and_table_name_keeper = std::make_unique<DatabaseAndTableName>();
+        database_and_table_name_keeper->first = database_and_table_name.first;
+        database_and_table_name_keeper->second = database_and_table_name.second;
+        auto & mixed_conditions = (*map_of_mixed_conditions)[DatabaseAndTableNameRef{database_and_table_name_keeper->first,
+                                                                                     database_and_table_name_keeper->second}];
+        mixed_conditions.database_and_table_name_keeper = std::move(database_and_table_name_keeper);
+        mixed_conditions.policy_ids = std::move(mixers.policy_ids);
+        for (auto index : ext::range(0, MAX_CONDITION_INDEX))
+            mixed_conditions.mixed_conditions[index] = std::move(mixers.mixers[index]).getResult();
+    }
+
+    std::atomic_store(&context.atomic_map_of_mixed_conditions, std::shared_ptr<const MapOfMixedConditions>{map_of_mixed_conditions});
+}
+
+}
diff --git a/dbms/src/Access/RowPolicyContextFactory.h b/dbms/src/Access/RowPolicyContextFactory.h
new file mode 100644
index 00000000000..02019c468a9
--- /dev/null
+++ b/dbms/src/Access/RowPolicyContextFactory.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <Access/RowPolicyContext.h>
+#include <Access/IAccessStorage.h>
+#include <mutex>
+#include <unordered_map>
+#include <unordered_set>
+
+
+namespace DB
+{
+class AccessControlManager;
+
+
+/// Stores read and parsed row policies.
+class RowPolicyContextFactory
+{
+public:
+    RowPolicyContextFactory(const AccessControlManager & access_control_manager_);
+    ~RowPolicyContextFactory();
+
+    RowPolicyContextPtr createContext(const String & user_name);
+
+private:
+    using ParsedConditions = RowPolicyContext::ParsedConditions;
+
+    struct PolicyInfo
+    {
+        PolicyInfo(const RowPolicyPtr & policy_) { setPolicy(policy_); }
+        void setPolicy(const RowPolicyPtr & policy_);
+        bool canUseWithContext(const RowPolicyContext & context) const;
+
+        RowPolicyPtr policy;
+        std::unordered_set<String> roles;
+        bool all_roles = false;
+        std::unordered_set<String> except_roles;
+        ParsedConditions parsed_conditions;
+    };
+
+    void ensureAllRowPoliciesRead();
+    void rowPolicyAddedOrChanged(const UUID & policy_id, const RowPolicyPtr & new_policy);
+    void rowPolicyRemoved(const UUID & policy_id);
+    void mixConditionsForAllContexts();
+    void mixConditionsForContext(RowPolicyContext & context);
+
+    const AccessControlManager & access_control_manager;
+    std::unordered_map<UUID, PolicyInfo> all_policies;
+    bool all_policies_read = false;
+    IAccessStorage::SubscriptionPtr subscription;
+    std::vector<std::weak_ptr<RowPolicyContext>> contexts;
+    std::mutex mutex;
+};
+
+}
diff --git a/dbms/src/Access/UsersConfigAccessStorage.cpp b/dbms/src/Access/UsersConfigAccessStorage.cpp
index d417968bb64..c9671afaca1 100644
--- a/dbms/src/Access/UsersConfigAccessStorage.cpp
+++ b/dbms/src/Access/UsersConfigAccessStorage.cpp
@@ -1,5 +1,6 @@
 #include <Access/UsersConfigAccessStorage.h>
 #include <Access/Quota.h>
+#include <Access/RowPolicy.h>
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/quoteString.h>
 #include <Poco/Util/AbstractConfiguration.h>
@@ -15,6 +16,8 @@ namespace
     {
         if (type == typeid(Quota))
             return 'Q';
+        if (type == typeid(RowPolicy))
+            return 'P';
         return 0;
     }
 
@@ -112,6 +115,57 @@ namespace
         }
         return quotas;
     }
+
+
+    std::vector<AccessEntityPtr> parseRowPolicies(const Poco::Util::AbstractConfiguration & config, Poco::Logger * log)
+    {
+        std::vector<AccessEntityPtr> policies;
+        Poco::Util::AbstractConfiguration::Keys user_names;
+        config.keys("users", user_names);
+
+        for (const String & user_name : user_names)
+        {
+            const String databases_config = "users." + user_name + ".databases";
+            if (config.has(databases_config))
+            {
+                Poco::Util::AbstractConfiguration::Keys databases;
+                config.keys(databases_config, databases);
+
+                /// Read tables within databases
+                for (const String & database : databases)
+                {
+                    const String database_config = databases_config + "." + database;
+                    Poco::Util::AbstractConfiguration::Keys table_names;
+                    config.keys(database_config, table_names);
+
+                    /// Read table properties
+                    for (const String & table_name : table_names)
+                    {
+                        const auto filter_config = database_config + "." + table_name + ".filter";
+                        if (config.has(filter_config))
+                        {
+                            try
+                            {
+                                auto policy = std::make_shared<RowPolicy>();
+                                policy->setFullName(database, table_name, user_name);
+                                policy->conditions[RowPolicy::SELECT_FILTER] = config.getString(filter_config);
+                                policy->roles.push_back(user_name);
+                                policies.push_back(policy);
+                            }
+                            catch (...)
+                            {
+                                tryLogCurrentException(
+                                    log,
+                                    "Could not parse row policy " + backQuote(user_name) + " on table " + backQuoteIfNeed(database) + "."
+                                        + backQuoteIfNeed(table_name));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return policies;
+    }
 }
 
 
@@ -128,6 +182,8 @@ void UsersConfigAccessStorage::loadFromConfig(const Poco::Util::AbstractConfigur
     std::vector<std::pair<UUID, AccessEntityPtr>> all_entities;
     for (const auto & entity : parseQuotas(config, getLogger()))
         all_entities.emplace_back(generateID(*entity), entity);
+    for (const auto & entity : parseRowPolicies(config, getLogger()))
+        all_entities.emplace_back(generateID(*entity), entity);
     memory_storage.setAll(all_entities);
 }
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h b/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h
index 96d97280f03..88ad9430bf0 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h
@@ -24,11 +24,16 @@ struct AggregateFunctionArgMinMaxData
 
     ResultData result;  // the argument at which the minimum/maximum value is reached.
     ValueData value;    // value for which the minimum/maximum is calculated.
+
+    static bool allocatesMemoryInArena()
+    {
+        return ResultData::allocatesMemoryInArena() || ValueData::allocatesMemoryInArena();
+    }
 };
 
 /// Returns the first arg value found for the minimum/maximum value. Example: argMax(arg, value).
-template <typename Data, bool AllocatesMemoryInArena>
-class AggregateFunctionArgMinMax final : public IAggregateFunctionDataHelper<Data, AggregateFunctionArgMinMax<Data, AllocatesMemoryInArena>>
+template <typename Data>
+class AggregateFunctionArgMinMax final : public IAggregateFunctionDataHelper<Data, AggregateFunctionArgMinMax<Data>>
 {
 private:
     const DataTypePtr & type_res;
@@ -36,7 +41,7 @@ private:
 
 public:
     AggregateFunctionArgMinMax(const DataTypePtr & type_res_, const DataTypePtr & type_val_)
-        : IAggregateFunctionDataHelper<Data, AggregateFunctionArgMinMax<Data, AllocatesMemoryInArena>>({type_res_, type_val_}, {}),
+        : IAggregateFunctionDataHelper<Data, AggregateFunctionArgMinMax<Data>>({type_res_, type_val_}, {}),
         type_res(this->argument_types[0]), type_val(this->argument_types[1])
     {
         if (!type_val->isComparable())
@@ -77,7 +82,7 @@ public:
 
     bool allocatesMemoryInArena() const override
     {
-        return AllocatesMemoryInArena;
+        return Data::allocatesMemoryInArena();
     }
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h b/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
index a6779eb5d9e..e26f1a1f528 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
@@ -166,6 +166,11 @@ public:
     {
         return has() && assert_cast<const ColVecType &>(column).getData()[row_num] == value;
     }
+
+    static bool allocatesMemoryInArena()
+    {
+        return false;
+    }
 };
 
 
@@ -384,6 +389,11 @@ public:
     {
         return has() && assert_cast<const ColumnString &>(column).getDataAtWithTerminatingZero(row_num) == getStringRef();
     }
+
+    static bool allocatesMemoryInArena()
+    {
+        return true;
+    }
 };
 
 static_assert(
@@ -555,6 +565,11 @@ public:
     {
         return has() && to.value == value;
     }
+
+    static bool allocatesMemoryInArena()
+    {
+        return false;
+    }
 };
 
 
@@ -675,15 +690,15 @@ struct AggregateFunctionAnyHeavyData : Data
 };
 
 
-template <typename Data, bool use_arena>
-class AggregateFunctionsSingleValue final : public IAggregateFunctionDataHelper<Data, AggregateFunctionsSingleValue<Data, use_arena>>
+template <typename Data>
+class AggregateFunctionsSingleValue final : public IAggregateFunctionDataHelper<Data, AggregateFunctionsSingleValue<Data>>
 {
 private:
     DataTypePtr & type;
 
 public:
     AggregateFunctionsSingleValue(const DataTypePtr & type_)
-        : IAggregateFunctionDataHelper<Data, AggregateFunctionsSingleValue<Data, use_arena>>({type_}, {})
+        : IAggregateFunctionDataHelper<Data, AggregateFunctionsSingleValue<Data>>({type_}, {})
         , type(this->argument_types[0])
     {
         if (StringRef(Data::name()) == StringRef("min")
@@ -724,7 +739,7 @@ public:
 
     bool allocatesMemoryInArena() const override
     {
-        return use_arena;
+        return Data::allocatesMemoryInArena();
     }
 
     void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
diff --git a/dbms/src/AggregateFunctions/HelpersMinMaxAny.h b/dbms/src/AggregateFunctions/HelpersMinMaxAny.h
index 5486e71fdd0..6c027b5a6de 100644
--- a/dbms/src/AggregateFunctions/HelpersMinMaxAny.h
+++ b/dbms/src/AggregateFunctions/HelpersMinMaxAny.h
@@ -13,8 +13,8 @@
 namespace DB
 {
 
-/// min, max, any, anyLast
-template <template <typename, bool> class AggregateFunctionTemplate, template <typename> class Data>
+/// min, max, any, anyLast, anyHeavy, etc...
+template <template <typename> class AggregateFunctionTemplate, template <typename> class Data>
 static IAggregateFunction * createAggregateFunctionSingleValue(const String & name, const DataTypes & argument_types, const Array & parameters)
 {
     assertNoParameters(name, parameters);
@@ -24,26 +24,26 @@ static IAggregateFunction * createAggregateFunctionSingleValue(const String & na
 
     WhichDataType which(argument_type);
 #define DISPATCH(TYPE) \
-    if (which.idx == TypeIndex::TYPE) return new AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE>>, false>(argument_type);
+    if (which.idx == TypeIndex::TYPE) return new AggregateFunctionTemplate<Data<SingleValueDataFixed<TYPE>>>(argument_type);
     FOR_NUMERIC_TYPES(DISPATCH)
 #undef DISPATCH
 
     if (which.idx == TypeIndex::Date)
-        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<DataTypeDate::FieldType>>, false>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<DataTypeDate::FieldType>>>(argument_type);
     if (which.idx == TypeIndex::DateTime)
-        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<DataTypeDateTime::FieldType>>, false>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<DataTypeDateTime::FieldType>>>(argument_type);
     if (which.idx == TypeIndex::DateTime64)
-        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<DateTime64>>, false>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<DateTime64>>>(argument_type);
     if (which.idx == TypeIndex::Decimal32)
-        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<Decimal32>>, false>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<Decimal32>>>(argument_type);
     if (which.idx == TypeIndex::Decimal64)
-        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<Decimal64>>, false>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<Decimal64>>>(argument_type);
     if (which.idx == TypeIndex::Decimal128)
-        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<Decimal128>>, false>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataFixed<Decimal128>>>(argument_type);
     if (which.idx == TypeIndex::String)
-        return new AggregateFunctionTemplate<Data<SingleValueDataString>, true>(argument_type);
+        return new AggregateFunctionTemplate<Data<SingleValueDataString>>(argument_type);
 
-    return new AggregateFunctionTemplate<Data<SingleValueDataGeneric>, false>(argument_type);
+    return new AggregateFunctionTemplate<Data<SingleValueDataGeneric>>(argument_type);
 }
 
 
@@ -53,53 +53,28 @@ static IAggregateFunction * createAggregateFunctionArgMinMaxSecond(const DataTyp
 {
     WhichDataType which(val_type);
 
-    /// If at least one argument is a String, the function can allocate memory in Arena.
-    bool is_res_type_string = WhichDataType(res_type).isString();
-
 #define DISPATCH(TYPE) \
-    if (which.idx == TypeIndex::TYPE && !is_res_type_string) \
-        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<TYPE>>>, false>(res_type, val_type); \
-    if (which.idx == TypeIndex::TYPE && is_res_type_string) \
-        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<TYPE>>>, true>(res_type, val_type);
+    if (which.idx == TypeIndex::TYPE) \
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<TYPE>>>>(res_type, val_type); \
     FOR_NUMERIC_TYPES(DISPATCH)
 #undef DISPATCH
 
-    if (!is_res_type_string)
-    {
-        if (which.idx == TypeIndex::Date)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DataTypeDate::FieldType>>>, false>(res_type, val_type);
-        if (which.idx == TypeIndex::DateTime)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DataTypeDateTime::FieldType>>>, false>(res_type, val_type);
-        if (which.idx == TypeIndex::DateTime64)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DateTime64>>>, false>(res_type, val_type);
-        if (which.idx == TypeIndex::Decimal32)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal32>>>, false>(res_type, val_type);
-        if (which.idx == TypeIndex::Decimal64)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal64>>>, false>(res_type, val_type);
-        if (which.idx == TypeIndex::Decimal128)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal128>>>, false>(res_type, val_type);
-        if (which.idx == TypeIndex::String)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataString>>, true>(res_type, val_type);
-    }
-    else
-    {
-        if (which.idx == TypeIndex::Date)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DataTypeDate::FieldType>>>, true>(res_type, val_type);
-        if (which.idx == TypeIndex::DateTime)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DataTypeDateTime::FieldType>>>, true>(res_type, val_type);
-        if (which.idx == TypeIndex::DateTime64)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DateTime64>>>, true>(res_type, val_type);
-        if (which.idx == TypeIndex::Decimal32)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal32>>>, true>(res_type, val_type);
-        if (which.idx == TypeIndex::Decimal64)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal64>>>, true>(res_type, val_type);
-        if (which.idx == TypeIndex::Decimal128)
-            return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal128>>>, true>(res_type, val_type);
-    }
+    if (which.idx == TypeIndex::Date)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DataTypeDate::FieldType>>>>(res_type, val_type);
+    if (which.idx == TypeIndex::DateTime)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DataTypeDateTime::FieldType>>>>(res_type, val_type);
+    if (which.idx == TypeIndex::DateTime64)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<DateTime64>>>>(res_type, val_type);
+    if (which.idx == TypeIndex::Decimal32)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal32>>>>(res_type, val_type);
+    if (which.idx == TypeIndex::Decimal64)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal64>>>>(res_type, val_type);
+    if (which.idx == TypeIndex::Decimal128)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataFixed<Decimal128>>>>(res_type, val_type);
+    if (which.idx == TypeIndex::String)
+        return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataString>>>(res_type, val_type);
 
-    /// But generic implementation doesn't allocate memory in Arena.
-
-    return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataGeneric>>, false>(res_type, val_type);
+    return new AggregateFunctionArgMinMax<AggregateFunctionArgMinMaxData<ResData, MinMaxData<SingleValueDataGeneric>>>(res_type, val_type);
 }
 
 template <template <typename> class MinMaxData>
diff --git a/dbms/src/Functions/GeoUtils.h b/dbms/src/Functions/GeoUtils.h
index b13faa0f014..3a5e0202469 100644
--- a/dbms/src/Functions/GeoUtils.h
+++ b/dbms/src/Functions/GeoUtils.h
@@ -261,6 +261,10 @@ void PointInPolygonWithGrid<CoordinateType>::buildGrid()
 
     for (size_t row = 0; row < grid_size; ++row)
     {
+#pragma GCC diagnostic push
+#if !__clang__
+#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#endif
         CoordinateType y_min = min_corner.y() + row * cell_height;
         CoordinateType y_max = min_corner.y() + (row + 1) * cell_height;
 
@@ -268,6 +272,7 @@ void PointInPolygonWithGrid<CoordinateType>::buildGrid()
         {
             CoordinateType x_min = min_corner.x() + col * cell_width;
             CoordinateType x_max = min_corner.x() + (col + 1) * cell_width;
+#pragma GCC diagnostic pop
             Box cell_box(Point(x_min, y_min), Point(x_max, y_max));
 
             Polygon cell_bound;
diff --git a/dbms/src/Functions/currentRowPolicies.cpp b/dbms/src/Functions/currentRowPolicies.cpp
new file mode 100644
index 00000000000..4ffd40ed1b9
--- /dev/null
+++ b/dbms/src/Functions/currentRowPolicies.cpp
@@ -0,0 +1,225 @@
+#include <Functions/IFunction.h>
+#include <Functions/FunctionFactory.h>
+#include <DataTypes/DataTypeArray.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <DataTypes/DataTypeUUID.h>
+#include <Columns/ColumnArray.h>
+#include <Columns/ColumnConst.h>
+#include <Columns/ColumnString.h>
+#include <Columns/ColumnTuple.h>
+#include <Interpreters/Context.h>
+#include <Access/RowPolicyContext.h>
+#include <Access/AccessControlManager.h>
+#include <ext/range.h>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
+
+/// The currentRowPolicies() function can be called with 0..2 arguments:
+/// currentRowPolicies() returns array of tuples (database, table_name, row_policy_name) for all the row policies applied for the current user;
+/// currentRowPolicies(table_name) is equivalent to currentRowPolicies(currentDatabase(), table_name);
+/// currentRowPolicies(database, table_name) returns array of names of the row policies applied to a specific table and for the current user.
+class FunctionCurrentRowPolicies : public IFunction
+{
+public:
+    static constexpr auto name = "currentRowPolicies";
+
+    static FunctionPtr create(const Context & context_) { return std::make_shared<FunctionCurrentRowPolicies>(context_); }
+    explicit FunctionCurrentRowPolicies(const Context & context_) : context(context_) {}
+
+    String getName() const override { return name; }
+    size_t getNumberOfArguments() const override { return 0; }
+    bool isVariadic() const override { return true; }
+
+    void checkNumberOfArgumentsIfVariadic(size_t number_of_arguments) const override
+    {
+        if (number_of_arguments > 2)
+            throw Exception("Number of arguments for function " + String(name) + " doesn't match: passed "
+                            + toString(number_of_arguments) + ", should be 0..2",
+                            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+    }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
+    {
+        if (arguments.empty())
+            return std::make_shared<DataTypeArray>(std::make_shared<DataTypeTuple>(
+                DataTypes{std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>(), std::make_shared<DataTypeString>()}));
+        else
+            return std::make_shared<DataTypeArray>(std::make_shared<DataTypeString>());
+    }
+
+    bool isDeterministic() const override { return false; }
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result_pos, size_t input_rows_count) override
+    {
+        if (arguments.empty())
+        {
+            auto database_column = ColumnString::create();
+            auto table_name_column = ColumnString::create();
+            auto policy_name_column = ColumnString::create();
+            for (const auto & policy_id : context.getRowPolicy()->getCurrentPolicyIDs())
+            {
+                const auto policy = context.getAccessControlManager().tryRead<RowPolicy>(policy_id);
+                if (policy)
+                {
+                    const String database = policy->getDatabase();
+                    const String table_name = policy->getTableName();
+                    const String policy_name = policy->getName();
+                    database_column->insertData(database.data(), database.length());
+                    table_name_column->insertData(table_name.data(), table_name.length());
+                    policy_name_column->insertData(policy_name.data(), policy_name.length());
+                }
+            }
+            auto offset_column = ColumnArray::ColumnOffsets::create();
+            offset_column->insertValue(policy_name_column->size());
+            block.getByPosition(result_pos).column = ColumnConst::create(
+                ColumnArray::create(
+                    ColumnTuple::create(Columns{std::move(database_column), std::move(table_name_column), std::move(policy_name_column)}),
+                    std::move(offset_column)),
+                input_rows_count);
+            return;
+        }
+
+        const IColumn * database_column = nullptr;
+        if (arguments.size() == 2)
+        {
+            const auto & database_column_with_type = block.getByPosition(arguments[0]);
+            if (!isStringOrFixedString(database_column_with_type.type))
+                throw Exception{"The first argument of function " + String(name)
+                                    + " should be a string containing database name, illegal type: "
+                                    + database_column_with_type.type->getName(),
+                                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            database_column = database_column_with_type.column.get();
+        }
+
+        const auto & table_name_column_with_type = block.getByPosition(arguments[arguments.size() - 1]);
+        if (!isStringOrFixedString(table_name_column_with_type.type))
+            throw Exception{"The" + String(database_column ? " last" : "") + " argument of function " + String(name)
+                                + " should be a string containing table name, illegal type: " + table_name_column_with_type.type->getName(),
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+        const IColumn * table_name_column = table_name_column_with_type.column.get();
+
+        auto policy_name_column = ColumnString::create();
+        auto offset_column = ColumnArray::ColumnOffsets::create();
+        for (const auto i : ext::range(0, input_rows_count))
+        {
+            String database = database_column ? database_column->getDataAt(i).toString() : context.getCurrentDatabase();
+            String table_name = table_name_column->getDataAt(i).toString();
+            for (const auto & policy_id : context.getRowPolicy()->getCurrentPolicyIDs(database, table_name))
+            {
+                const auto policy = context.getAccessControlManager().tryRead<RowPolicy>(policy_id);
+                if (policy)
+                {
+                    const String policy_name = policy->getName();
+                    policy_name_column->insertData(policy_name.data(), policy_name.length());
+                }
+            }
+            offset_column->insertValue(policy_name_column->size());
+        }
+
+        block.getByPosition(result_pos).column = ColumnArray::create(std::move(policy_name_column), std::move(offset_column));
+    }
+
+private:
+    const Context & context;
+};
+
+
+/// The currentRowPolicyIDs() function can be called with 0..2 arguments:
+/// currentRowPolicyIDs() returns array of IDs of all the row policies applied for the current user;
+/// currentRowPolicyIDs(table_name) is equivalent to currentRowPolicyIDs(currentDatabase(), table_name);
+/// currentRowPolicyIDs(database, table_name) returns array of IDs of the row policies applied to a specific table and for the current user.
+class FunctionCurrentRowPolicyIDs : public IFunction
+{
+public:
+    static constexpr auto name = "currentRowPolicyIDs";
+
+    static FunctionPtr create(const Context & context_) { return std::make_shared<FunctionCurrentRowPolicyIDs>(context_); }
+    explicit FunctionCurrentRowPolicyIDs(const Context & context_) : context(context_) {}
+
+    String getName() const override { return name; }
+    size_t getNumberOfArguments() const override { return 0; }
+    bool isVariadic() const override { return true; }
+
+    void checkNumberOfArgumentsIfVariadic(size_t number_of_arguments) const override
+    {
+        if (number_of_arguments > 2)
+            throw Exception("Number of arguments for function " + String(name) + " doesn't match: passed "
+                            + toString(number_of_arguments) + ", should be 0..2",
+                            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+    }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & /* arguments */) const override
+    {
+        return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUUID>());
+    }
+
+    bool isDeterministic() const override { return false; }
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result_pos, size_t input_rows_count) override
+    {
+        if (arguments.empty())
+        {
+            auto policy_id_column = ColumnVector<UInt128>::create();
+            for (const auto & policy_id : context.getRowPolicy()->getCurrentPolicyIDs())
+                 policy_id_column->insertValue(policy_id);
+            auto offset_column = ColumnArray::ColumnOffsets::create();
+            offset_column->insertValue(policy_id_column->size());
+            block.getByPosition(result_pos).column
+                = ColumnConst::create(ColumnArray::create(std::move(policy_id_column), std::move(offset_column)), input_rows_count);
+            return;
+        }
+
+        const IColumn * database_column = nullptr;
+        if (arguments.size() == 2)
+        {
+            const auto & database_column_with_type = block.getByPosition(arguments[0]);
+            if (!isStringOrFixedString(database_column_with_type.type))
+                throw Exception{"The first argument of function " + String(name)
+                                    + " should be a string containing database name, illegal type: "
+                                    + database_column_with_type.type->getName(),
+                                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            database_column = database_column_with_type.column.get();
+        }
+
+        const auto & table_name_column_with_type = block.getByPosition(arguments[arguments.size() - 1]);
+        if (!isStringOrFixedString(table_name_column_with_type.type))
+            throw Exception{"The" + String(database_column ? " last" : "") + " argument of function " + String(name)
+                                + " should be a string containing table name, illegal type: " + table_name_column_with_type.type->getName(),
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+        const IColumn * table_name_column = table_name_column_with_type.column.get();
+
+        auto policy_id_column = ColumnVector<UInt128>::create();
+        auto offset_column = ColumnArray::ColumnOffsets::create();
+        for (const auto i : ext::range(0, input_rows_count))
+        {
+            String database = database_column ? database_column->getDataAt(i).toString() : context.getCurrentDatabase();
+            String table_name = table_name_column->getDataAt(i).toString();
+            for (const auto & policy_id : context.getRowPolicy()->getCurrentPolicyIDs(database, table_name))
+                policy_id_column->insertValue(policy_id);
+            offset_column->insertValue(policy_id_column->size());
+        }
+
+        block.getByPosition(result_pos).column = ColumnArray::create(std::move(policy_id_column), std::move(offset_column));
+    }
+
+private:
+    const Context & context;
+};
+
+
+void registerFunctionCurrentRowPolicies(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionCurrentRowPolicies>();
+    factory.registerFunction<FunctionCurrentRowPolicyIDs>();
+}
+
+}
diff --git a/dbms/src/Functions/registerFunctions.h b/dbms/src/Functions/registerFunctions.h
index 087fd6b7e2b..5827ae5894c 100644
--- a/dbms/src/Functions/registerFunctions.h
+++ b/dbms/src/Functions/registerFunctions.h
@@ -9,6 +9,7 @@ class FunctionFactory;
 void registerFunctionCurrentDatabase(FunctionFactory &);
 void registerFunctionCurrentUser(FunctionFactory &);
 void registerFunctionCurrentQuota(FunctionFactory &);
+void registerFunctionCurrentRowPolicies(FunctionFactory &);
 void registerFunctionHostName(FunctionFactory &);
 void registerFunctionFQDN(FunctionFactory &);
 void registerFunctionVisibleWidth(FunctionFactory &);
diff --git a/dbms/src/Functions/registerFunctionsMiscellaneous.cpp b/dbms/src/Functions/registerFunctionsMiscellaneous.cpp
index c45ccf57f64..98c749189d4 100644
--- a/dbms/src/Functions/registerFunctionsMiscellaneous.cpp
+++ b/dbms/src/Functions/registerFunctionsMiscellaneous.cpp
@@ -8,6 +8,7 @@ void registerFunctionsMiscellaneous(FunctionFactory & factory)
     registerFunctionCurrentDatabase(factory);
     registerFunctionCurrentUser(factory);
     registerFunctionCurrentQuota(factory);
+    registerFunctionCurrentRowPolicies(factory);
     registerFunctionHostName(factory);
     registerFunctionFQDN(factory);
     registerFunctionVisibleWidth(factory);
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 4ed8a540f29..e5aab7075ca 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -28,6 +28,7 @@
 #include <Access/AccessControlManager.h>
 #include <Access/SettingsConstraints.h>
 #include <Access/QuotaContext.h>
+#include <Access/RowPolicyContext.h>
 #include <Interpreters/ExpressionJIT.h>
 #include <Interpreters/UsersManager.h>
 #include <Dictionaries/Embedded/GeoDictionariesLoader.h>
@@ -333,6 +334,7 @@ Context Context::createGlobal()
 {
     Context res;
     res.quota = std::make_shared<QuotaContext>();
+    res.row_policy = std::make_shared<RowPolicyContext>();
     res.shared = std::make_shared<ContextShared>();
     return res;
 }
@@ -625,6 +627,13 @@ void Context::checkQuotaManagementIsAllowed()
             "User " + client_info.current_user + " doesn't have enough privileges to manage quotas", ErrorCodes::NOT_ENOUGH_PRIVILEGES);
 }
 
+void Context::checkRowPolicyManagementIsAllowed()
+{
+    if (!is_row_policy_management_allowed)
+        throw Exception(
+            "User " + client_info.current_user + " doesn't have enough privileges to manage row policies", ErrorCodes::NOT_ENOUGH_PRIVILEGES);
+}
+
 void Context::setUsersConfig(const ConfigurationPtr & config)
 {
     auto lock = getLock();
@@ -639,34 +648,6 @@ ConfigurationPtr Context::getUsersConfig()
     return shared->users_config;
 }
 
-bool Context::hasUserProperty(const String & database, const String & table, const String & name) const
-{
-    auto lock = getLock();
-
-    // No user - no properties.
-    if (client_info.current_user.empty())
-        return false;
-
-    const auto & props = shared->users_manager->getUser(client_info.current_user)->table_props;
-
-    auto db = props.find(database);
-    if (db == props.end())
-        return false;
-
-    auto table_props = db->second.find(table);
-    if (table_props == db->second.end())
-        return false;
-
-    return !!table_props->second.count(name);
-}
-
-const String & Context::getUserProperty(const String & database, const String & table, const String & name) const
-{
-    auto lock = getLock();
-    const auto & props = shared->users_manager->getUser(client_info.current_user)->table_props;
-    return props.at(database).at(table).at(name);
-}
-
 void Context::calculateUserSettings()
 {
     auto lock = getLock();
@@ -691,6 +672,8 @@ void Context::calculateUserSettings()
     quota = getAccessControlManager().createQuotaContext(
         client_info.current_user, client_info.current_address.host(), client_info.quota_key);
     is_quota_management_allowed = user->is_quota_management_allowed;
+    row_policy = getAccessControlManager().getRowPolicyContext(client_info.current_user);
+    is_row_policy_management_allowed = user->is_row_policy_management_allowed;
 }
 
 
diff --git a/dbms/src/Interpreters/Context.h b/dbms/src/Interpreters/Context.h
index 930b0f254fe..79e2936d7d2 100644
--- a/dbms/src/Interpreters/Context.h
+++ b/dbms/src/Interpreters/Context.h
@@ -45,6 +45,7 @@ namespace DB
 struct ContextShared;
 class Context;
 class QuotaContext;
+class RowPolicyContext;
 class EmbeddedDictionaries;
 class ExternalDictionariesLoader;
 class ExternalModelsLoader;
@@ -140,6 +141,8 @@ private:
 
     std::shared_ptr<QuotaContext> quota;           /// Current quota. By default - empty quota, that have no limits.
     bool is_quota_management_allowed = false;      /// Whether the current user is allowed to manage quotas via SQL commands.
+    std::shared_ptr<RowPolicyContext> row_policy;
+    bool is_row_policy_management_allowed = false; /// Whether the current user is allowed to manage row policies via SQL commands.
     String current_database;
     Settings settings;                                  /// Setting for query execution.
     std::shared_ptr<const SettingsConstraints> settings_constraints;
@@ -209,6 +212,8 @@ public:
     const AccessControlManager & getAccessControlManager() const;
     std::shared_ptr<QuotaContext> getQuota() const { return quota; }
     void checkQuotaManagementIsAllowed();
+    std::shared_ptr<RowPolicyContext> getRowPolicy() const { return row_policy; }
+    void checkRowPolicyManagementIsAllowed();
 
     /** Take the list of users, quotas and configuration profiles from this config.
       * The list of users is completely replaced.
@@ -217,10 +222,6 @@ public:
     void setUsersConfig(const ConfigurationPtr & config);
     ConfigurationPtr getUsersConfig();
 
-    // User property is a key-value pair from the configuration entry: users.<username>.databases.<db_name>.<table_name>.<key_name>
-    bool hasUserProperty(const String & database, const String & table, const String & name) const;
-    const String & getUserProperty(const String & database, const String & table, const String & name) const;
-
     /// Must be called before getClientInfo.
     void setUser(const String & name, const String & password, const Poco::Net::SocketAddress & address, const String & quota_key);
 
diff --git a/dbms/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp b/dbms/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp
new file mode 100644
index 00000000000..daab0762826
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterCreateRowPolicyQuery.cpp
@@ -0,0 +1,93 @@
+#include <Interpreters/InterpreterCreateRowPolicyQuery.h>
+#include <Parsers/ASTCreateRowPolicyQuery.h>
+#include <Parsers/ASTRoleList.h>
+#include <Parsers/formatAST.h>
+#include <Interpreters/Context.h>
+#include <Access/AccessControlManager.h>
+#include <boost/range/algorithm/sort.hpp>
+
+
+namespace DB
+{
+BlockIO InterpreterCreateRowPolicyQuery::execute()
+{
+    context.checkRowPolicyManagementIsAllowed();
+    const auto & query = query_ptr->as<const ASTCreateRowPolicyQuery &>();
+    auto & access_control = context.getAccessControlManager();
+
+    if (query.alter)
+    {
+        auto update_func = [&](const AccessEntityPtr & entity) -> AccessEntityPtr
+        {
+            auto updated_policy = typeid_cast<std::shared_ptr<RowPolicy>>(entity->clone());
+            updateRowPolicyFromQuery(*updated_policy, query);
+            return updated_policy;
+        };
+        String full_name = query.name_parts.getFullName(context);
+        if (query.if_exists)
+        {
+            if (auto id = access_control.find<RowPolicy>(full_name))
+                access_control.tryUpdate(*id, update_func);
+        }
+        else
+            access_control.update(access_control.getID<RowPolicy>(full_name), update_func);
+    }
+    else
+    {
+        auto new_policy = std::make_shared<RowPolicy>();
+        updateRowPolicyFromQuery(*new_policy, query);
+
+        if (query.if_not_exists)
+            access_control.tryInsert(new_policy);
+        else if (query.or_replace)
+            access_control.insertOrReplace(new_policy);
+        else
+            access_control.insert(new_policy);
+    }
+
+    return {};
+}
+
+
+void InterpreterCreateRowPolicyQuery::updateRowPolicyFromQuery(RowPolicy & policy, const ASTCreateRowPolicyQuery & query)
+{
+    if (query.alter)
+    {
+        if (!query.new_policy_name.empty())
+            policy.setName(query.new_policy_name);
+    }
+    else
+    {
+        policy.setDatabase(query.name_parts.database.empty() ? context.getCurrentDatabase() : query.name_parts.database);
+        policy.setTableName(query.name_parts.table_name);
+        policy.setName(query.name_parts.policy_name);
+    }
+
+    if (query.is_restrictive)
+        policy.setRestrictive(*query.is_restrictive);
+
+    for (const auto & [index, condition] : query.conditions)
+        policy.conditions[index] = condition ? serializeAST(*condition) : String{};
+
+    if (query.roles)
+    {
+        const auto & query_roles = *query.roles;
+
+        /// We keep `roles` sorted.
+        policy.roles = query_roles.roles;
+        if (query_roles.current_user)
+            policy.roles.push_back(context.getClientInfo().current_user);
+        boost::range::sort(policy.roles);
+        policy.roles.erase(std::unique(policy.roles.begin(), policy.roles.end()), policy.roles.end());
+
+        policy.all_roles = query_roles.all_roles;
+
+        /// We keep `except_roles` sorted.
+        policy.except_roles = query_roles.except_roles;
+        if (query_roles.except_current_user)
+            policy.except_roles.push_back(context.getClientInfo().current_user);
+        boost::range::sort(policy.except_roles);
+        policy.except_roles.erase(std::unique(policy.except_roles.begin(), policy.except_roles.end()), policy.except_roles.end());
+    }
+}
+}
diff --git a/dbms/src/Interpreters/InterpreterCreateRowPolicyQuery.h b/dbms/src/Interpreters/InterpreterCreateRowPolicyQuery.h
new file mode 100644
index 00000000000..e7ee47dbe81
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterCreateRowPolicyQuery.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <Interpreters/IInterpreter.h>
+#include <Parsers/IAST_fwd.h>
+
+
+namespace DB
+{
+class ASTCreateRowPolicyQuery;
+struct RowPolicy;
+
+
+class InterpreterCreateRowPolicyQuery : public IInterpreter
+{
+public:
+    InterpreterCreateRowPolicyQuery(const ASTPtr & query_ptr_, Context & context_) : query_ptr(query_ptr_), context(context_) {}
+
+    BlockIO execute() override;
+
+private:
+    void updateRowPolicyFromQuery(RowPolicy & policy, const ASTCreateRowPolicyQuery & query);
+
+    ASTPtr query_ptr;
+    Context & context;
+};
+}
diff --git a/dbms/src/Interpreters/InterpreterDropAccessEntityQuery.cpp b/dbms/src/Interpreters/InterpreterDropAccessEntityQuery.cpp
index 7f18084038c..c8e7ab43a64 100644
--- a/dbms/src/Interpreters/InterpreterDropAccessEntityQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterDropAccessEntityQuery.cpp
@@ -3,6 +3,8 @@
 #include <Interpreters/Context.h>
 #include <Access/AccessControlManager.h>
 #include <Access/Quota.h>
+#include <Access/RowPolicy.h>
+#include <boost/range/algorithm/transform.hpp>
 
 
 namespace DB
@@ -24,6 +26,19 @@ BlockIO InterpreterDropAccessEntityQuery::execute()
                 access_control.remove(access_control.getIDs<Quota>(query.names));
             return {};
         }
+        case Kind::ROW_POLICY:
+        {
+            context.checkRowPolicyManagementIsAllowed();
+            Strings full_names;
+            boost::range::transform(
+                query.row_policies_names, std::back_inserter(full_names),
+                [this](const RowPolicy::FullNameParts & row_policy_name) { return row_policy_name.getFullName(context); });
+            if (query.if_exists)
+                access_control.tryRemove(access_control.find<RowPolicy>(full_names));
+            else
+                access_control.remove(access_control.getIDs<RowPolicy>(full_names));
+            return {};
+        }
     }
 
     __builtin_unreachable();
diff --git a/dbms/src/Interpreters/InterpreterFactory.cpp b/dbms/src/Interpreters/InterpreterFactory.cpp
index 33e9da95dfc..7d1eccd8581 100644
--- a/dbms/src/Interpreters/InterpreterFactory.cpp
+++ b/dbms/src/Interpreters/InterpreterFactory.cpp
@@ -2,6 +2,7 @@
 #include <Parsers/ASTCheckQuery.h>
 #include <Parsers/ASTCreateQuery.h>
 #include <Parsers/ASTCreateQuotaQuery.h>
+#include <Parsers/ASTCreateRowPolicyQuery.h>
 #include <Parsers/ASTDropAccessEntityQuery.h>
 #include <Parsers/ASTDropQuery.h>
 #include <Parsers/ASTInsertQuery.h>
@@ -14,6 +15,7 @@
 #include <Parsers/ASTShowCreateAccessEntityQuery.h>
 #include <Parsers/ASTShowProcesslistQuery.h>
 #include <Parsers/ASTShowQuotasQuery.h>
+#include <Parsers/ASTShowRowPoliciesQuery.h>
 #include <Parsers/ASTShowTablesQuery.h>
 #include <Parsers/ASTUseQuery.h>
 #include <Parsers/ASTExplainQuery.h>
@@ -24,6 +26,7 @@
 #include <Interpreters/InterpreterCheckQuery.h>
 #include <Interpreters/InterpreterCreateQuery.h>
 #include <Interpreters/InterpreterCreateQuotaQuery.h>
+#include <Interpreters/InterpreterCreateRowPolicyQuery.h>
 #include <Interpreters/InterpreterDescribeQuery.h>
 #include <Interpreters/InterpreterExplainQuery.h>
 #include <Interpreters/InterpreterDropAccessEntityQuery.h>
@@ -41,6 +44,7 @@
 #include <Interpreters/InterpreterShowCreateQuery.h>
 #include <Interpreters/InterpreterShowProcesslistQuery.h>
 #include <Interpreters/InterpreterShowQuotasQuery.h>
+#include <Interpreters/InterpreterShowRowPoliciesQuery.h>
 #include <Interpreters/InterpreterShowTablesQuery.h>
 #include <Interpreters/InterpreterSystemQuery.h>
 #include <Interpreters/InterpreterUseQuery.h>
@@ -199,6 +203,10 @@ std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, Context &
     {
         return std::make_unique<InterpreterCreateQuotaQuery>(query, context);
     }
+    else if (query->as<ASTCreateRowPolicyQuery>())
+    {
+        return std::make_unique<InterpreterCreateRowPolicyQuery>(query, context);
+    }
     else if (query->as<ASTDropAccessEntityQuery>())
     {
         return std::make_unique<InterpreterDropAccessEntityQuery>(query, context);
@@ -211,6 +219,10 @@ std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, Context &
     {
         return std::make_unique<InterpreterShowQuotasQuery>(query, context);
     }
+    else if (query->as<ASTShowRowPoliciesQuery>())
+    {
+        return std::make_unique<InterpreterShowRowPoliciesQuery>(query, context);
+    }
     else
         throw Exception("Unknown type of query: " + query->getID(), ErrorCodes::UNKNOWN_TYPE_OF_QUERY);
 }
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index 8b906472997..45ace212c68 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -38,6 +38,8 @@
 #include <Parsers/ExpressionListParsers.h>
 #include <Parsers/parseQuery.h>
 
+#include <Access/RowPolicyContext.h>
+
 #include <Interpreters/InterpreterSelectQuery.h>
 #include <Interpreters/InterpreterSelectWithUnionQuery.h>
 #include <Interpreters/InterpreterSetQuery.h>
@@ -118,11 +120,10 @@ namespace
 {
 
 /// Assumes `storage` is set and the table filter (row-level security) is not empty.
-String generateFilterActions(ExpressionActionsPtr & actions, const StoragePtr & storage, const Context & context, const Names & prerequisite_columns = {})
+String generateFilterActions(ExpressionActionsPtr & actions, const Context & context, const StoragePtr & storage, const ASTPtr & row_policy_filter, const Names & prerequisite_columns = {})
 {
     const auto & db_name = storage->getDatabaseName();
     const auto & table_name = storage->getTableName();
-    const auto & filter_str = context.getUserProperty(db_name, table_name, "filter");
 
     /// TODO: implement some AST builders for this kind of stuff
     ASTPtr query_ast = std::make_shared<ASTSelectQuery>();
@@ -131,18 +132,15 @@ String generateFilterActions(ExpressionActionsPtr & actions, const StoragePtr &
     select_ast->setExpression(ASTSelectQuery::Expression::SELECT, std::make_shared<ASTExpressionList>());
     auto expr_list = select_ast->select();
 
-    auto parseExpression = [] (const String & expr)
-    {
-        ParserExpression expr_parser;
-        return parseQuery(expr_parser, expr, 0);
-    };
-
     // The first column is our filter expression.
-    expr_list->children.push_back(parseExpression(filter_str));
+    expr_list->children.push_back(row_policy_filter);
 
     /// Keep columns that are required after the filter actions.
     for (const auto & column_str : prerequisite_columns)
-        expr_list->children.push_back(parseExpression(column_str));
+    {
+        ParserExpression expr_parser;
+        expr_list->children.push_back(parseQuery(expr_parser, column_str, 0));
+    }
 
     select_ast->setExpression(ASTSelectQuery::Expression::TABLES, std::make_shared<ASTTablesInSelectQuery>());
     auto tables = select_ast->tables();
@@ -372,10 +370,11 @@ InterpreterSelectQuery::InterpreterSelectQuery(
             source_header = storage->getSampleBlockForColumns(required_columns);
 
             /// Fix source_header for filter actions.
-            if (context->hasUserProperty(storage->getDatabaseName(), storage->getTableName(), "filter"))
+            auto row_policy_filter = context->getRowPolicy()->getCondition(storage->getDatabaseName(), storage->getTableName(), RowPolicy::SELECT_FILTER);
+            if (row_policy_filter)
             {
                 filter_info = std::make_shared<FilterInfo>();
-                filter_info->column_name = generateFilterActions(filter_info->actions, storage, *context, required_columns);
+                filter_info->column_name = generateFilterActions(filter_info->actions, *context, storage, row_policy_filter, required_columns);
                 source_header = storage->getSampleBlockForColumns(filter_info->actions->getRequiredColumns());
             }
         }
@@ -496,7 +495,7 @@ Block InterpreterSelectQuery::getSampleBlockImpl()
 
     /// PREWHERE optimization.
     /// Turn off, if the table filter (row-level security) is applied.
-    if (storage && !context->hasUserProperty(storage->getDatabaseName(), storage->getTableName(), "filter"))
+    if (storage && !context->getRowPolicy()->getCondition(storage->getDatabaseName(), storage->getTableName(), RowPolicy::SELECT_FILTER))
     {
         query_analyzer->makeSetsForIndex(query.where());
         query_analyzer->makeSetsForIndex(query.prewhere());
@@ -1357,11 +1356,12 @@ void InterpreterSelectQuery::executeFetchColumns(
     if (storage)
     {
         /// Append columns from the table filter to required
-        if (context->hasUserProperty(storage->getDatabaseName(), storage->getTableName(), "filter"))
+        auto row_policy_filter = context->getRowPolicy()->getCondition(storage->getDatabaseName(), storage->getTableName(), RowPolicy::SELECT_FILTER);
+        if (row_policy_filter)
         {
             auto initial_required_columns = required_columns;
             ExpressionActionsPtr actions;
-            generateFilterActions(actions, storage, *context, initial_required_columns);
+            generateFilterActions(actions, *context, storage, row_policy_filter, initial_required_columns);
             auto required_columns_from_filter = actions->getRequiredColumns();
 
             for (const auto & column : required_columns_from_filter)
diff --git a/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp b/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
index d0ef8992691..cf2a07425ba 100644
--- a/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp
@@ -1,9 +1,12 @@
 #include <Interpreters/InterpreterShowCreateAccessEntityQuery.h>
 #include <Interpreters/Context.h>
 #include <Parsers/ASTCreateQuotaQuery.h>
+#include <Parsers/ASTCreateRowPolicyQuery.h>
 #include <Parsers/ASTShowCreateAccessEntityQuery.h>
 #include <Parsers/ASTRoleList.h>
+#include <Parsers/ExpressionListParsers.h>
 #include <Parsers/formatAST.h>
+#include <Parsers/parseQuery.h>
 #include <Access/AccessControlManager.h>
 #include <Access/QuotaContext.h>
 #include <Columns/ColumnString.h>
@@ -28,7 +31,7 @@ BlockInputStreamPtr InterpreterShowCreateAccessEntityQuery::executeImpl()
     const auto & show_query = query_ptr->as<ASTShowCreateAccessEntityQuery &>();
 
     /// Build a create query.
-    ASTPtr create_query = getCreateQuotaQuery(show_query);
+    ASTPtr create_query = getCreateQuery(show_query);
 
     /// Build the result column.
     std::stringstream create_query_ss;
@@ -49,6 +52,18 @@ BlockInputStreamPtr InterpreterShowCreateAccessEntityQuery::executeImpl()
 }
 
 
+ASTPtr InterpreterShowCreateAccessEntityQuery::getCreateQuery(const ASTShowCreateAccessEntityQuery & show_query) const
+{
+    using Kind = ASTShowCreateAccessEntityQuery::Kind;
+    switch (show_query.kind)
+    {
+        case Kind::QUOTA: return getCreateQuotaQuery(show_query);
+        case Kind::ROW_POLICY: return getCreateRowPolicyQuery(show_query);
+    }
+    __builtin_unreachable();
+}
+
+
 ASTPtr InterpreterShowCreateAccessEntityQuery::getCreateQuotaQuery(const ASTShowCreateAccessEntityQuery & show_query) const
 {
     auto & access_control = context.getAccessControlManager();
@@ -86,4 +101,38 @@ ASTPtr InterpreterShowCreateAccessEntityQuery::getCreateQuotaQuery(const ASTShow
 
     return create_query;
 }
+
+
+ASTPtr InterpreterShowCreateAccessEntityQuery::getCreateRowPolicyQuery(const ASTShowCreateAccessEntityQuery & show_query) const
+{
+    auto & access_control = context.getAccessControlManager();
+    RowPolicyPtr policy = access_control.read<RowPolicy>(show_query.row_policy_name.getFullName(context));
+
+    auto create_query = std::make_shared<ASTCreateRowPolicyQuery>();
+    create_query->name_parts = RowPolicy::FullNameParts{policy->getDatabase(), policy->getTableName(), policy->getName()};
+    if (policy->isRestrictive())
+        create_query->is_restrictive = policy->isRestrictive();
+
+    for (auto index : ext::range_with_static_cast<RowPolicy::ConditionIndex>(RowPolicy::MAX_CONDITION_INDEX))
+    {
+        const auto & condition = policy->conditions[index];
+        if (!condition.empty())
+        {
+            ParserExpression parser;
+            ASTPtr expr = parseQuery(parser, condition, 0);
+            create_query->conditions.push_back(std::pair{index, expr});
+        }
+    }
+
+    if (!policy->roles.empty() || policy->all_roles)
+    {
+        auto create_query_roles = std::make_shared<ASTRoleList>();
+        create_query_roles->roles = policy->roles;
+        create_query_roles->all_roles = policy->all_roles;
+        create_query_roles->except_roles = policy->except_roles;
+        create_query->roles = std::move(create_query_roles);
+    }
+
+    return create_query;
+}
 }
diff --git a/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h b/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h
index 94b06dadb19..0a6d94b85d0 100644
--- a/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h
+++ b/dbms/src/Interpreters/InterpreterShowCreateAccessEntityQuery.h
@@ -28,7 +28,9 @@ private:
     const Context & context;
 
     BlockInputStreamPtr executeImpl();
+    ASTPtr getCreateQuery(const ASTShowCreateAccessEntityQuery & show_query) const;
     ASTPtr getCreateQuotaQuery(const ASTShowCreateAccessEntityQuery & show_query) const;
+    ASTPtr getCreateRowPolicyQuery(const ASTShowCreateAccessEntityQuery & show_query) const;
 };
 
 
diff --git a/dbms/src/Interpreters/InterpreterShowRowPoliciesQuery.cpp b/dbms/src/Interpreters/InterpreterShowRowPoliciesQuery.cpp
new file mode 100644
index 00000000000..4b9b80d91a8
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterShowRowPoliciesQuery.cpp
@@ -0,0 +1,68 @@
+#include <Interpreters/InterpreterShowRowPoliciesQuery.h>
+#include <Parsers/ASTShowRowPoliciesQuery.h>
+#include <Parsers/formatAST.h>
+#include <Interpreters/executeQuery.h>
+#include <Common/quoteString.h>
+#include <Interpreters/Context.h>
+#include <ext/range.h>
+
+
+namespace DB
+{
+InterpreterShowRowPoliciesQuery::InterpreterShowRowPoliciesQuery(const ASTPtr & query_ptr_, Context & context_)
+    : query_ptr(query_ptr_), context(context_)
+{
+}
+
+
+BlockIO InterpreterShowRowPoliciesQuery::execute()
+{
+    return executeQuery(getRewrittenQuery(), context, true);
+}
+
+
+String InterpreterShowRowPoliciesQuery::getRewrittenQuery() const
+{
+    const auto & query = query_ptr->as<ASTShowRowPoliciesQuery &>();
+
+    const String & table_name = query.table_name;
+    String database;
+    if (!table_name.empty())
+    {
+        database = query.database;
+        if (database.empty())
+            database = context.getCurrentDatabase();
+    }
+
+    String filter;
+    if (query.current)
+    {
+        if (table_name.empty())
+            filter = "has(currentRowPolicyIDs(), id)";
+        else
+            filter = "has(currentRowPolicyIDs(" + quoteString(database) + ", " + quoteString(table_name) + "), id)";
+    }
+    else
+    {
+        if (!table_name.empty())
+            filter = "database = " + quoteString(database) + " AND table = " + quoteString(table_name);
+    }
+
+    String expr = table_name.empty() ? "full_name" : "name";
+
+    return "SELECT " + expr + " AS " + backQuote(getResultDescription()) + " from system.row_policies"
+            + (filter.empty() ? "" : " WHERE " + filter) + " ORDER BY " + expr;
+}
+
+
+String InterpreterShowRowPoliciesQuery::getResultDescription() const
+{
+    std::stringstream ss;
+    formatAST(*query_ptr, ss, false, true);
+    String desc = ss.str();
+    String prefix = "SHOW ";
+    if (startsWith(desc, prefix))
+        desc = desc.substr(prefix.length()); /// `desc` always starts with "SHOW ", so we can trim this prefix.
+    return desc;
+}
+}
diff --git a/dbms/src/Interpreters/InterpreterShowRowPoliciesQuery.h b/dbms/src/Interpreters/InterpreterShowRowPoliciesQuery.h
new file mode 100644
index 00000000000..84cf6299b84
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterShowRowPoliciesQuery.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include <Interpreters/IInterpreter.h>
+#include <Parsers/IAST_fwd.h>
+
+
+namespace DB
+{
+class Context;
+
+class InterpreterShowRowPoliciesQuery : public IInterpreter
+{
+public:
+    InterpreterShowRowPoliciesQuery(const ASTPtr & query_ptr_, Context & context_);
+    BlockIO execute() override;
+
+private:
+    String getRewrittenQuery() const;
+    String getResultDescription() const;
+
+    ASTPtr query_ptr;
+    Context & context;
+};
+
+}
diff --git a/dbms/src/Interpreters/Users.cpp b/dbms/src/Interpreters/Users.cpp
index e66b5119f84..2b48ce56e3f 100644
--- a/dbms/src/Interpreters/Users.cpp
+++ b/dbms/src/Interpreters/Users.cpp
@@ -5,6 +5,7 @@
 #include <IO/ReadHelpers.h>
 #include <Interpreters/Users.h>
 #include <common/logger_useful.h>
+#include <Poco/MD5Engine.h>
 
 
 namespace DB
@@ -102,36 +103,10 @@ User::User(const String & name_, const String & config_elem, const Poco::Util::A
         }
     }
 
-    /// Read properties per "database.table"
-    /// Only tables are expected to have properties, so that all the keys inside "database" are table names.
-    const auto config_databases = config_elem + ".databases";
-    if (config.has(config_databases))
-    {
-        Poco::Util::AbstractConfiguration::Keys database_names;
-        config.keys(config_databases, database_names);
-
-        /// Read tables within databases
-        for (const auto & database : database_names)
-        {
-            const auto config_database = config_databases + "." + database;
-            Poco::Util::AbstractConfiguration::Keys table_names;
-            config.keys(config_database, table_names);
-
-            /// Read table properties
-            for (const auto & table : table_names)
-            {
-                const auto config_filter = config_database + "." + table + ".filter";
-                if (config.has(config_filter))
-                {
-                    const auto filter_query = config.getString(config_filter);
-                    table_props[database][table]["filter"] = filter_query;
-                }
-            }
-        }
-    }
-
     if (config.has(config_elem + ".allow_quota_management"))
         is_quota_management_allowed = config.getBool(config_elem + ".allow_quota_management");
+    if (config.has(config_elem + ".allow_row_policy_management"))
+        is_row_policy_management_allowed = config.getBool(config_elem + ".allow_row_policy_management");
 }
 
 }
diff --git a/dbms/src/Interpreters/Users.h b/dbms/src/Interpreters/Users.h
index 6f9a47c4422..f151770cefd 100644
--- a/dbms/src/Interpreters/Users.h
+++ b/dbms/src/Interpreters/Users.h
@@ -1,12 +1,13 @@
 #pragma once
 
 #include <Core/Types.h>
+#include <Core/UUID.h>
 #include <Access/Authentication.h>
 #include <Access/AllowedClientHosts.h>
 
 #include <memory>
-#include <unordered_map>
 #include <unordered_set>
+#include <vector>
 
 
 namespace Poco
@@ -41,13 +42,8 @@ struct User
     using DictionarySet = std::unordered_set<std::string>;
     std::optional<DictionarySet> dictionaries;
 
-    /// Table properties.
-    using PropertyMap = std::unordered_map<std::string /* name */, std::string /* value */>;
-    using TableMap = std::unordered_map<std::string /* table */, PropertyMap /* properties */>;
-    using DatabaseMap = std::unordered_map<std::string /* database */, TableMap /* tables */>;
-    DatabaseMap table_props;
-
     bool is_quota_management_allowed = false;
+    bool is_row_policy_management_allowed = false;
 
     User(const String & name_, const String & config_elem, const Poco::Util::AbstractConfiguration & config);
 };
diff --git a/dbms/src/Parsers/ASTCreateRowPolicyQuery.cpp b/dbms/src/Parsers/ASTCreateRowPolicyQuery.cpp
new file mode 100644
index 00000000000..50e1645f14b
--- /dev/null
+++ b/dbms/src/Parsers/ASTCreateRowPolicyQuery.cpp
@@ -0,0 +1,164 @@
+#include <Parsers/ASTCreateRowPolicyQuery.h>
+#include <Parsers/ASTRoleList.h>
+#include <Parsers/formatAST.h>
+#include <Common/quoteString.h>
+#include <boost/range/algorithm/transform.hpp>
+#include <sstream>
+
+
+namespace DB
+{
+namespace
+{
+    using ConditionIndex = RowPolicy::ConditionIndex;
+
+    void formatRenameTo(const String & new_policy_name, const IAST::FormatSettings & settings)
+    {
+        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " RENAME TO " << (settings.hilite ? IAST::hilite_none : "")
+                      << backQuote(new_policy_name);
+    }
+
+
+    void formatIsRestrictive(bool is_restrictive, const IAST::FormatSettings & settings)
+    {
+        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " AS " << (is_restrictive ? "RESTRICTIVE" : "PERMISSIVE")
+                      << (settings.hilite ? IAST::hilite_none : "");
+    }
+
+
+    void formatConditionalExpression(const ASTPtr & expr, const IAST::FormatSettings & settings)
+    {
+        if (!expr)
+        {
+            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " NONE" << (settings.hilite ? IAST::hilite_none : "");
+            return;
+        }
+        expr->format(settings);
+    }
+
+
+    std::vector<std::pair<ConditionIndex, String>>
+    conditionalExpressionsToStrings(const std::vector<std::pair<ConditionIndex, ASTPtr>> & exprs, const IAST::FormatSettings & settings)
+    {
+        std::vector<std::pair<ConditionIndex, String>> result;
+        std::stringstream ss;
+        IAST::FormatSettings temp_settings(ss, settings);
+        boost::range::transform(exprs, std::back_inserter(result), [&](const std::pair<ConditionIndex, ASTPtr> & in)
+        {
+            formatConditionalExpression(in.second, temp_settings);
+            auto out = std::pair{in.first, ss.str()};
+            ss.str("");
+            return out;
+        });
+        return result;
+    }
+
+
+    void formatConditions(const char * op, const std::optional<String> & filter, const std::optional<String> & check, bool alter, const IAST::FormatSettings & settings)
+    {
+        if (op)
+        {
+            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " FOR" << (settings.hilite ? IAST::hilite_none : "");
+            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << ' ' << op << (settings.hilite ? IAST::hilite_none : "");
+        }
+
+        if (filter)
+            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " USING " << (settings.hilite ? IAST::hilite_none : "") << *filter;
+
+        if (check && (alter || (check != filter)))
+            settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " WITH CHECK " << (settings.hilite ? IAST::hilite_none : "") << *check;
+    }
+
+
+    void formatMultipleConditions(const std::vector<std::pair<ConditionIndex, ASTPtr>> & conditions, bool alter, const IAST::FormatSettings & settings)
+    {
+        std::optional<String> scond[RowPolicy::MAX_CONDITION_INDEX];
+        for (const auto & [index, scondition] : conditionalExpressionsToStrings(conditions, settings))
+            scond[index] = scondition;
+
+        if ((scond[RowPolicy::SELECT_FILTER] == scond[RowPolicy::UPDATE_FILTER])
+            && (scond[RowPolicy::UPDATE_FILTER] == scond[RowPolicy::DELETE_FILTER])
+            && (scond[RowPolicy::INSERT_CHECK] == scond[RowPolicy::UPDATE_CHECK])
+            && (scond[RowPolicy::SELECT_FILTER] || scond[RowPolicy::INSERT_CHECK]))
+        {
+            formatConditions(nullptr, scond[RowPolicy::SELECT_FILTER], scond[RowPolicy::INSERT_CHECK], alter, settings);
+            return;
+        }
+
+        bool need_comma = false;
+        if (scond[RowPolicy::SELECT_FILTER])
+        {
+            if (std::exchange(need_comma, true))
+                settings.ostr << ',';
+            formatConditions("SELECT", scond[RowPolicy::SELECT_FILTER], {}, alter, settings);
+        }
+        if (scond[RowPolicy::INSERT_CHECK])
+        {
+            if (std::exchange(need_comma, true))
+                settings.ostr << ',';
+            formatConditions("INSERT", {}, scond[RowPolicy::INSERT_CHECK], alter, settings);
+        }
+        if (scond[RowPolicy::UPDATE_FILTER] || scond[RowPolicy::UPDATE_CHECK])
+        {
+            if (std::exchange(need_comma, true))
+                settings.ostr << ',';
+            formatConditions("UPDATE", scond[RowPolicy::UPDATE_FILTER], scond[RowPolicy::UPDATE_CHECK], alter, settings);
+        }
+        if (scond[RowPolicy::DELETE_FILTER])
+        {
+            if (std::exchange(need_comma, true))
+                settings.ostr << ',';
+            formatConditions("DELETE", scond[RowPolicy::DELETE_FILTER], {}, alter, settings);
+        }
+    }
+
+    void formatRoles(const ASTRoleList & roles, const IAST::FormatSettings & settings)
+    {
+        settings.ostr << (settings.hilite ? IAST::hilite_keyword : "") << " TO " << (settings.hilite ? IAST::hilite_none : "");
+        roles.format(settings);
+    }
+}
+
+
+String ASTCreateRowPolicyQuery::getID(char) const
+{
+    return "CREATE POLICY or ALTER POLICY query";
+}
+
+
+ASTPtr ASTCreateRowPolicyQuery::clone() const
+{
+    return std::make_shared<ASTCreateRowPolicyQuery>(*this);
+}
+
+
+void ASTCreateRowPolicyQuery::formatImpl(const FormatSettings & settings, FormatState &, FormatStateStacked) const
+{
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << (alter ? "ALTER POLICY" : "CREATE POLICY")
+                  << (settings.hilite ? hilite_none : "");
+
+    if (if_exists)
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " IF EXISTS" << (settings.hilite ? hilite_none : "");
+    else if (if_not_exists)
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " IF NOT EXISTS" << (settings.hilite ? hilite_none : "");
+    else if (or_replace)
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " OR REPLACE" << (settings.hilite ? hilite_none : "");
+
+    const String & database = name_parts.database;
+    const String & table_name = name_parts.table_name;
+    const String & policy_name = name_parts.policy_name;
+    settings.ostr << " " << backQuoteIfNeed(policy_name) << (settings.hilite ? hilite_keyword : "") << " ON "
+                  << (settings.hilite ? hilite_none : "") << (database.empty() ? String{} : backQuoteIfNeed(database) + ".") << table_name;
+
+    if (!new_policy_name.empty())
+        formatRenameTo(new_policy_name, settings);
+
+    if (is_restrictive)
+        formatIsRestrictive(*is_restrictive, settings);
+
+    formatMultipleConditions(conditions, alter, settings);
+
+    if (roles)
+        formatRoles(*roles, settings);
+}
+}
diff --git a/dbms/src/Parsers/ASTCreateRowPolicyQuery.h b/dbms/src/Parsers/ASTCreateRowPolicyQuery.h
new file mode 100644
index 00000000000..a4caf1aeb85
--- /dev/null
+++ b/dbms/src/Parsers/ASTCreateRowPolicyQuery.h
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <Parsers/IAST.h>
+#include <Access/RowPolicy.h>
+#include <utility>
+#include <vector>
+
+
+namespace DB
+{
+class ASTRoleList;
+
+/** CREATE [ROW] POLICY [IF NOT EXISTS | OR REPLACE] name ON [database.]table
+  *      [AS {PERMISSIVE | RESTRICTIVE}]
+  *      [FOR {SELECT | INSERT | UPDATE | DELETE | ALL}]
+  *      [USING condition]
+  *      [WITH CHECK condition] [,...]
+  *      [TO {role [,...] | ALL | ALL EXCEPT role [,...]}]
+  *
+  * ALTER [ROW] POLICY [IF EXISTS] name ON [database.]table
+  *      [RENAME TO new_name]
+  *      [AS {PERMISSIVE | RESTRICTIVE}]
+  *      [FOR {SELECT | INSERT | UPDATE | DELETE | ALL}]
+  *      [USING {condition | NONE}]
+  *      [WITH CHECK {condition | NONE}] [,...]
+  *      [TO {role [,...] | ALL | ALL EXCEPT role [,...]}]
+  */
+class ASTCreateRowPolicyQuery : public IAST
+{
+public:
+    bool alter = false;
+
+    bool if_exists = false;
+    bool if_not_exists = false;
+    bool or_replace = false;
+
+    RowPolicy::FullNameParts name_parts;
+    String new_policy_name;
+
+    std::optional<bool> is_restrictive;
+    using ConditionIndex = RowPolicy::ConditionIndex;
+    std::vector<std::pair<ConditionIndex, ASTPtr>> conditions;
+
+    std::shared_ptr<ASTRoleList> roles;
+
+    String getID(char) const override;
+    ASTPtr clone() const override;
+    void formatImpl(const FormatSettings & settings, FormatState &, FormatStateStacked) const override;
+};
+}
diff --git a/dbms/src/Parsers/ASTDropAccessEntityQuery.cpp b/dbms/src/Parsers/ASTDropAccessEntityQuery.cpp
index 80d69ed5316..b80dc47a9f7 100644
--- a/dbms/src/Parsers/ASTDropAccessEntityQuery.cpp
+++ b/dbms/src/Parsers/ASTDropAccessEntityQuery.cpp
@@ -13,6 +13,7 @@ namespace
         switch (kind)
         {
             case Kind::QUOTA: return "QUOTA";
+            case Kind::ROW_POLICY: return "POLICY";
         }
         __builtin_unreachable();
     }
@@ -44,13 +45,32 @@ void ASTDropAccessEntityQuery::formatImpl(const FormatSettings & settings, Forma
                   << (if_exists ? " IF EXISTS" : "")
                   << (settings.hilite ? hilite_none : "");
 
-    bool need_comma = false;
-    for (const auto & name : names)
+    if (kind == Kind::ROW_POLICY)
     {
-        if (need_comma)
-            settings.ostr << ',';
-        need_comma = true;
-        settings.ostr << ' ' << backQuoteIfNeed(name);
+        bool need_comma = false;
+        for (const auto & row_policy_name : row_policies_names)
+        {
+            if (need_comma)
+                settings.ostr << ',';
+            need_comma = true;
+            const String & database = row_policy_name.database;
+            const String & table_name = row_policy_name.table_name;
+            const String & policy_name = row_policy_name.policy_name;
+            settings.ostr << ' ' << backQuoteIfNeed(policy_name) << (settings.hilite ? hilite_keyword : "") << " ON "
+                          << (settings.hilite ? hilite_none : "") << (database.empty() ? String{} : backQuoteIfNeed(database) + ".")
+                          << backQuoteIfNeed(table_name);
+        }
+    }
+    else
+    {
+        bool need_comma = false;
+        for (const auto & name : names)
+        {
+            if (need_comma)
+                settings.ostr << ',';
+            need_comma = true;
+            settings.ostr << ' ' << backQuoteIfNeed(name);
+        }
     }
 }
 }
diff --git a/dbms/src/Parsers/ASTDropAccessEntityQuery.h b/dbms/src/Parsers/ASTDropAccessEntityQuery.h
index 91b76253db4..690a89995cf 100644
--- a/dbms/src/Parsers/ASTDropAccessEntityQuery.h
+++ b/dbms/src/Parsers/ASTDropAccessEntityQuery.h
@@ -1,12 +1,14 @@
 #pragma once
 
 #include <Parsers/IAST.h>
+#include <Access/RowPolicy.h>
 
 
 namespace DB
 {
 
 /** DROP QUOTA [IF EXISTS] name [,...]
+  * DROP [ROW] POLICY [IF EXISTS] name [,...] ON [database.]table [,...]
   */
 class ASTDropAccessEntityQuery : public IAST
 {
@@ -14,11 +16,13 @@ public:
     enum class Kind
     {
         QUOTA,
+        ROW_POLICY,
     };
     const Kind kind;
     const char * const keyword;
     bool if_exists = false;
     Strings names;
+    std::vector<RowPolicy::FullNameParts> row_policies_names;
 
     ASTDropAccessEntityQuery(Kind kind_);
     String getID(char) const override;
diff --git a/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.cpp b/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.cpp
index 8509a902014..caa9fb620e9 100644
--- a/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.cpp
+++ b/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.cpp
@@ -13,6 +13,7 @@ namespace
         switch (kind)
         {
             case Kind::QUOTA: return "QUOTA";
+            case Kind::ROW_POLICY: return "POLICY";
         }
         __builtin_unreachable();
     }
@@ -43,7 +44,16 @@ void ASTShowCreateAccessEntityQuery::formatQueryImpl(const FormatSettings & sett
                   << "SHOW CREATE " << keyword
                   << (settings.hilite ? hilite_none : "");
 
-    if (current_quota)
+    if (kind == Kind::ROW_POLICY)
+    {
+        const String & database = row_policy_name.database;
+        const String & table_name = row_policy_name.table_name;
+        const String & policy_name = row_policy_name.policy_name;
+        settings.ostr << ' ' << backQuoteIfNeed(policy_name) << (settings.hilite ? hilite_keyword : "") << " ON "
+                      << (settings.hilite ? hilite_none : "") << (database.empty() ? String{} : backQuoteIfNeed(database) + ".")
+                      << backQuoteIfNeed(table_name);
+    }
+    else if ((kind == Kind::QUOTA) && current_quota)
         settings.ostr << (settings.hilite ? hilite_keyword : "") << " CURRENT" << (settings.hilite ? hilite_none : "");
     else
         settings.ostr << " " << backQuoteIfNeed(name);
diff --git a/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.h b/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.h
index 32c0ace101b..c19f00b1d6e 100644
--- a/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.h
+++ b/dbms/src/Parsers/ASTShowCreateAccessEntityQuery.h
@@ -1,11 +1,13 @@
 #pragma once
 
 #include <Parsers/ASTQueryWithOutput.h>
+#include <Access/RowPolicy.h>
 
 
 namespace DB
 {
 /** SHOW CREATE QUOTA [name | CURRENT]
+  * SHOW CREATE [ROW] POLICY name ON [database.]table
   */
 class ASTShowCreateAccessEntityQuery : public ASTQueryWithOutput
 {
@@ -13,11 +15,13 @@ public:
     enum class Kind
     {
         QUOTA,
+        ROW_POLICY,
     };
     const Kind kind;
     const char * const keyword;
     String name;
     bool current_quota = false;
+    RowPolicy::FullNameParts row_policy_name;
 
     ASTShowCreateAccessEntityQuery(Kind kind_);
     String getID(char) const override;
diff --git a/dbms/src/Parsers/ASTShowRowPoliciesQuery.cpp b/dbms/src/Parsers/ASTShowRowPoliciesQuery.cpp
new file mode 100644
index 00000000000..15e0e81f218
--- /dev/null
+++ b/dbms/src/Parsers/ASTShowRowPoliciesQuery.cpp
@@ -0,0 +1,22 @@
+#include <Parsers/ASTShowRowPoliciesQuery.h>
+#include <Common/quoteString.h>
+
+
+namespace DB
+{
+void ASTShowRowPoliciesQuery::formatQueryImpl(const FormatSettings & settings, FormatState &, FormatStateStacked) const
+{
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << "SHOW POLICIES" << (settings.hilite ? hilite_none : "");
+
+    if (current)
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " CURRENT" << (settings.hilite ? hilite_none : "");
+
+    if (!table_name.empty())
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << " ON " << (settings.hilite ? hilite_none : "");
+        if (!database.empty())
+            settings.ostr << backQuoteIfNeed(database) << ".";
+        settings.ostr << backQuoteIfNeed(table_name);
+    }
+}
+}
diff --git a/dbms/src/Parsers/ASTShowRowPoliciesQuery.h b/dbms/src/Parsers/ASTShowRowPoliciesQuery.h
new file mode 100644
index 00000000000..ce82902e96d
--- /dev/null
+++ b/dbms/src/Parsers/ASTShowRowPoliciesQuery.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <Parsers/ASTQueryWithOutput.h>
+
+
+namespace DB
+{
+/// SHOW [ROW] POLICIES [CURRENT] [ON [database.]table]
+class ASTShowRowPoliciesQuery : public ASTQueryWithOutput
+{
+public:
+    bool current = false;
+    String database;
+    String table_name;
+
+    String getID(char) const override { return "SHOW POLICIES query"; }
+    ASTPtr clone() const override { return std::make_shared<ASTShowRowPoliciesQuery>(*this); }
+
+protected:
+    void formatQueryImpl(const FormatSettings & settings, FormatState &, FormatStateStacked) const override;
+};
+
+}
diff --git a/dbms/src/Parsers/ParserCreateRowPolicyQuery.cpp b/dbms/src/Parsers/ParserCreateRowPolicyQuery.cpp
new file mode 100644
index 00000000000..2778ddea93f
--- /dev/null
+++ b/dbms/src/Parsers/ParserCreateRowPolicyQuery.cpp
@@ -0,0 +1,261 @@
+#include <Parsers/ParserCreateRowPolicyQuery.h>
+#include <Parsers/ASTCreateRowPolicyQuery.h>
+#include <Access/RowPolicy.h>
+#include <Parsers/ParserRoleList.h>
+#include <Parsers/ASTRoleList.h>
+#include <Parsers/parseIdentifierOrStringLiteral.h>
+#include <Parsers/parseDatabaseAndTableName.h>
+#include <Parsers/ExpressionListParsers.h>
+#include <Parsers/ASTLiteral.h>
+
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int SYNTAX_ERROR;
+}
+
+
+namespace
+{
+    using ConditionIndex = RowPolicy::ConditionIndex;
+
+    bool parseRenameTo(IParserBase::Pos & pos, Expected & expected, String & new_policy_name, bool alter)
+    {
+        return IParserBase::wrapParseImpl(pos, [&]
+        {
+            if (!new_policy_name.empty() || !alter)
+                return false;
+
+            if (!ParserKeyword{"RENAME TO"}.ignore(pos, expected))
+                return false;
+
+            return parseIdentifierOrStringLiteral(pos, expected, new_policy_name);
+        });
+    }
+
+    bool parseIsRestrictive(IParserBase::Pos & pos, Expected & expected, std::optional<bool> & is_restrictive)
+    {
+        return IParserBase::wrapParseImpl(pos, [&]
+        {
+            if (is_restrictive)
+                return false;
+
+            if (!ParserKeyword{"AS"}.ignore(pos, expected))
+                return false;
+
+            if (ParserKeyword{"RESTRICTIVE"}.ignore(pos, expected))
+                is_restrictive = true;
+            else if (ParserKeyword{"PERMISSIVE"}.ignore(pos, expected))
+                is_restrictive = false;
+            else
+                return false;
+
+            return true;
+        });
+    }
+
+    bool parseConditionalExpression(IParserBase::Pos & pos, Expected & expected, std::optional<ASTPtr> & expr)
+    {
+        if (ParserKeyword("NONE").ignore(pos, expected))
+        {
+            expr = nullptr;
+            return true;
+        }
+        ParserExpression parser;
+        ASTPtr x;
+        if (parser.parse(pos, x, expected))
+        {
+            expr = x;
+            return true;
+        }
+        expr.reset();
+        return false;
+    }
+
+    bool parseConditions(IParserBase::Pos & pos, Expected & expected, std::vector<std::pair<ConditionIndex, ASTPtr>> & conditions, bool alter)
+    {
+        return IParserBase::wrapParseImpl(pos, [&]
+        {
+            static constexpr char select_op[] = "SELECT";
+            static constexpr char insert_op[] = "INSERT";
+            static constexpr char update_op[] = "UPDATE";
+            static constexpr char delete_op[] = "DELETE";
+            std::vector<const char *> ops;
+
+            bool keyword_for = false;
+            if (ParserKeyword{"FOR"}.ignore(pos, expected))
+            {
+                keyword_for = true;
+                do
+                {
+                    if (ParserKeyword{"SELECT"}.ignore(pos, expected))
+                        ops.push_back(select_op);
+                    else if (ParserKeyword{"INSERT"}.ignore(pos, expected))
+                        ops.push_back(insert_op);
+                    else if (ParserKeyword{"UPDATE"}.ignore(pos, expected))
+                        ops.push_back(update_op);
+                    else if (ParserKeyword{"DELETE"}.ignore(pos, expected))
+                        ops.push_back(delete_op);
+                    else if (ParserKeyword{"ALL"}.ignore(pos, expected))
+                    {
+                    }
+                    else
+                        return false;
+                }
+                while (ParserToken{TokenType::Comma}.ignore(pos, expected));
+            }
+
+            if (ops.empty())
+            {
+                ops.push_back(select_op);
+                ops.push_back(insert_op);
+                ops.push_back(update_op);
+                ops.push_back(delete_op);
+            }
+
+            std::optional<ASTPtr> filter;
+            std::optional<ASTPtr> check;
+            bool keyword_using = false, keyword_with_check = false;
+            if (ParserKeyword{"USING"}.ignore(pos, expected))
+            {
+                keyword_using = true;
+                if (!parseConditionalExpression(pos, expected, filter))
+                    return false;
+            }
+            if (ParserKeyword{"WITH CHECK"}.ignore(pos, expected))
+            {
+                keyword_with_check = true;
+                if (!parseConditionalExpression(pos, expected, check))
+                    return false;
+            }
+
+            if (!keyword_for && !keyword_using && !keyword_with_check)
+                return false;
+
+            if (filter && !check && !alter)
+                check = filter;
+
+            auto set_condition = [&](ConditionIndex index, const ASTPtr & condition)
+            {
+                auto it = std::find_if(conditions.begin(), conditions.end(), [index](const std::pair<ConditionIndex, ASTPtr> & element)
+                {
+                    return element.first == index;
+                });
+                if (it == conditions.end())
+                    it = conditions.insert(conditions.end(), std::pair<ConditionIndex, ASTPtr>{index, nullptr});
+                it->second = condition;
+            };
+
+            for (const auto & op : ops)
+            {
+                if ((op == select_op) && filter)
+                    set_condition(RowPolicy::SELECT_FILTER, *filter);
+                else if ((op == insert_op) && check)
+                    set_condition(RowPolicy::INSERT_CHECK, *check);
+                else if (op == update_op)
+                {
+                    if (filter)
+                        set_condition(RowPolicy::UPDATE_FILTER, *filter);
+                    if (check)
+                        set_condition(RowPolicy::UPDATE_CHECK, *check);
+                }
+                else if ((op == delete_op) && filter)
+                    set_condition(RowPolicy::DELETE_FILTER, *filter);
+                else
+                    __builtin_unreachable();
+            }
+
+            return true;
+        });
+    }
+
+    bool parseMultipleConditions(IParserBase::Pos & pos, Expected & expected, std::vector<std::pair<ConditionIndex, ASTPtr>> & conditions, bool alter)
+    {
+        return IParserBase::wrapParseImpl(pos, [&]
+        {
+            do
+            {
+                if (!parseConditions(pos, expected, conditions, alter))
+                    return false;
+            }
+            while (ParserToken{TokenType::Comma}.ignore(pos, expected));
+            return true;
+        });
+    }
+
+    bool parseRoles(IParserBase::Pos & pos, Expected & expected, std::shared_ptr<ASTRoleList> & roles)
+    {
+        return IParserBase::wrapParseImpl(pos, [&]
+        {
+            ASTPtr node;
+            if (roles || !ParserKeyword{"TO"}.ignore(pos, expected) || !ParserRoleList{}.parse(pos, node, expected))
+                return false;
+
+            roles = std::static_pointer_cast<ASTRoleList>(node);
+            return true;
+        });
+    }
+}
+
+
+bool ParserCreateRowPolicyQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
+{
+    bool alter;
+    if (ParserKeyword{"CREATE POLICY"}.ignore(pos, expected) || ParserKeyword{"CREATE ROW POLICY"}.ignore(pos, expected))
+        alter = false;
+    else if (ParserKeyword{"ALTER POLICY"}.ignore(pos, expected) || ParserKeyword{"ALTER ROW POLICY"}.ignore(pos, expected))
+        alter = true;
+    else
+        return false;
+
+    bool if_exists = false;
+    bool if_not_exists = false;
+    bool or_replace = false;
+    if (alter)
+    {
+        if (ParserKeyword{"IF EXISTS"}.ignore(pos, expected))
+            if_exists = true;
+    }
+    else
+    {
+        if (ParserKeyword{"IF NOT EXISTS"}.ignore(pos, expected))
+            if_not_exists = true;
+        else if (ParserKeyword{"OR REPLACE"}.ignore(pos, expected))
+            or_replace = true;
+    }
+
+    RowPolicy::FullNameParts name_parts;
+    String & database = name_parts.database;
+    String & table_name = name_parts.table_name;
+    String & policy_name = name_parts.policy_name;
+    if (!parseIdentifierOrStringLiteral(pos, expected, policy_name) || !ParserKeyword{"ON"}.ignore(pos, expected)
+        || !parseDatabaseAndTableName(pos, expected, database, table_name))
+        return false;
+
+    String new_policy_name;
+    std::optional<bool> is_restrictive;
+    std::vector<std::pair<ConditionIndex, ASTPtr>> conditions;
+    std::shared_ptr<ASTRoleList> roles;
+
+    while (parseRenameTo(pos, expected, new_policy_name, alter) || parseIsRestrictive(pos, expected, is_restrictive)
+           || parseMultipleConditions(pos, expected, conditions, alter) || parseRoles(pos, expected, roles))
+        ;
+
+    auto query = std::make_shared<ASTCreateRowPolicyQuery>();
+    node = query;
+
+    query->alter = alter;
+    query->if_exists = if_exists;
+    query->if_not_exists = if_not_exists;
+    query->or_replace = or_replace;
+    query->name_parts = std::move(name_parts);
+    query->new_policy_name = std::move(new_policy_name);
+    query->is_restrictive = is_restrictive;
+    query->conditions = std::move(conditions);
+    query->roles = std::move(roles);
+
+    return true;
+}
+}
diff --git a/dbms/src/Parsers/ParserCreateRowPolicyQuery.h b/dbms/src/Parsers/ParserCreateRowPolicyQuery.h
new file mode 100644
index 00000000000..2ec7ff37c94
--- /dev/null
+++ b/dbms/src/Parsers/ParserCreateRowPolicyQuery.h
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <Parsers/IParserBase.h>
+
+
+namespace DB
+{
+/** Parses queries like
+  * CREATE [ROW] POLICY [IF NOT EXISTS | OR REPLACE] name ON [database.]table
+  *      [AS {PERMISSIVE | RESTRICTIVE}]
+  *      [FOR {SELECT | INSERT | UPDATE | DELETE | ALL}]
+  *      [USING condition]
+  *      [WITH CHECK condition] [,...]
+  *      [TO {role [,...] | ALL | ALL EXCEPT role [,...]}]
+  *
+  * ALTER [ROW] POLICY [IF EXISTS] name ON [database.]table
+  *      [RENAME TO new_name]
+  *      [AS {PERMISSIVE | RESTRICTIVE}]
+  *      [FOR {SELECT | INSERT | UPDATE | DELETE | ALL}]
+  *      [USING {condition | NONE}]
+  *      [WITH CHECK {condition | NONE}] [,...]
+  *      [TO {role [,...] | ALL | ALL EXCEPT role [,...]}]
+  */
+class ParserCreateRowPolicyQuery : public IParserBase
+{
+protected:
+    const char * getName() const override { return "CREATE ROW POLICY or ALTER ROW POLICY query"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
+};
+}
diff --git a/dbms/src/Parsers/ParserDropAccessEntityQuery.cpp b/dbms/src/Parsers/ParserDropAccessEntityQuery.cpp
index c6d5ff889fc..1c34fd6edb6 100644
--- a/dbms/src/Parsers/ParserDropAccessEntityQuery.cpp
+++ b/dbms/src/Parsers/ParserDropAccessEntityQuery.cpp
@@ -2,11 +2,30 @@
 #include <Parsers/ASTDropAccessEntityQuery.h>
 #include <Parsers/CommonParsers.h>
 #include <Parsers/parseIdentifierOrStringLiteral.h>
+#include <Parsers/parseDatabaseAndTableName.h>
 #include <Access/Quota.h>
 
 
 namespace DB
 {
+namespace
+{
+    bool parseNames(IParserBase::Pos & pos, Expected & expected, Strings & names)
+    {
+        do
+        {
+            String name;
+            if (!parseIdentifierOrStringLiteral(pos, expected, name))
+                return false;
+
+            names.push_back(std::move(name));
+        }
+        while (ParserToken{TokenType::Comma}.ignore(pos, expected));
+        return true;
+    }
+}
+
+
 bool ParserDropAccessEntityQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
     if (!ParserKeyword{"DROP"}.ignore(pos, expected))
@@ -16,6 +35,8 @@ bool ParserDropAccessEntityQuery::parseImpl(Pos & pos, ASTPtr & node, Expected &
     Kind kind;
     if (ParserKeyword{"QUOTA"}.ignore(pos, expected))
         kind = Kind::QUOTA;
+    else if (ParserKeyword{"POLICY"}.ignore(pos, expected) || ParserKeyword{"ROW POLICY"}.ignore(pos, expected))
+        kind = Kind::ROW_POLICY;
     else
         return false;
 
@@ -24,21 +45,35 @@ bool ParserDropAccessEntityQuery::parseImpl(Pos & pos, ASTPtr & node, Expected &
         if_exists = true;
 
     Strings names;
-    do
-    {
-        String name;
-        if (!parseIdentifierOrStringLiteral(pos, expected, name))
-            return false;
+    std::vector<RowPolicy::FullNameParts> row_policies_names;
 
-        names.push_back(std::move(name));
+    if (kind == Kind::ROW_POLICY)
+    {
+        do
+        {
+            Strings policy_names;
+            if (!parseNames(pos, expected, policy_names))
+                return false;
+            String database, table_name;
+            if (!ParserKeyword{"ON"}.ignore(pos, expected) || !parseDatabaseAndTableName(pos, expected, database, table_name))
+                return false;
+            for (const String & policy_name : policy_names)
+                row_policies_names.push_back({database, table_name, policy_name});
+        }
+        while (ParserToken{TokenType::Comma}.ignore(pos, expected));
+    }
+    else
+    {
+        if (!parseNames(pos, expected, names))
+            return false;
     }
-    while (ParserToken{TokenType::Comma}.ignore(pos, expected));
 
     auto query = std::make_shared<ASTDropAccessEntityQuery>(kind);
     node = query;
 
     query->if_exists = if_exists;
     query->names = std::move(names);
+    query->row_policies_names = std::move(row_policies_names);
 
     return true;
 }
diff --git a/dbms/src/Parsers/ParserQuery.cpp b/dbms/src/Parsers/ParserQuery.cpp
index a3bb652032e..d5002794734 100644
--- a/dbms/src/Parsers/ParserQuery.cpp
+++ b/dbms/src/Parsers/ParserQuery.cpp
@@ -10,6 +10,7 @@
 #include <Parsers/ParserAlterQuery.h>
 #include <Parsers/ParserSystemQuery.h>
 #include <Parsers/ParserCreateQuotaQuery.h>
+#include <Parsers/ParserCreateRowPolicyQuery.h>
 #include <Parsers/ParserDropAccessEntityQuery.h>
 
 
@@ -25,6 +26,7 @@ bool ParserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ParserSetQuery set_p;
     ParserSystemQuery system_p;
     ParserCreateQuotaQuery create_quota_p;
+    ParserCreateRowPolicyQuery create_row_policy_p;
     ParserDropAccessEntityQuery drop_access_entity_p;
 
     bool res = query_with_output_p.parse(pos, node, expected)
@@ -33,6 +35,7 @@ bool ParserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
         || set_p.parse(pos, node, expected)
         || system_p.parse(pos, node, expected)
         || create_quota_p.parse(pos, node, expected)
+        || create_row_policy_p.parse(pos, node, expected)
         || drop_access_entity_p.parse(pos, node, expected);
 
     return res;
diff --git a/dbms/src/Parsers/ParserQueryWithOutput.cpp b/dbms/src/Parsers/ParserQueryWithOutput.cpp
index d08ae984c90..31948194976 100644
--- a/dbms/src/Parsers/ParserQueryWithOutput.cpp
+++ b/dbms/src/Parsers/ParserQueryWithOutput.cpp
@@ -16,6 +16,7 @@
 #include <Parsers/ASTExplainQuery.h>
 #include <Parsers/ParserShowCreateAccessEntityQuery.h>
 #include <Parsers/ParserShowQuotasQuery.h>
+#include <Parsers/ParserShowRowPoliciesQuery.h>
 
 
 namespace DB
@@ -38,6 +39,7 @@ bool ParserQueryWithOutput::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
     ParserWatchQuery watch_p;
     ParserShowCreateAccessEntityQuery show_create_access_entity_p;
     ParserShowQuotasQuery show_quotas_p;
+    ParserShowRowPoliciesQuery show_row_policies_p;
 
     ASTPtr query;
 
@@ -66,7 +68,8 @@ bool ParserQueryWithOutput::parseImpl(Pos & pos, ASTPtr & node, Expected & expec
         || kill_query_p.parse(pos, query, expected)
         || optimize_p.parse(pos, query, expected)
         || watch_p.parse(pos, query, expected)
-        || show_quotas_p.parse(pos, query, expected);
+        || show_quotas_p.parse(pos, query, expected)
+        || show_row_policies_p.parse(pos, query, expected);
 
     if (!parsed)
         return false;
diff --git a/dbms/src/Parsers/ParserShowCreateAccessEntityQuery.cpp b/dbms/src/Parsers/ParserShowCreateAccessEntityQuery.cpp
index 661330ffd0b..0caba5e0495 100644
--- a/dbms/src/Parsers/ParserShowCreateAccessEntityQuery.cpp
+++ b/dbms/src/Parsers/ParserShowCreateAccessEntityQuery.cpp
@@ -2,6 +2,8 @@
 #include <Parsers/ASTShowCreateAccessEntityQuery.h>
 #include <Parsers/CommonParsers.h>
 #include <Parsers/parseIdentifierOrStringLiteral.h>
+#include <Parsers/parseDatabaseAndTableName.h>
+#include <assert.h>
 
 
 namespace DB
@@ -15,25 +17,41 @@ bool ParserShowCreateAccessEntityQuery::parseImpl(Pos & pos, ASTPtr & node, Expe
     Kind kind;
     if (ParserKeyword{"QUOTA"}.ignore(pos, expected))
         kind = Kind::QUOTA;
+    else if (ParserKeyword{"POLICY"}.ignore(pos, expected) || ParserKeyword{"ROW POLICY"}.ignore(pos, expected))
+        kind = Kind::ROW_POLICY;
     else
         return false;
 
     String name;
     bool current_quota = false;
+    RowPolicy::FullNameParts row_policy_name;
 
-    if ((kind == Kind::QUOTA) && ParserKeyword{"CURRENT"}.ignore(pos, expected))
+    if (kind == Kind::ROW_POLICY)
     {
-        /// SHOW CREATE QUOTA CURRENT
-        current_quota = true;
-    }
-    else if (parseIdentifierOrStringLiteral(pos, expected, name))
-    {
-        /// SHOW CREATE QUOTA name
+        String & database = row_policy_name.database;
+        String & table_name = row_policy_name.table_name;
+        String & policy_name = row_policy_name.policy_name;
+        if (!parseIdentifierOrStringLiteral(pos, expected, policy_name) || !ParserKeyword{"ON"}.ignore(pos, expected)
+            || !parseDatabaseAndTableName(pos, expected, database, table_name))
+            return false;
     }
     else
     {
-        /// SHOW CREATE QUOTA
-        current_quota = true;
+        assert(kind == Kind::QUOTA);
+        if (ParserKeyword{"CURRENT"}.ignore(pos, expected))
+        {
+            /// SHOW CREATE QUOTA CURRENT
+            current_quota = true;
+        }
+        else if (parseIdentifierOrStringLiteral(pos, expected, name))
+        {
+            /// SHOW CREATE QUOTA name
+        }
+        else
+        {
+            /// SHOW CREATE QUOTA
+            current_quota = true;
+        }
     }
 
     auto query = std::make_shared<ASTShowCreateAccessEntityQuery>(kind);
@@ -41,6 +59,7 @@ bool ParserShowCreateAccessEntityQuery::parseImpl(Pos & pos, ASTPtr & node, Expe
 
     query->name = std::move(name);
     query->current_quota = current_quota;
+    query->row_policy_name = std::move(row_policy_name);
 
     return true;
 }
diff --git a/dbms/src/Parsers/ParserShowRowPoliciesQuery.cpp b/dbms/src/Parsers/ParserShowRowPoliciesQuery.cpp
new file mode 100644
index 00000000000..b07e7a386ba
--- /dev/null
+++ b/dbms/src/Parsers/ParserShowRowPoliciesQuery.cpp
@@ -0,0 +1,40 @@
+#include <Parsers/ParserShowRowPoliciesQuery.h>
+#include <Parsers/ASTShowRowPoliciesQuery.h>
+#include <Parsers/CommonParsers.h>
+#include <Parsers/parseDatabaseAndTableName.h>
+
+
+namespace DB
+{
+namespace
+{
+    bool parseONDatabaseAndTableName(IParserBase::Pos & pos, Expected & expected, String & database, String & table_name)
+    {
+        return IParserBase::wrapParseImpl(pos, [&]
+        {
+            database.clear();
+            table_name.clear();
+            return ParserKeyword{"ON"}.ignore(pos, expected) && parseDatabaseAndTableName(pos, expected, database, table_name);
+        });
+    }
+}
+
+
+bool ParserShowRowPoliciesQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
+{
+    if (!ParserKeyword{"SHOW POLICIES"}.ignore(pos, expected) && !ParserKeyword{"SHOW ROW POLICIES"}.ignore(pos, expected))
+        return false;
+
+    bool current = ParserKeyword{"CURRENT"}.ignore(pos, expected);
+
+    String database, table_name;
+    parseONDatabaseAndTableName(pos, expected, database, table_name);
+
+    auto query = std::make_shared<ASTShowRowPoliciesQuery>();
+    query->current = current;
+    query->database = std::move(database);
+    query->table_name = std::move(table_name);
+    node = query;
+    return true;
+}
+}
diff --git a/dbms/src/Parsers/ParserShowRowPoliciesQuery.h b/dbms/src/Parsers/ParserShowRowPoliciesQuery.h
new file mode 100644
index 00000000000..df7413fb604
--- /dev/null
+++ b/dbms/src/Parsers/ParserShowRowPoliciesQuery.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <Parsers/IParserBase.h>
+
+
+namespace DB
+{
+/** Parses queries like
+  * SHOW [ROW] POLICIES [CURRENT] [ON [database.]table]
+  */
+class ParserShowRowPoliciesQuery : public IParserBase
+{
+protected:
+    const char * getName() const override { return "SHOW POLICIES query"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
+};
+}
diff --git a/dbms/src/Processors/Formats/IInputFormat.h b/dbms/src/Processors/Formats/IInputFormat.h
index 7fa6859da9f..00cb38405cf 100644
--- a/dbms/src/Processors/Formats/IInputFormat.h
+++ b/dbms/src/Processors/Formats/IInputFormat.h
@@ -27,7 +27,7 @@ public:
 
     /** In some usecase (hello Kafka) we need to read a lot of tiny streams in exactly the same format.
      * The recreating of parser for each small stream takes too long, so we introduce a method
-     * resetParser() which allow to reset the state of parser to continure reading of
+     * resetParser() which allow to reset the state of parser to continue reading of
      * source stream w/o recreating that.
      * That should be called after current buffer was fully read.
      */
diff --git a/dbms/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp b/dbms/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp
index d9b5fbc330e..42a94ea0bf9 100644
--- a/dbms/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp
+++ b/dbms/src/Processors/Transforms/MergingAggregatedMemoryEfficientTransform.cpp
@@ -429,21 +429,30 @@ IProcessor::Status SortingAggregatedTransform::prepare()
             continue;
         }
 
-        all_finished = false;
+        //all_finished = false;
 
         in->setNeeded();
 
         if (!in->hasData())
         {
             need_data = true;
+            all_finished = false;
             continue;
         }
 
         auto chunk = in->pull();
-        /// If chunk was pulled, then we need data from this port.
-        need_data = true;
-
         addChunk(std::move(chunk), input_num);
+
+        if (in->isFinished())
+        {
+            is_input_finished[input_num] = true;
+        }
+        else
+        {
+            /// If chunk was pulled, then we need data from this port.
+            need_data = true;
+            all_finished = false;
+        }
     }
 
     if (pushed_to_output)
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 87e6ff6bebe..94c96839ec7 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -638,11 +638,22 @@ void MergeTreeData::setTTLExpressions(const ColumnsDescription::ColumnTTLs & new
             else
             {
                 auto new_ttl_entry = create_ttl_entry(ttl_element.children[0]);
+
+                new_ttl_entry.entry_ast = ttl_element_ptr;
+                new_ttl_entry.destination_type = ttl_element.destination_type;
+                new_ttl_entry.destination_name = ttl_element.destination_name;
+                if (!new_ttl_entry.getDestination(getStoragePolicy()))
+                {
+                    String message;
+                    if (new_ttl_entry.destination_type == PartDestinationType::DISK)
+                        message = "No such disk " + backQuote(new_ttl_entry.destination_name) + " for given storage policy.";
+                    else
+                        message = "No such volume " + backQuote(new_ttl_entry.destination_name) + " for given storage policy.";
+                    throw Exception(message, ErrorCodes::BAD_TTL_EXPRESSION);
+                }
+
                 if (!only_check)
                 {
-                    new_ttl_entry.entry_ast = ttl_element_ptr;
-                    new_ttl_entry.destination_type = ttl_element.destination_type;
-                    new_ttl_entry.destination_name = ttl_element.destination_name;
                     move_ttl_entries.emplace_back(std::move(new_ttl_entry));
                 }
             }
diff --git a/dbms/src/Storages/StorageJoin.cpp b/dbms/src/Storages/StorageJoin.cpp
index 954d096cbd7..232e2201536 100644
--- a/dbms/src/Storages/StorageJoin.cpp
+++ b/dbms/src/Storages/StorageJoin.cpp
@@ -140,35 +140,36 @@ void registerStorageJoin(StorageFactory & factory)
         {
             const String strictness_str = Poco::toLower(*opt_strictness_id);
 
-            if (strictness_str == "any" || strictness_str == "\'any\'")
+            if (strictness_str == "any")
             {
                 if (old_any_join)
                     strictness = ASTTableJoin::Strictness::RightAny;
                 else
                     strictness = ASTTableJoin::Strictness::Any;
             }
-            else if (strictness_str == "all" || strictness_str == "\'all\'")
+            else if (strictness_str == "all")
                 strictness = ASTTableJoin::Strictness::All;
-            else if (strictness_str == "semi" || strictness_str == "\'semi\'")
+            else if (strictness_str == "semi")
                 strictness = ASTTableJoin::Strictness::Semi;
-            else if (strictness_str == "anti" || strictness_str == "\'anti\'")
+            else if (strictness_str == "anti")
                 strictness = ASTTableJoin::Strictness::Anti;
         }
 
         if (strictness == ASTTableJoin::Strictness::Unspecified)
-            throw Exception("First parameter of storage Join must be ANY or ALL or SEMI or ANTI.", ErrorCodes::BAD_ARGUMENTS);
+            throw Exception("First parameter of storage Join must be ANY or ALL or SEMI or ANTI (without quotes).",
+                            ErrorCodes::BAD_ARGUMENTS);
 
         if (auto opt_kind_id = tryGetIdentifierName(engine_args[1]))
         {
             const String kind_str = Poco::toLower(*opt_kind_id);
 
-            if (kind_str == "left" || kind_str == "\'left\'")
+            if (kind_str == "left")
                 kind = ASTTableJoin::Kind::Left;
-            else if (kind_str == "inner" || kind_str == "\'inner\'")
+            else if (kind_str == "inner")
                 kind = ASTTableJoin::Kind::Inner;
-            else if (kind_str == "right" || kind_str == "\'right\'")
+            else if (kind_str == "right")
                 kind = ASTTableJoin::Kind::Right;
-            else if (kind_str == "full" || kind_str == "\'full\'")
+            else if (kind_str == "full")
             {
                 if (strictness == ASTTableJoin::Strictness::Any)
                     strictness = ASTTableJoin::Strictness::RightAny;
@@ -177,7 +178,8 @@ void registerStorageJoin(StorageFactory & factory)
         }
 
         if (kind == ASTTableJoin::Kind::Comma)
-            throw Exception("Second parameter of storage Join must be LEFT or INNER or RIGHT or FULL.", ErrorCodes::BAD_ARGUMENTS);
+            throw Exception("Second parameter of storage Join must be LEFT or INNER or RIGHT or FULL (without quotes).",
+                            ErrorCodes::BAD_ARGUMENTS);
 
         Names key_names;
         key_names.reserve(engine_args.size() - 2);
diff --git a/dbms/src/Storages/StorageURL.cpp b/dbms/src/Storages/StorageURL.cpp
index 06b8aaf70e3..907e18b21cf 100644
--- a/dbms/src/Storages/StorageURL.cpp
+++ b/dbms/src/Storages/StorageURL.cpp
@@ -196,7 +196,7 @@ BlockInputStreams IStorageURLBase::read(const Names & column_names,
         context,
         max_block_size,
         ConnectionTimeouts::getHTTPTimeouts(context),
-        IStorage::chooseCompressionMethod(request_uri.toString(), compression_method));
+        IStorage::chooseCompressionMethod(request_uri.getPath(), compression_method));
 
     auto column_defaults = getColumns().getDefaults();
     if (column_defaults.empty())
diff --git a/dbms/src/Storages/System/StorageSystemRowPolicies.cpp b/dbms/src/Storages/System/StorageSystemRowPolicies.cpp
new file mode 100644
index 00000000000..8ac4ac1b755
--- /dev/null
+++ b/dbms/src/Storages/System/StorageSystemRowPolicies.cpp
@@ -0,0 +1,59 @@
+#include <Storages/System/StorageSystemRowPolicies.h>
+#include <DataTypes/DataTypeString.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeUUID.h>
+#include <DataTypes/DataTypeDateTime.h>
+#include <DataTypes/DataTypeNullable.h>
+#include <Interpreters/Context.h>
+#include <Access/AccessControlManager.h>
+#include <Access/RowPolicy.h>
+#include <ext/range.h>
+
+
+namespace DB
+{
+NamesAndTypesList StorageSystemRowPolicies::getNamesAndTypes()
+{
+    NamesAndTypesList names_and_types{
+        {"database", std::make_shared<DataTypeString>()},
+        {"table", std::make_shared<DataTypeString>()},
+        {"name", std::make_shared<DataTypeString>()},
+        {"full_name", std::make_shared<DataTypeString>()},
+        {"id", std::make_shared<DataTypeUUID>()},
+        {"source", std::make_shared<DataTypeString>()},
+        {"restrictive", std::make_shared<DataTypeUInt8>()},
+    };
+
+    for (auto index : ext::range_with_static_cast<RowPolicy::ConditionIndex>(RowPolicy::MAX_CONDITION_INDEX))
+        names_and_types.push_back({RowPolicy::conditionIndexToColumnName(index), std::make_shared<DataTypeString>()});
+
+    return names_and_types;
+}
+
+
+void StorageSystemRowPolicies::fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const
+{
+    const auto & access_control = context.getAccessControlManager();
+    std::vector<UUID> ids = access_control.findAll<RowPolicy>();
+
+    for (const auto & id : ids)
+    {
+        auto policy = access_control.tryRead<RowPolicy>(id);
+        if (!policy)
+            continue;
+        const auto * storage = access_control.findStorage(id);
+
+        size_t i = 0;
+        res_columns[i++]->insert(policy->getDatabase());
+        res_columns[i++]->insert(policy->getTableName());
+        res_columns[i++]->insert(policy->getName());
+        res_columns[i++]->insert(policy->getFullName());
+        res_columns[i++]->insert(id);
+        res_columns[i++]->insert(storage ? storage->getStorageName() : "");
+        res_columns[i++]->insert(policy->isRestrictive());
+
+        for (auto index : ext::range(RowPolicy::MAX_CONDITION_INDEX))
+            res_columns[i++]->insert(policy->conditions[index]);
+    }
+}
+}
diff --git a/dbms/src/Storages/System/StorageSystemRowPolicies.h b/dbms/src/Storages/System/StorageSystemRowPolicies.h
new file mode 100644
index 00000000000..c28342eb18c
--- /dev/null
+++ b/dbms/src/Storages/System/StorageSystemRowPolicies.h
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <ext/shared_ptr_helper.h>
+#include <Storages/System/IStorageSystemOneBlock.h>
+
+
+namespace DB
+{
+
+class Context;
+
+
+/// Implements `row_policies` system table, which allows you to get information about row policies.
+class StorageSystemRowPolicies : public ext::shared_ptr_helper<StorageSystemRowPolicies>, public IStorageSystemOneBlock<StorageSystemRowPolicies>
+{
+public:
+    std::string getName() const override { return "SystemRowPolicies"; }
+    static NamesAndTypesList getNamesAndTypes();
+
+protected:
+    friend struct ext::shared_ptr_helper<StorageSystemRowPolicies>;
+    using IStorageSystemOneBlock::IStorageSystemOneBlock;
+    void fillData(MutableColumns & res_columns, const Context & context, const SelectQueryInfo &) const override;
+};
+
+}
diff --git a/dbms/src/Storages/System/attachSystemTables.cpp b/dbms/src/Storages/System/attachSystemTables.cpp
index fc3a36d7c2c..06f00783384 100644
--- a/dbms/src/Storages/System/attachSystemTables.cpp
+++ b/dbms/src/Storages/System/attachSystemTables.cpp
@@ -29,6 +29,7 @@
 #include <Storages/System/StorageSystemQuotaUsage.h>
 #include <Storages/System/StorageSystemReplicas.h>
 #include <Storages/System/StorageSystemReplicationQueue.h>
+#include <Storages/System/StorageSystemRowPolicies.h>
 #include <Storages/System/StorageSystemSettings.h>
 #include <Storages/System/StorageSystemMergeTreeSettings.h>
 #include <Storages/System/StorageSystemTableEngines.h>
@@ -60,6 +61,7 @@ void attachSystemTablesLocal(IDatabase & system_database)
     system_database.attachTable("settings", StorageSystemSettings::create("settings"));
     system_database.attachTable("quotas", StorageSystemQuotas::create("quotas"));
     system_database.attachTable("quota_usage", StorageSystemQuotaUsage::create("quota_usage"));
+    system_database.attachTable("row_policies", StorageSystemRowPolicies::create("row_policies"));
     system_database.attachTable("merge_tree_settings", SystemMergeTreeSettings::create("merge_tree_settings"));
     system_database.attachTable("build_options", StorageSystemBuildOptions::create("build_options"));
     system_database.attachTable("formats", StorageSystemFormats::create("formats"));
diff --git a/dbms/tests/integration/test_row_policy/__init__.py b/dbms/tests/integration/test_row_policy/__init__.py
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/integration/test_row_policy/all_rows.xml b/dbms/tests/integration/test_row_policy/all_rows.xml
new file mode 100644
index 00000000000..d00db61482c
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/all_rows.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<yandex>
+    <users>
+        <default>
+            <!-- Allows all rows -->
+            <databases>
+                <mydb>
+                    <filtered_table1>
+                        <filter>1</filter>
+                    </filtered_table1>
+
+                    <filtered_table2>
+                        <filter>1</filter>
+                    </filtered_table2>
+
+                    <filtered_table3>
+                        <filter>1</filter>
+                    </filtered_table3>
+                </mydb>
+            </databases>
+        </default>
+    </users>
+</yandex>
diff --git a/dbms/tests/integration/test_row_policy/configs/users.d/row_policy.xml b/dbms/tests/integration/test_row_policy/configs/users.d/row_policy.xml
new file mode 120000
index 00000000000..593f0e42662
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/configs/users.d/row_policy.xml
@@ -0,0 +1 @@
+../../normal_filters.xml
\ No newline at end of file
diff --git a/dbms/tests/integration/test_row_policy/configs/users.xml b/dbms/tests/integration/test_row_policy/configs/users.xml
new file mode 100644
index 00000000000..c86ab1f15a1
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/configs/users.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<yandex>
+    <profiles>
+        <default>
+            <any_join_distinct_right_table_keys>1</any_join_distinct_right_table_keys>
+        </default>
+    </profiles>
+    <users>
+        <default>
+            <password></password>
+            <networks incl="networks" replace="replace">
+                <ip>::/0</ip>
+            </networks>
+            <profile>default</profile>
+            <quota>default</quota>
+            <allow_row_policy_management>true</allow_row_policy_management>
+        </default>
+    </users>
+    <quotas>
+        <default>
+        </default>
+    </quotas>
+</yandex>
diff --git a/dbms/tests/integration/test_row_policy/no_filters.xml b/dbms/tests/integration/test_row_policy/no_filters.xml
new file mode 100644
index 00000000000..9aba4ac0914
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/no_filters.xml
@@ -0,0 +1,3 @@
+<?xml version="1.0"?>
+<yandex>
+</yandex>
diff --git a/dbms/tests/integration/test_row_policy/no_rows.xml b/dbms/tests/integration/test_row_policy/no_rows.xml
new file mode 100644
index 00000000000..904d94b13fb
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/no_rows.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<yandex>
+    <users>
+        <default>
+            <!-- Allows no rows -->
+            <databases>
+                <mydb>
+                    <filtered_table1>
+                        <filter>NULL</filter>
+                    </filtered_table1>
+
+                    <filtered_table2>
+                        <filter>NULL</filter>
+                    </filtered_table2>
+
+                    <filtered_table3>
+                        <filter>NULL</filter>
+                    </filtered_table3>
+                </mydb>
+            </databases>
+        </default>
+    </users>
+</yandex>
diff --git a/dbms/tests/integration/test_row_policy/normal_filters.xml b/dbms/tests/integration/test_row_policy/normal_filters.xml
new file mode 100644
index 00000000000..ddd84e43ac7
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/normal_filters.xml
@@ -0,0 +1,26 @@
+<?xml version="1.0"?>
+<yandex>
+    <users>
+        <default>
+            <!-- For testing the table filters -->
+            <databases>
+                <mydb>
+                    <!-- Simple expression filter -->
+                    <filtered_table1>
+                        <filter>a = 1</filter>
+                    </filtered_table1>
+
+                    <!-- Complex expression filter -->
+                    <filtered_table2>
+                        <filter>a + b &lt; 1 or c - d &gt; 5</filter>
+                    </filtered_table2>
+
+                    <!-- Filter with ALIAS column -->
+                    <filtered_table3>
+                        <filter>c = 1</filter>
+                    </filtered_table3>
+                </mydb>
+            </databases>
+        </default>
+    </users>
+</yandex>
diff --git a/dbms/tests/integration/test_row_policy/test.py b/dbms/tests/integration/test_row_policy/test.py
new file mode 100644
index 00000000000..421a4b0510c
--- /dev/null
+++ b/dbms/tests/integration/test_row_policy/test.py
@@ -0,0 +1,209 @@
+import pytest
+from helpers.cluster import ClickHouseCluster
+from helpers.test_tools import assert_eq_with_retry
+import os
+import re
+import time
+
+cluster = ClickHouseCluster(__file__)
+instance = cluster.add_instance('instance',
+                                config_dir="configs")
+
+
+def copy_policy_xml(local_file_name, reload_immediately = True):
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    instance.copy_file_to_container(os.path.join(script_dir, local_file_name), '/etc/clickhouse-server/users.d/row_policy.xml')
+    if reload_immediately:
+       instance.query("SYSTEM RELOAD CONFIG")
+
+
+@pytest.fixture(scope="module", autouse=True)
+def started_cluster():
+    try:
+        cluster.start()
+
+        instance.query('''
+            CREATE DATABASE mydb;
+
+            CREATE TABLE mydb.filtered_table1 (a UInt8, b UInt8) ENGINE MergeTree ORDER BY a;
+            INSERT INTO mydb.filtered_table1 values (0, 0), (0, 1), (1, 0), (1, 1);
+
+            CREATE TABLE mydb.filtered_table2 (a UInt8, b UInt8, c UInt8, d UInt8) ENGINE MergeTree ORDER BY a;
+            INSERT INTO mydb.filtered_table2 values (0, 0, 0, 0), (1, 2, 3, 4), (4, 3, 2, 1), (0, 0, 6, 0);
+
+            CREATE TABLE mydb.filtered_table3 (a UInt8, b UInt8, c UInt16 ALIAS a + b) ENGINE MergeTree ORDER BY a;
+            INSERT INTO mydb.filtered_table3 values (0, 0), (0, 1), (1, 0), (1, 1);
+        ''')
+        
+        yield cluster
+
+    finally:
+        cluster.shutdown()
+
+
+@pytest.fixture(autouse=True)
+def reset_policies():
+    try:
+        yield
+    finally:
+        copy_policy_xml('normal_filters.xml')
+        instance.query("DROP POLICY IF EXISTS pA, pB ON mydb.filtered_table1")
+
+
+def test_smoke():
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t1\n1\t0\n"
+
+    assert instance.query("SELECT a FROM mydb.filtered_table1") == "1\n1\n"
+    assert instance.query("SELECT b FROM mydb.filtered_table1") == "0\n1\n"
+    assert instance.query("SELECT a FROM mydb.filtered_table1 WHERE a = 1") == "1\n1\n"
+    assert instance.query("SELECT a = 1 FROM mydb.filtered_table1") == "1\n1\n"
+
+    assert instance.query("SELECT a FROM mydb.filtered_table3") == "0\n1\n"
+    assert instance.query("SELECT b FROM mydb.filtered_table3") == "1\n0\n"
+    assert instance.query("SELECT c FROM mydb.filtered_table3") == "1\n1\n"
+    assert instance.query("SELECT a + b FROM mydb.filtered_table3") == "1\n1\n"
+    assert instance.query("SELECT a FROM mydb.filtered_table3 WHERE c = 1") == "0\n1\n"
+    assert instance.query("SELECT c = 1 FROM mydb.filtered_table3") == "1\n1\n"
+    assert instance.query("SELECT a + b = 1 FROM mydb.filtered_table3") == "1\n1\n"
+
+
+def test_join():
+    assert instance.query("SELECT * FROM mydb.filtered_table1 as t1 ANY LEFT JOIN mydb.filtered_table1 as t2 ON t1.a = t2.b") == "1\t0\t1\t1\n1\t1\t1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table1 as t2 ANY RIGHT JOIN mydb.filtered_table1 as t1 ON t2.b = t1.a") == "1\t1\t1\t0\n"
+
+
+def test_cannot_trick_row_policy_with_keyword_with():
+    assert instance.query("WITH 0 AS a SELECT * FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("WITH 0 AS a SELECT a, b FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("WITH 0 AS a SELECT a FROM mydb.filtered_table1") == "1\n1\n"
+    assert instance.query("WITH 0 AS a SELECT b FROM mydb.filtered_table1") == "0\n1\n"
+
+
+def test_prewhere_not_supported():
+    expected_error = "PREWHERE is not supported if the table is filtered by row-level security"
+    assert expected_error in instance.query_and_get_error("SELECT * FROM mydb.filtered_table1 PREWHERE 1")
+    assert expected_error in instance.query_and_get_error("SELECT * FROM mydb.filtered_table2 PREWHERE 1")
+    assert expected_error in instance.query_and_get_error("SELECT * FROM mydb.filtered_table3 PREWHERE 1")
+
+
+def test_change_of_users_xml_changes_row_policies():
+    copy_policy_xml('normal_filters.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t1\n1\t0\n"
+
+    copy_policy_xml('all_rows.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "0\t0\n0\t1\n1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n1\t2\t3\t4\n4\t3\t2\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t0\n0\t1\n1\t0\n1\t1\n"
+
+    copy_policy_xml('no_rows.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == ""
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == ""
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == ""
+
+    copy_policy_xml('normal_filters.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t1\n1\t0\n"
+
+    copy_policy_xml('no_filters.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "0\t0\n0\t1\n1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n1\t2\t3\t4\n4\t3\t2\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t0\n0\t1\n1\t0\n1\t1\n"
+
+    copy_policy_xml('normal_filters.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t1\n1\t0\n"
+
+
+def test_reload_users_xml_by_timer():
+    copy_policy_xml('normal_filters.xml')
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n1\t1\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table2") == "0\t0\t0\t0\n0\t0\t6\t0\n"
+    assert instance.query("SELECT * FROM mydb.filtered_table3") == "0\t1\n1\t0\n"
+
+    time.sleep(1) # The modification time of the 'row_policy.xml' file should be different.
+    copy_policy_xml('all_rows.xml', False)
+    assert_eq_with_retry(instance, "SELECT * FROM mydb.filtered_table1", "0\t0\n0\t1\n1\t0\n1\t1")
+    assert_eq_with_retry(instance, "SELECT * FROM mydb.filtered_table2", "0\t0\t0\t0\n0\t0\t6\t0\n1\t2\t3\t4\n4\t3\t2\t1")
+    assert_eq_with_retry(instance, "SELECT * FROM mydb.filtered_table3", "0\t0\n0\t1\n1\t0\n1\t1")
+
+    time.sleep(1) # The modification time of the 'row_policy.xml' file should be different.
+    copy_policy_xml('normal_filters.xml', False)
+    assert_eq_with_retry(instance, "SELECT * FROM mydb.filtered_table1", "1\t0\n1\t1")
+    assert_eq_with_retry(instance, "SELECT * FROM mydb.filtered_table2", "0\t0\t0\t0\n0\t0\t6\t0")
+    assert_eq_with_retry(instance, "SELECT * FROM mydb.filtered_table3", "0\t1\n1\t0")
+
+
+def test_introspection():
+    assert instance.query("SELECT currentRowPolicies('mydb', 'filtered_table1')") == "['default']\n"
+    assert instance.query("SELECT currentRowPolicies('mydb', 'filtered_table2')") == "['default']\n"
+    assert instance.query("SELECT currentRowPolicies('mydb', 'filtered_table3')") == "['default']\n"
+    assert instance.query("SELECT arraySort(currentRowPolicies())") == "[('mydb','filtered_table1','default'),('mydb','filtered_table2','default'),('mydb','filtered_table3','default')]\n"
+
+    policy1 = "mydb\tfiltered_table1\tdefault\tdefault ON mydb.filtered_table1\t9e8a8f62-4965-2b5e-8599-57c7b99b3549\tusers.xml\t0\ta = 1\t\t\t\t\n"
+    policy2 = "mydb\tfiltered_table2\tdefault\tdefault ON mydb.filtered_table2\tcffae79d-b9bf-a2ef-b798-019c18470b25\tusers.xml\t0\ta + b < 1 or c - d > 5\t\t\t\t\n"
+    policy3 = "mydb\tfiltered_table3\tdefault\tdefault ON mydb.filtered_table3\t12fc5cef-e3da-3940-ec79-d8be3911f42b\tusers.xml\t0\tc = 1\t\t\t\t\n"
+    assert instance.query("SELECT * from system.row_policies WHERE has(currentRowPolicyIDs('mydb', 'filtered_table1'), id) ORDER BY table, name") == policy1
+    assert instance.query("SELECT * from system.row_policies WHERE has(currentRowPolicyIDs('mydb', 'filtered_table2'), id) ORDER BY table, name") == policy2
+    assert instance.query("SELECT * from system.row_policies WHERE has(currentRowPolicyIDs('mydb', 'filtered_table3'), id) ORDER BY table, name") == policy3
+    assert instance.query("SELECT * from system.row_policies ORDER BY table, name") == policy1 + policy2 + policy3
+    assert instance.query("SELECT * from system.row_policies WHERE has(currentRowPolicyIDs(), id) ORDER BY table, name") == policy1 + policy2 + policy3
+
+
+def test_dcl_introspection():
+    assert instance.query("SHOW POLICIES ON mydb.filtered_table1") == "default\n"
+    assert instance.query("SHOW POLICIES CURRENT ON mydb.filtered_table2") == "default\n"
+    assert instance.query("SHOW POLICIES") == "default ON mydb.filtered_table1\ndefault ON mydb.filtered_table2\ndefault ON mydb.filtered_table3\n"
+    assert instance.query("SHOW POLICIES CURRENT") == "default ON mydb.filtered_table1\ndefault ON mydb.filtered_table2\ndefault ON mydb.filtered_table3\n"
+
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table1") == "CREATE POLICY default ON mydb.filtered_table1 FOR SELECT USING a = 1 TO default\n"
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table2") == "CREATE POLICY default ON mydb.filtered_table2 FOR SELECT USING ((a + b) < 1) OR ((c - d) > 5) TO default\n"
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table3") == "CREATE POLICY default ON mydb.filtered_table3 FOR SELECT USING c = 1 TO default\n"
+
+    copy_policy_xml('all_rows.xml')
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table1") == "CREATE POLICY default ON mydb.filtered_table1 FOR SELECT USING 1 TO default\n"
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table2") == "CREATE POLICY default ON mydb.filtered_table2 FOR SELECT USING 1 TO default\n"
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table3") == "CREATE POLICY default ON mydb.filtered_table3 FOR SELECT USING 1 TO default\n"
+
+    copy_policy_xml('no_rows.xml')
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table1") == "CREATE POLICY default ON mydb.filtered_table1 FOR SELECT USING NULL TO default\n"
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table2") == "CREATE POLICY default ON mydb.filtered_table2 FOR SELECT USING NULL TO default\n"
+    assert instance.query("SHOW CREATE POLICY default ON mydb.filtered_table3") == "CREATE POLICY default ON mydb.filtered_table3 FOR SELECT USING NULL TO default\n"
+
+    copy_policy_xml('no_filters.xml')
+    assert instance.query("SHOW POLICIES") == ""
+
+
+def test_dcl_management():
+    copy_policy_xml('no_filters.xml')
+    assert instance.query("SHOW POLICIES") == ""
+
+    instance.query("CREATE POLICY pA ON mydb.filtered_table1 FOR SELECT USING a<b")
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "0\t0\n0\t1\n1\t0\n1\t1\n"
+    assert instance.query("SHOW POLICIES CURRENT ON mydb.filtered_table1") == ""
+    assert instance.query("SHOW POLICIES ON mydb.filtered_table1") == "pA\n"
+
+    instance.query("ALTER POLICY pA ON mydb.filtered_table1 TO default")
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "0\t1\n"
+    assert instance.query("SHOW POLICIES CURRENT ON mydb.filtered_table1") == "pA\n"
+
+    instance.query("ALTER POLICY pA ON mydb.filtered_table1 FOR SELECT USING a>b")
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n"
+
+    instance.query("ALTER POLICY pA ON mydb.filtered_table1 RENAME TO pB")
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "1\t0\n"
+    assert instance.query("SHOW POLICIES CURRENT ON mydb.filtered_table1") == "pB\n"
+    assert instance.query("SHOW CREATE POLICY pB ON mydb.filtered_table1") == "CREATE POLICY pB ON mydb.filtered_table1 FOR SELECT USING a > b TO default\n"
+
+    instance.query("DROP POLICY pB ON mydb.filtered_table1")
+    assert instance.query("SELECT * FROM mydb.filtered_table1") == "0\t0\n0\t1\n1\t0\n1\t1\n"
+    assert instance.query("SHOW POLICIES") == ""
+
+
+def test_users_xml_is_readonly():
+    assert re.search("storage is readonly", instance.query_and_get_error("DROP POLICY default ON mydb.filtered_table1"))
diff --git a/dbms/tests/integration/test_ttl_move/test.py b/dbms/tests/integration/test_ttl_move/test.py
index 5c252a573aa..a03575cde98 100644
--- a/dbms/tests/integration/test_ttl_move/test.py
+++ b/dbms/tests/integration/test_ttl_move/test.py
@@ -50,6 +50,65 @@ def get_used_disks_for_table(node, table_name):
     return node.query("select disk_name from system.parts where table == '{}' and active=1 order by modification_time".format(table_name)).strip().split('\n')
 
 
+@pytest.mark.parametrize("name,engine,alter", [
+    ("mt_test_rule_with_invalid_destination","MergeTree()",0),
+    ("replicated_mt_test_rule_with_invalid_destination","ReplicatedMergeTree('/clickhouse/replicated_test_rule_with_invalid_destination', '1')",0),
+    ("mt_test_rule_with_invalid_destination","MergeTree()",1),
+    ("replicated_mt_test_rule_with_invalid_destination","ReplicatedMergeTree('/clickhouse/replicated_test_rule_with_invalid_destination', '1')",1),
+])
+def test_rule_with_invalid_destination(started_cluster, name, engine, alter):
+    try:
+        def get_command(x, policy):
+            x = x or ""
+            if alter and x:
+                return """
+                    ALTER TABLE {name} MODIFY TTL {expression}
+                """.format(expression=x, name=name)
+            else:
+                return """
+                    CREATE TABLE {name} (
+                        s1 String,
+                        d1 DateTime
+                    ) ENGINE = {engine}
+                    ORDER BY tuple()
+                    {expression}
+                    SETTINGS storage_policy='{policy}'
+                """.format(expression=x, name=name, engine=engine, policy=policy)
+    
+        if alter:
+            node1.query(get_command(None, "small_jbod_with_external"))
+    
+        with pytest.raises(QueryRuntimeException):
+            node1.query(get_command("TTL d1 TO DISK 'unknown'", "small_jbod_with_external"))
+    
+        node1.query("DROP TABLE IF EXISTS {}".format(name))
+    
+        if alter:
+            node1.query(get_command(None, "small_jbod_with_external"))
+    
+        with pytest.raises(QueryRuntimeException):
+            node1.query(get_command("TTL d1 TO VOLUME 'unknown'", "small_jbod_with_external"))
+    
+        node1.query("DROP TABLE IF EXISTS {}".format(name))
+    
+        if alter:
+            node1.query(get_command(None, "only_jbod2"))
+    
+        with pytest.raises(QueryRuntimeException):
+            node1.query(get_command("TTL d1 TO DISK 'jbod1'", "only_jbod2"))
+    
+        node1.query("DROP TABLE IF EXISTS {}".format(name))
+    
+        if alter:
+            node1.query(get_command(None, "only_jbod2"))
+    
+        with pytest.raises(QueryRuntimeException):
+            node1.query(get_command("TTL d1 TO VOLUME 'external'", "only_jbod2"))
+    
+    finally:
+        node1.query("DROP TABLE IF EXISTS {}".format(name))
+
+
 @pytest.mark.parametrize("name,engine,positive", [
     ("mt_test_inserts_to_disk_do_not_work","MergeTree()",0),
     ("replicated_mt_test_inserts_to_disk_do_not_work","ReplicatedMergeTree('/clickhouse/replicated_test_inserts_to_disk_do_not_work', '1')",0),
diff --git a/dbms/tests/performance/string_set.xml b/dbms/tests/performance/string_set.xml
index 54c445d3639..08a74e3e8f9 100644
--- a/dbms/tests/performance/string_set.xml
+++ b/dbms/tests/performance/string_set.xml
@@ -12,7 +12,7 @@
     </main_metric>
 
     <preconditions>
-        <table_exists>default.hits_10m_single</table_exists>
+        <table_exists>hits_10m_single</table_exists>
     </preconditions>
 
     <create_query>CREATE TABLE hits_10m_words (word String, UserID UInt64) ENGINE Memory</create_query>
diff --git a/dbms/tests/queries/0_stateless/00927_table_filter.reference b/dbms/tests/queries/0_stateless/00927_table_filter.reference
deleted file mode 100644
index e3ea6e2f0ff..00000000000
--- a/dbms/tests/queries/0_stateless/00927_table_filter.reference
+++ /dev/null
@@ -1,32 +0,0 @@
--- PREWHERE should fail
-1	0
-1	1
-0	0	0	0
-0	0	6	0
-0	1
-1	0
-1
-1
-0
-1
-1
-1
-1
-1
-0
-1
-1
-0
-1
-1
-1
-1
-0
-1
-1
-1
-1
-1
-1	0	1	1
-1	1	1	1
-1	1	1	0
diff --git a/dbms/tests/queries/0_stateless/00927_table_filter.sql b/dbms/tests/queries/0_stateless/00927_table_filter.sql
deleted file mode 100644
index ff9703be6cd..00000000000
--- a/dbms/tests/queries/0_stateless/00927_table_filter.sql
+++ /dev/null
@@ -1,46 +0,0 @@
-SET any_join_distinct_right_table_keys = 1;
-
-DROP TABLE IF EXISTS test.filtered_table1;
-DROP TABLE IF EXISTS test.filtered_table2;
-DROP TABLE IF EXISTS test.filtered_table3;
-
--- Filter: a = 1, values: (1, 0), (1, 1)
-CREATE TABLE test.filtered_table1 (a UInt8, b UInt8) ENGINE MergeTree ORDER BY a;
-INSERT INTO test.filtered_table1 values (0, 0), (0, 1), (1, 0), (1, 1);
-
--- Filter: a + b < 1 or c - d > 5, values: (0, 0, 0, 0), (0, 0, 6, 0)
-CREATE TABLE test.filtered_table2 (a UInt8, b UInt8, c UInt8, d UInt8) ENGINE MergeTree ORDER BY a;
-INSERT INTO test.filtered_table2 values (0, 0, 0, 0), (1, 2, 3, 4), (4, 3, 2, 1), (0, 0, 6, 0);
-
--- Filter: c = 1, values: (0, 1), (1, 0)
-CREATE TABLE test.filtered_table3 (a UInt8, b UInt8, c UInt16 ALIAS a + b) ENGINE MergeTree ORDER BY a;
-INSERT INTO test.filtered_table3 values (0, 0), (0, 1), (1, 0), (1, 1);
-
-SELECT '-- PREWHERE should fail';
-SELECT * FROM test.filtered_table1 PREWHERE 1; -- { serverError 182 }
-SELECT * FROM test.filtered_table2 PREWHERE 1; -- { serverError 182 }
-SELECT * FROM test.filtered_table3 PREWHERE 1; -- { serverError 182 }
-
-SELECT * FROM test.filtered_table1;
-SELECT * FROM test.filtered_table2;
-SELECT * FROM test.filtered_table3;
-
-SELECT a FROM test.filtered_table1;
-SELECT b FROM test.filtered_table1;
-SELECT a FROM test.filtered_table1 WHERE a = 1;
-SELECT a = 1 FROM test.filtered_table1;
-
-SELECT a FROM test.filtered_table3;
-SELECT b FROM test.filtered_table3;
-SELECT c FROM test.filtered_table3;
-SELECT a + b FROM test.filtered_table3;
-SELECT a FROM test.filtered_table3 WHERE c = 1;
-SELECT c = 1 FROM test.filtered_table3;
-SELECT a + b = 1 FROM test.filtered_table3;
-
-SELECT * FROM test.filtered_table1 as t1 ANY LEFT JOIN test.filtered_table1 as t2 ON t1.a = t2.b;
-SELECT * FROM test.filtered_table1 as t2 ANY RIGHT JOIN test.filtered_table1 as t1 ON t2.b = t1.a;
-
-DROP TABLE test.filtered_table1;
-DROP TABLE test.filtered_table2;
-DROP TABLE test.filtered_table3;
diff --git a/dbms/tests/queries/0_stateless/01039_row_policy_dcl.reference b/dbms/tests/queries/0_stateless/01039_row_policy_dcl.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/01039_row_policy_dcl.sql b/dbms/tests/queries/0_stateless/01039_row_policy_dcl.sql
new file mode 100644
index 00000000000..dc558a55b26
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/01039_row_policy_dcl.sql
@@ -0,0 +1,2 @@
+SHOW POLICIES;
+CREATE POLICY p1 ON dummytable; -- { serverError 497 }
diff --git a/dbms/tests/queries/0_stateless/01051_all_join_engine.reference b/dbms/tests/queries/0_stateless/01051_all_join_engine.reference
new file mode 100644
index 00000000000..3e73caac0c7
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/01051_all_join_engine.reference
@@ -0,0 +1,32 @@
+left
+0	a1	
+1	a2	
+2	a3	b1
+2	a3	b2
+3	a4	
+4	a5	b3
+4	a5	b4
+4	a5	b5
+inner
+2	a3	b1
+2	a3	b2
+4	a5	b3
+4	a5	b4
+4	a5	b5
+right
+2	a3	b1
+2	a3	b2
+4	a5	b3
+4	a5	b4
+4	a5	b5
+5		b6
+full
+0	a1	
+1	a2	
+2	a3	b1
+2	a3	b2
+3	a4	
+4	a5	b3
+4	a5	b4
+4	a5	b5
+5		b6
diff --git a/dbms/tests/queries/0_stateless/01051_all_join_engine.sql b/dbms/tests/queries/0_stateless/01051_all_join_engine.sql
new file mode 100644
index 00000000000..fe5ac390884
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/01051_all_join_engine.sql
@@ -0,0 +1,56 @@
+DROP TABLE IF EXISTS t1;
+
+DROP TABLE IF EXISTS left_join;
+DROP TABLE IF EXISTS inner_join;
+DROP TABLE IF EXISTS right_join;
+DROP TABLE IF EXISTS full_join;
+
+CREATE TABLE t1 (x UInt32, str String) engine = Memory;
+
+CREATE TABLE left_join (x UInt32, s String) engine = Join(ALL, LEFT, x);
+CREATE TABLE inner_join (x UInt32, s String) engine = Join(ALL, INNER, x);
+CREATE TABLE right_join (x UInt32, s String) engine = Join(ALL, RIGHT, x);
+CREATE TABLE full_join (x UInt32, s String) engine = Join(ALL, FULL, x);
+
+INSERT INTO t1 (x, str) VALUES (0, 'a1'), (1, 'a2'), (2, 'a3'), (3, 'a4'), (4, 'a5');
+
+INSERT INTO left_join (x, s) VALUES (2, 'b1'), (2, 'b2'), (4, 'b3'), (4, 'b4'), (4, 'b5'), (5, 'b6');
+INSERT INTO inner_join (x, s) VALUES (2, 'b1'), (2, 'b2'), (4, 'b3'), (4, 'b4'), (4, 'b5'), (5, 'b6');
+INSERT INTO right_join (x, s) VALUES (2, 'b1'), (2, 'b2'), (4, 'b3'), (4, 'b4'), (4, 'b5'), (5, 'b6');
+INSERT INTO full_join (x, s) VALUES (2, 'b1'), (2, 'b2'), (4, 'b3'), (4, 'b4'), (4, 'b5'), (5, 'b6');
+
+SET join_use_nulls = 0;
+
+SELECT 'left';
+SELECT * FROM t1 LEFT JOIN left_join j USING(x) ORDER BY x, str, s;
+
+SELECT 'inner';
+SELECT * FROM t1 INNER JOIN inner_join j USING(x) ORDER BY x, str, s;
+
+SELECT 'right';
+SELECT * FROM t1 RIGHT JOIN right_join j USING(x) ORDER BY x, str, s;
+
+SELECT 'full';
+SELECT * FROM t1 FULL JOIN full_join j USING(x) ORDER BY x, str, s;
+
+-- TODO
+-- SET join_use_nulls = 1;
+-- 
+-- SELECT 'left (join_use_nulls)';
+-- SELECT * FROM t1 LEFT JOIN left_join j USING(x) ORDER BY x, str, s;
+-- 
+-- SELECT 'inner (join_use_nulls)';
+-- SELECT * FROM t1 INNER JOIN inner_join j USING(x) ORDER BY x, str, s;
+-- 
+-- SELECT 'right (join_use_nulls)';
+-- SELECT * FROM t1 RIGHT JOIN right_join j USING(x) ORDER BY x, str, s;
+-- 
+-- SELECT 'full (join_use_nulls)';
+-- SELECT * FROM t1 FULL JOIN full_join j USING(x) ORDER BY x, str, s;
+
+DROP TABLE t1;
+
+DROP TABLE left_join;
+DROP TABLE inner_join;
+DROP TABLE right_join;
+DROP TABLE full_join;
diff --git a/dbms/tests/queries/0_stateless/01051_new_any_join_engine.reference b/dbms/tests/queries/0_stateless/01051_new_any_join_engine.reference
index fe207c56ed1..635ae641a63 100644
--- a/dbms/tests/queries/0_stateless/01051_new_any_join_engine.reference
+++ b/dbms/tests/queries/0_stateless/01051_new_any_join_engine.reference
@@ -16,7 +16,6 @@ any right
 5		b6
 semi left
 2	a3	b1
-2	a6	b1
 4	a5	b3
 semi right
 2	a3	b1
diff --git a/dbms/tests/queries/0_stateless/01051_new_any_join_engine.sql b/dbms/tests/queries/0_stateless/01051_new_any_join_engine.sql
index 5ca321135a3..8662d8532d4 100644
--- a/dbms/tests/queries/0_stateless/01051_new_any_join_engine.sql
+++ b/dbms/tests/queries/0_stateless/01051_new_any_join_engine.sql
@@ -45,9 +45,6 @@ SELECT * FROM t1 ANY INNER JOIN any_inner_join j USING(x) ORDER BY x, str, s;
 SELECT 'any right';
 SELECT * FROM t1 ANY RIGHT JOIN any_right_join j USING(x) ORDER BY x, str, s;
 
-
-INSERT INTO t1 (x, str) VALUES (2, 'a6');
-
 SELECT 'semi left';
 SELECT * FROM t1 SEMI LEFT JOIN semi_left_join j USING(x) ORDER BY x, str, s;
 
diff --git a/docker/images.json b/docker/images.json
index a3094251a5a..d21365fd49d 100644
--- a/docker/images.json
+++ b/docker/images.json
@@ -5,6 +5,7 @@
     "docker/test/compatibility/ubuntu": "yandex/clickhouse-test-old-ubuntu",
     "docker/test/integration": "yandex/clickhouse-integration-test",
     "docker/test/performance": "yandex/clickhouse-performance-test",
+    "docker/test/performance-comparison": "yandex/clickhouse-performance-comparison",
     "docker/test/pvs": "yandex/clickhouse-pvs-test",
     "docker/test/stateful": "yandex/clickhouse-stateful-test",
     "docker/test/stateful_with_coverage": "yandex/clickhouse-stateful-test-with-coverage",
diff --git a/docker/test/performance-comparison/Dockerfile b/docker/test/performance-comparison/Dockerfile
new file mode 100644
index 00000000000..1e08ec0f521
--- /dev/null
+++ b/docker/test/performance-comparison/Dockerfile
@@ -0,0 +1,17 @@
+# docker build -t yandex/clickhouse-performance-comparison .
+FROM ubuntu:18.04
+
+RUN apt-get update \
+    && apt-get install --yes --no-install-recommends \
+        p7zip-full bash ncdu wget python3 python3-pip python3-dev g++ \
+    && pip3 --no-cache-dir install clickhouse_driver \
+    && apt-get purge --yes python3-dev g++ \
+    && apt-get autoremove --yes \
+    && apt-get clean
+
+COPY * /
+
+CMD /entrypoint.sh
+
+# docker run --network=host --volume <workspace>:/workspace --volume=<output>:/output -e LEFT_PR=<> -e LEFT_SHA=<> -e RIGHT_PR=<> -e RIGHT_SHA=<> yandex/clickhouse-performance-comparison
+
diff --git a/docker/test/performance-comparison/compare.sh b/docker/test/performance-comparison/compare.sh
index 4cd3e39522e..7ecf715403f 100755
--- a/docker/test/performance-comparison/compare.sh
+++ b/docker/test/performance-comparison/compare.sh
@@ -4,8 +4,8 @@ set -o pipefail
 trap "exit" INT TERM
 trap "kill 0" EXIT
 
-mkdir left ||:
-mkdir right ||:
+script_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
+
 mkdir db0 ||:
 
 left_pr=$1
@@ -16,43 +16,53 @@ right_sha=$4
 
 function download
 {
+    rm -r left ||:
+    mkdir left ||:
+    rm -r right ||:
+    mkdir right ||:
+
     la="$left_pr-$left_sha.tgz"
     ra="$right_pr-$right_sha.tgz"
-    wget -nd -c "https://clickhouse-builds.s3.yandex.net/$left_pr/$left_sha/performance/performance.tgz" -O "$la" && tar -C left --strip-components=1 -zxvf "$la" &
-    wget -nd -c "https://clickhouse-builds.s3.yandex.net/$right_pr/$right_sha/performance/performance.tgz" -O "$ra" && tar -C right --strip-components=1 -zxvf "$ra" &
-    cd db0 && wget -nd -c "https://s3.mds.yandex.net/clickhouse-private-datasets/hits_10m_single/partitions/hits_10m_single.tar" && tar -xvf hits_10m_single.tar &
-    cd db0 && wget -nd -c "https://s3.mds.yandex.net/clickhouse-private-datasets/hits_100m_single/partitions/hits_100m_single.tar" && tar -xvf hits_100m_single.tar &
-    #cd db0 && wget -nd -c "https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits_v1.tar" && tar -xvf hits_v1.tar &
+    wget -q -nd -c "https://clickhouse-builds.s3.yandex.net/$left_pr/$left_sha/performance/performance.tgz" -O "$la" && tar -C left --strip-components=1 -zxvf "$la" &
+    wget -q -nd -c "https://clickhouse-builds.s3.yandex.net/$right_pr/$right_sha/performance/performance.tgz" -O "$ra" && tar -C right --strip-components=1 -zxvf "$ra" &
+    cd db0 && wget -q -nd -c "https://s3.mds.yandex.net/clickhouse-private-datasets/hits_10m_single/partitions/hits_10m_single.tar" && tar -xvf hits_10m_single.tar &
+    cd db0 && wget -q -nd -c "https://s3.mds.yandex.net/clickhouse-private-datasets/hits_100m_single/partitions/hits_100m_single.tar" && tar -xvf hits_100m_single.tar &
+    cd db0 && wget -q -nd -c "https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits_v1.tar" && tar -xvf hits_v1.tar &
     wait
 
     # Use hardlinks instead of copying
-    rm -r left/db ||:
-    rm -r right/db ||:
     cp -al db0/ left/db/
     cp -al db0/ right/db/
 }
-
-#download
+download
 
 function configure
 {
     sed -i 's/<tcp_port>9000/<tcp_port>9001/g' right/config/config.xml
 
-    cat > right/config/config.d/perf-test-tweaks.xml <<EOF
+    cat > right/config/config.d/zz-perf-test-tweaks.xml <<EOF
     <yandex>
         <logger>
             <console>true</console>
         </logger>
-        <text_log remove="remove"/>
+        <text_log remove="remove">
+            <table remove="remove"/>
+        </text_log>
+        <metric_log remove="remove">
+            <table remove="remove"/>
+        </metric_log>
     </yandex>
 EOF
 
-    cp right/config/config.d/perf-test-tweaks.xml left/config/config.d/perf-test-tweaks.xml
+    cp right/config/config.d/zz-perf-test-tweaks.xml left/config/config.d/zz-perf-test-tweaks.xml
+
+    rm left/config/config.d/metric_log.xml ||:
+    rm left/config/config.d/text_log.xml ||:
+    rm right/config/config.d/metric_log.xml ||:
+    rm right/config/config.d/text_log.xml ||:
 }
-
 configure
 
-
 function restart
 {
     while killall clickhouse ; do echo . ; sleep 1 ; done
@@ -78,20 +88,31 @@ function restart
 
     while ! right/clickhouse client --port 9001 --query "select 1" ; do kill -0 $right_pid ; echo . ; sleep 1 ; done
     echo right ok
-}
 
+    right/clickhouse client --port 9001 --query "create database test" ||:
+    right/clickhouse client --port 9001 --query "rename table datasets.hits_v1 to test.hits" ||:
+    left/clickhouse client --port 9000 --query "create database test" ||:
+    left/clickhouse client --port 9000 --query "rename table datasets.hits_v1 to test.hits" ||:
+}
 restart
 
-for test in ch/dbms/tests/performance/*.xml
-do
-    test_name=$(basename $test ".xml")
-    ./perf.py "$test" > "$test_name-raw.tsv" || continue
-    right/clickhouse local --file "$test_name-raw.tsv" --structure 'query text, run int, version UInt32, time float' --query "$(cat eqmed.sql)" > "$test_name-report.tsv"
-done
-
-#while killall clickhouse ; do echo . ; sleep 1 ; done
-#echo ok
-
-
+function run_tests
+{
+    # Just check that the script runs at all
+    "$script_dir/perf.py" --help > /dev/null
 
+    # Run the tests
+    for test in left/performance/*.xml
+    do
+        test_name=$(basename $test ".xml")
+        "$script_dir/perf.py" "$test" > "$test_name-raw.tsv" 2> "$test_name-err.log" || continue
+        right/clickhouse local --file "$test_name-raw.tsv" --structure 'query text, run int, version UInt32, time float' --query "$(cat $script_dir/eqmed.sql)" > "$test_name-report.tsv"
+    done
+}
+run_tests
 
+# Analyze results
+result_structure="left float, right float, diff float, rd Array(float), query text"
+right/clickhouse local --file '*-report.tsv' -S "$result_structure" --query "select * from table where rd[3] > 0.05 order by rd[3] desc" > flap-prone.tsv
+right/clickhouse local --file '*-report.tsv' -S "$result_structure" --query "select * from table where diff > 0.05 and diff > rd[3] order by diff desc" > bad-perf.tsv
+grep Exception:[^:] *-err.log > run-errors.log
diff --git a/docker/test/performance-comparison/entrypoint.sh b/docker/test/performance-comparison/entrypoint.sh
new file mode 100755
index 00000000000..7ef5a9553a0
--- /dev/null
+++ b/docker/test/performance-comparison/entrypoint.sh
@@ -0,0 +1,8 @@
+#!/bin/bash
+
+cd /workspace
+
+../compare.sh $LEFT_PR $LEFT_SHA $RIGHT_PR $RIGHT_SHA > compare.log 2>&1
+
+7z a /output/output.7z *.log *.tsv
+cp compare.log /output
diff --git a/docker/test/performance-comparison/eqmed.sql b/docker/test/performance-comparison/eqmed.sql
index dd677b750a0..5e8d842b7df 100644
--- a/docker/test/performance-comparison/eqmed.sql
+++ b/docker/test/performance-comparison/eqmed.sql
@@ -1,6 +1,6 @@
 -- input is table(query text, run UInt32, version int, time float)
 select
-   abs(diff_percent) > rd_quantiles_percent[3] fail, 
+--   abs(diff_percent) > rd_quantiles_percent[3] fail,
    floor(original_medians_array.time_by_version[1], 4) m1,
    floor(original_medians_array.time_by_version[2], 4) m2,
    floor((m1 - m2) / m1, 3) diff_percent,
@@ -38,4 +38,4 @@ from
         group by query
    ) original_medians_array
 where rd.query = original_medians_array.query
-order by fail desc, rd_quantiles_percent[3] asc;
+order by rd_quantiles_percent[3] desc;
diff --git a/docker/test/performance-comparison/perf.py b/docker/test/performance-comparison/perf.py
index 508d46b6261..5517a71cc44 100755
--- a/docker/test/performance-comparison/perf.py
+++ b/docker/test/performance-comparison/perf.py
@@ -14,9 +14,14 @@ tree = et.parse(args.file[0])
 root = tree.getroot()
 
 # Check main metric
-main_metric = root.find('main_metric/*').tag
-if main_metric != 'min_time':
-    raise Exception('Only the min_time main metric is supported. This test uses \'{}\''.format(main_metric))
+main_metric_element = root.find('main_metric/*')
+if main_metric_element is not None and main_metric_element.tag != 'min_time':
+    raise Exception('Only the min_time main metric is supported. This test uses \'{}\''.format(main_metric_element.tag))
+
+# FIXME another way to detect infinite tests. They should have an appropriate main_metric but sometimes they don't.
+infinite_sign = root.find('.//average_speed_not_changing_for_ms')
+if infinite_sign is not None:
+    raise Exception('Looks like the test is infinite (sign 1)')
 
 # Open connections
 servers = [{'host': 'localhost', 'port': 9000, 'client_name': 'left'}, {'host': 'localhost', 'port': 9001, 'client_name': 'right'}]
@@ -24,12 +29,15 @@ connections = [clickhouse_driver.Client(**server) for server in servers]
 
 # Check tables that should exist
 tables = [e.text for e in root.findall('preconditions/table_exists')]
-if tables:
+for t in tables:
     for c in connections:
-        tables_list = ", ".join("'{}'".format(t) for t in tables)
-        res = c.execute("select t from values('t text', {}) anti join system.tables on database = currentDatabase() and name = t".format(tables_list))
-        if res:
-            raise Exception('Some tables are not found: {}'.format(res))
+        res = c.execute("select 1 from {}".format(t))
+
+# Apply settings
+settings = root.findall('settings/*')
+for c in connections:
+    for s in settings:
+        c.execute("set {} = '{}'".format(s.tag, s.text))
 
 # Process substitutions
 subst_elems = root.findall('substitutions/substitution')
@@ -70,6 +78,9 @@ for c in connections:
         c.execute(q)
 
 # Run test queries
+def tsv_escape(s):
+    return s.replace('\\', '\\\\').replace('\t', '\\t').replace('\n', '\\n').replace('\r','')
+
 test_query_templates = [q.text for q in root.findall('query')]
 test_queries = substitute_parameters(test_query_templates, parameter_combinations)
 
@@ -77,7 +88,7 @@ for q in test_queries:
     for run in range(0, 7):
         for conn_index, c in enumerate(connections):
             res = c.execute(q)
-            print(q + '\t' + str(run) + '\t' + str(conn_index) + '\t' + str(c.last_query.elapsed))
+            print(tsv_escape(q) + '\t' + str(run) + '\t' + str(conn_index) + '\t' + str(c.last_query.elapsed))
 
 # Run drop queries
 drop_query_templates = [q.text for q in root.findall('drop_query')]
diff --git a/docs/en/faq/general.md b/docs/en/faq/general.md
index 41026e54a08..3e6daf6ed9a 100644
--- a/docs/en/faq/general.md
+++ b/docs/en/faq/general.md
@@ -21,4 +21,36 @@ If you use Oracle through the ODBC driver as a source of external dictionaries,
 NLS_LANG=RUSSIAN_RUSSIA.UTF8
 ```
 
+## How to export data from ClickHouse to the file?
+
+### Using INTO OUTFILE Clause
+
+Add [INTO OUTFILE](../query_language/select/#into-outfile-clause) clause to your query.
+
+For example:
+
+```sql
+SELECT * FROM table INTO OUTFILE 'file'
+```
+
+By default, ClickHouse uses the [TabSeparated](../interfaces/formats.md#tabseparated) format for output data. To select the [data format](../interfaces/formats.md), use the [FORMAT clause](../query_language/select/#format-clause).
+
+For example:
+
+```sql
+SELECT * FROM table INTO OUTFILE 'file' FORMAT CSV
+```
+
+### Using File-engine Table
+
+See [File](../operations/table_engines/file.md).
+
+### Using Command-line Redirection
+
+```sql
+$ clickhouse-client --query "SELECT * from table" > result.txt
+```
+
+See [clickhouse-client](../interfaces/cli.md).
+
 [Original article](https://clickhouse.yandex/docs/en/faq/general/) <!--hide-->
diff --git a/docs/en/interfaces/formats.md b/docs/en/interfaces/formats.md
index eebdf10702d..b37c9cdddb2 100644
--- a/docs/en/interfaces/formats.md
+++ b/docs/en/interfaces/formats.md
@@ -29,6 +29,7 @@ The supported formats are:
 | [PrettySpace](#prettyspace) | ✗ | ✔ |
 | [Protobuf](#protobuf) | ✔ | ✔ |
 | [Parquet](#data-format-parquet) | ✔ | ✔ |
+| [ORC](#data-format-orc) | ✔ | ✗ |
 | [RowBinary](#rowbinary) | ✔ | ✔ |
 | [RowBinaryWithNamesAndTypes](#rowbinarywithnamesandtypes) | ✔ | ✔ |
 | [Native](#native) | ✔ | ✔ |
@@ -954,16 +955,57 @@ Data types of a ClickHouse table columns can differ from the corresponding field
 You can insert Parquet data from a file into ClickHouse table by the following command:
 
 ```bash
-cat {filename} | clickhouse-client --query="INSERT INTO {some_table} FORMAT Parquet"
+$ cat {filename} | clickhouse-client --query="INSERT INTO {some_table} FORMAT Parquet"
 ```
 
 You can select data from a ClickHouse table and save them into some file in the Parquet format by the following command:
 
-```sql
-clickhouse-client --query="SELECT * FROM {some_table} FORMAT Parquet" > {some_file.pq}
+```bash
+$ clickhouse-client --query="SELECT * FROM {some_table} FORMAT Parquet" > {some_file.pq}
 ```
 
-To exchange data with the Hadoop, you can use [HDFS table engine](../operations/table_engines/hdfs.md).
+To exchange data with Hadoop, you can use [HDFS table engine](../operations/table_engines/hdfs.md).
+
+## ORC {#data-format-orc}
+
+[Apache ORC](https://orc.apache.org/) is a columnar storage format widespread in the Hadoop ecosystem. ClickHouse supports only read operations for this format.
+
+### Data Types Matching
+
+The table below shows supported data types and how they match ClickHouse [data types](../data_types/index.md) in `INSERT` queries.
+
+| ORC data type (`INSERT`) | ClickHouse data type |
+| -------------------- | ------------------ |
+| `UINT8`, `BOOL` | [UInt8](../data_types/int_uint.md) |
+| `INT8` | [Int8](../data_types/int_uint.md) |
+| `UINT16` | [UInt16](../data_types/int_uint.md) |
+| `INT16` | [Int16](../data_types/int_uint.md) |
+| `UINT32` | [UInt32](../data_types/int_uint.md) |
+| `INT32` | [Int32](../data_types/int_uint.md) |
+| `UINT64` | [UInt64](../data_types/int_uint.md) |
+| `INT64` | [Int64](../data_types/int_uint.md) |
+| `FLOAT`, `HALF_FLOAT` | [Float32](../data_types/float.md) |
+| `DOUBLE` | [Float64](../data_types/float.md) |
+| `DATE32` | [Date](../data_types/date.md) |
+| `DATE64`, `TIMESTAMP` | [DateTime](../data_types/datetime.md) |
+| `STRING`, `BINARY` | [String](../data_types/string.md) |
+| `DECIMAL` | [Decimal](../data_types/decimal.md) |
+
+ClickHouse supports configurable precision of `Decimal` type. The `INSERT` query treats the ORC `DECIMAL` type as the ClickHouse `Decimal128` type.
+
+Unsupported ORC data types: `DATE32`, `TIME32`, `FIXED_SIZE_BINARY`, `JSON`, `UUID`, `ENUM`.
+
+Data types of a ClickHouse table columns can differ from the corresponding fields of the ORC data inserted. When inserting data, ClickHouse interprets data types according to the table above and then [cast](../query_language/functions/type_conversion_functions/#type_conversion_function-cast) the data to that data type which is set for the ClickHouse table column.
+
+### Inserting Data
+
+You can insert Parquet data from a file into ClickHouse table by the following command:
+
+```bash
+$ cat {filename} | clickhouse-client --query="INSERT INTO {some_table} FORMAT ORC"
+```
+
+To exchange data with Hadoop, you can use [HDFS table engine](../operations/table_engines/hdfs.md).
 
 ## Format Schema {#formatschema}
 
diff --git a/docs/en/query_language/select.md b/docs/en/query_language/select.md
index e6e7676c643..6e053332d83 100644
--- a/docs/en/query_language/select.md
+++ b/docs/en/query_language/select.md
@@ -1120,7 +1120,7 @@ The structure of results (the number and type of columns) must match for the que
 
 Queries that are parts of UNION ALL can't be enclosed in brackets. ORDER BY and LIMIT are applied to separate queries, not to the final result. If you need to apply a conversion to the final result, you can put all the queries with UNION ALL in a subquery in the FROM clause.
 
-### INTO OUTFILE Clause
+### INTO OUTFILE Clause {#into-outfile-clause}
 
 Add the `INTO OUTFILE filename` clause (where filename is a string literal) to redirect query output to the specified file.
 In contrast to MySQL, the file is created on the client side. The query will fail if a file with the same filename already exists.
@@ -1128,7 +1128,7 @@ This functionality is available in the command-line client and clickhouse-local
 
 The default output format is TabSeparated (the same as in the command-line client batch mode).
 
-### FORMAT Clause
+### FORMAT Clause {#format-clause}
 
 Specify 'FORMAT format' to get data in any specified format.
 You can use this for convenience, or for creating dumps.
diff --git a/utils/ci/README.md b/utils/ci/README.md
index 003f547fb79..5bb22933ad1 100644
--- a/utils/ci/README.md
+++ b/utils/ci/README.md
@@ -107,7 +107,7 @@ Using libraries from OS packages is discouraged, but we also support this option
 - shared;
 
 Static linking is the only option for production usage.
-We also have support for shared linking, but it is indended only for developers.
+We also have support for shared linking, but it is intended only for developers.
 
 #### Make tools:
 - make;