duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

package/src/duckdb/third_party/parquet/parquet_types.cpp

@@ -3827,11 +3827,11 @@ void ColumnMetaData::__set_type(const Type::type val) {
   this->type = val;
 }
 
-void ColumnMetaData::__set_encodings(const std::vector<Encoding::type> & val) {
+void ColumnMetaData::__set_encodings(const duckdb::vector<Encoding::type> & val) {
   this->encodings = val;
 }
 
-void ColumnMetaData::__set_path_in_schema(const std::vector<std::string> & val) {
+void ColumnMetaData::__set_path_in_schema(const duckdb::vector<std::string> & val) {
   this->path_in_schema = val;
 }
 
@@ -3851,7 +3851,7 @@ void ColumnMetaData::__set_total_compressed_size(const int64_t val) {
   this->total_compressed_size = val;
 }
 
-void ColumnMetaData::__set_key_value_metadata(const std::vector<KeyValue> & val) {
+void ColumnMetaData::__set_key_value_metadata(const duckdb::vector<KeyValue> & val) {
   this->key_value_metadata = val;
 __isset.key_value_metadata = true;
 }
@@ -3875,7 +3875,7 @@ void ColumnMetaData::__set_statistics(const Statistics& val) {
 __isset.statistics = true;
 }
 
-void ColumnMetaData::__set_encoding_stats(const std::vector<PageEncodingStats> & val) {
+void ColumnMetaData::__set_encoding_stats(const duckdb::vector<PageEncodingStats> & val) {
   this->encoding_stats = val;
 __isset.encoding_stats = true;
 }
@@ -4113,7 +4113,7 @@ uint32_t ColumnMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* opr
   xfer += oprot->writeFieldBegin("encodings", ::duckdb_apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_I32, static_cast<uint32_t>(this->encodings.size()));
-    std::vector<Encoding::type> ::const_iterator _iter90;
+    duckdb::vector<Encoding::type> ::const_iterator _iter90;
     for (_iter90 = this->encodings.begin(); _iter90 != this->encodings.end(); ++_iter90)
     {
       xfer += oprot->writeI32((int32_t)(*_iter90));
@@ -4125,7 +4125,7 @@ uint32_t ColumnMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* opr
   xfer += oprot->writeFieldBegin("path_in_schema", ::duckdb_apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter91;
+    duckdb::vector<std::string> ::const_iterator _iter91;
     for (_iter91 = this->path_in_schema.begin(); _iter91 != this->path_in_schema.end(); ++_iter91)
     {
       xfer += oprot->writeString((*_iter91));
@@ -4154,7 +4154,7 @@ uint32_t ColumnMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* opr
     xfer += oprot->writeFieldBegin("key_value_metadata", ::duckdb_apache::thrift::protocol::T_LIST, 8);
     {
       xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter92;
+      duckdb::vector<KeyValue> ::const_iterator _iter92;
       for (_iter92 = this->key_value_metadata.begin(); _iter92 != this->key_value_metadata.end(); ++_iter92)
       {
         xfer += (*_iter92).write(oprot);
@@ -4186,7 +4186,7 @@ uint32_t ColumnMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* opr
     xfer += oprot->writeFieldBegin("encoding_stats", ::duckdb_apache::thrift::protocol::T_LIST, 13);
     {
       xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->encoding_stats.size()));
-      std::vector<PageEncodingStats> ::const_iterator _iter93;
+      duckdb::vector<PageEncodingStats> ::const_iterator _iter93;
       for (_iter93 = this->encoding_stats.begin(); _iter93 != this->encoding_stats.end(); ++_iter93)
       {
         xfer += (*_iter93).write(oprot);
@@ -4343,7 +4343,7 @@ EncryptionWithColumnKey::~EncryptionWithColumnKey() throw() {
 }
 
 
-void EncryptionWithColumnKey::__set_path_in_schema(const std::vector<std::string> & val) {
+void EncryptionWithColumnKey::__set_path_in_schema(const duckdb::vector<std::string> & val) {
   this->path_in_schema = val;
 }
 
@@ -4430,7 +4430,7 @@ uint32_t EncryptionWithColumnKey::write(::duckdb_apache::thrift::protocol::TProt
   xfer += oprot->writeFieldBegin("path_in_schema", ::duckdb_apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->path_in_schema.size()));
-    std::vector<std::string> ::const_iterator _iter103;
+    duckdb::vector<std::string> ::const_iterator _iter103;
     for (_iter103 = this->path_in_schema.begin(); _iter103 != this->path_in_schema.end(); ++_iter103)
     {
       xfer += oprot->writeString((*_iter103));
@@ -4867,7 +4867,7 @@ RowGroup::~RowGroup() throw() {
 }
 
 
-void RowGroup::__set_columns(const std::vector<ColumnChunk> & val) {
+void RowGroup::__set_columns(const duckdb::vector<ColumnChunk> & val) {
   this->columns = val;
 }
 
@@ -4879,7 +4879,7 @@ void RowGroup::__set_num_rows(const int64_t val) {
   this->num_rows = val;
 }
 
-void RowGroup::__set_sorting_columns(const std::vector<SortingColumn> & val) {
+void RowGroup::__set_sorting_columns(const duckdb::vector<SortingColumn> & val) {
   this->sorting_columns = val;
 __isset.sorting_columns = true;
 }
@@ -5035,7 +5035,7 @@ uint32_t RowGroup::write(::duckdb_apache::thrift::protocol::TProtocol* oprot) co
   xfer += oprot->writeFieldBegin("columns", ::duckdb_apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->columns.size()));
-    std::vector<ColumnChunk> ::const_iterator _iter120;
+    duckdb::vector<ColumnChunk> ::const_iterator _iter120;
     for (_iter120 = this->columns.begin(); _iter120 != this->columns.end(); ++_iter120)
     {
       xfer += (*_iter120).write(oprot);
@@ -5056,7 +5056,7 @@ uint32_t RowGroup::write(::duckdb_apache::thrift::protocol::TProtocol* oprot) co
     xfer += oprot->writeFieldBegin("sorting_columns", ::duckdb_apache::thrift::protocol::T_LIST, 4);
     {
       xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->sorting_columns.size()));
-      std::vector<SortingColumn> ::const_iterator _iter121;
+      duckdb::vector<SortingColumn> ::const_iterator _iter121;
       for (_iter121 = this->sorting_columns.begin(); _iter121 != this->sorting_columns.end(); ++_iter121)
       {
         xfer += (*_iter121).write(oprot);
@@ -5436,7 +5436,7 @@ OffsetIndex::~OffsetIndex() throw() {
 }
 
 
-void OffsetIndex::__set_page_locations(const std::vector<PageLocation> & val) {
+void OffsetIndex::__set_page_locations(const duckdb::vector<PageLocation> & val) {
   this->page_locations = val;
 }
 std::ostream& operator<<(std::ostream& out, const OffsetIndex& obj)
@@ -5510,7 +5510,7 @@ uint32_t OffsetIndex::write(::duckdb_apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("page_locations", ::duckdb_apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->page_locations.size()));
-    std::vector<PageLocation> ::const_iterator _iter135;
+    duckdb::vector<PageLocation> ::const_iterator _iter135;
     for (_iter135 = this->page_locations.begin(); _iter135 != this->page_locations.end(); ++_iter135)
     {
       xfer += (*_iter135).write(oprot);
@@ -5548,15 +5548,15 @@ ColumnIndex::~ColumnIndex() throw() {
 }
 
 
-void ColumnIndex::__set_null_pages(const std::vector<bool> & val) {
+void ColumnIndex::__set_null_pages(const duckdb::vector<bool> & val) {
   this->null_pages = val;
 }
 
-void ColumnIndex::__set_min_values(const std::vector<std::string> & val) {
+void ColumnIndex::__set_min_values(const duckdb::vector<std::string> & val) {
   this->min_values = val;
 }
 
-void ColumnIndex::__set_max_values(const std::vector<std::string> & val) {
+void ColumnIndex::__set_max_values(const duckdb::vector<std::string> & val) {
   this->max_values = val;
 }
 
@@ -5564,7 +5564,7 @@ void ColumnIndex::__set_boundary_order(const BoundaryOrder::type val) {
   this->boundary_order = val;
 }
 
-void ColumnIndex::__set_null_counts(const std::vector<int64_t> & val) {
+void ColumnIndex::__set_null_counts(const duckdb::vector<int64_t> & val) {
   this->null_counts = val;
 __isset.null_counts = true;
 }
@@ -5718,7 +5718,7 @@ uint32_t ColumnIndex::write(::duckdb_apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("null_pages", ::duckdb_apache::thrift::protocol::T_LIST, 1);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_BOOL, static_cast<uint32_t>(this->null_pages.size()));
-    std::vector<bool> ::const_iterator _iter159;
+    duckdb::vector<bool> ::const_iterator _iter159;
     for (_iter159 = this->null_pages.begin(); _iter159 != this->null_pages.end(); ++_iter159)
     {
       xfer += oprot->writeBool((*_iter159));
@@ -5730,7 +5730,7 @@ uint32_t ColumnIndex::write(::duckdb_apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("min_values", ::duckdb_apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->min_values.size()));
-    std::vector<std::string> ::const_iterator _iter160;
+    duckdb::vector<std::string> ::const_iterator _iter160;
     for (_iter160 = this->min_values.begin(); _iter160 != this->min_values.end(); ++_iter160)
     {
       xfer += oprot->writeBinary((*_iter160));
@@ -5742,7 +5742,7 @@ uint32_t ColumnIndex::write(::duckdb_apache::thrift::protocol::TProtocol* oprot)
   xfer += oprot->writeFieldBegin("max_values", ::duckdb_apache::thrift::protocol::T_LIST, 3);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->max_values.size()));
-    std::vector<std::string> ::const_iterator _iter161;
+    duckdb::vector<std::string> ::const_iterator _iter161;
     for (_iter161 = this->max_values.begin(); _iter161 != this->max_values.end(); ++_iter161)
     {
       xfer += oprot->writeBinary((*_iter161));
@@ -5759,7 +5759,7 @@ uint32_t ColumnIndex::write(::duckdb_apache::thrift::protocol::TProtocol* oprot)
     xfer += oprot->writeFieldBegin("null_counts", ::duckdb_apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_I64, static_cast<uint32_t>(this->null_counts.size()));
-      std::vector<int64_t> ::const_iterator _iter162;
+      duckdb::vector<int64_t> ::const_iterator _iter162;
       for (_iter162 = this->null_counts.begin(); _iter162 != this->null_counts.end(); ++_iter162)
       {
         xfer += oprot->writeI64((*_iter162));
@@ -6212,7 +6212,7 @@ void FileMetaData::__set_version(const int32_t val) {
   this->version = val;
 }
 
-void FileMetaData::__set_schema(const std::vector<SchemaElement> & val) {
+void FileMetaData::__set_schema(const duckdb::vector<SchemaElement> & val) {
   this->schema = val;
 }
 
@@ -6220,11 +6220,11 @@ void FileMetaData::__set_num_rows(const int64_t val) {
   this->num_rows = val;
 }
 
-void FileMetaData::__set_row_groups(const std::vector<RowGroup> & val) {
+void FileMetaData::__set_row_groups(const duckdb::vector<RowGroup> & val) {
   this->row_groups = val;
 }
 
-void FileMetaData::__set_key_value_metadata(const std::vector<KeyValue> & val) {
+void FileMetaData::__set_key_value_metadata(const duckdb::vector<KeyValue> & val) {
   this->key_value_metadata = val;
 __isset.key_value_metadata = true;
 }
@@ -6234,7 +6234,7 @@ void FileMetaData::__set_created_by(const std::string& val) {
 __isset.created_by = true;
 }
 
-void FileMetaData::__set_column_orders(const std::vector<ColumnOrder> & val) {
+void FileMetaData::__set_column_orders(const duckdb::vector<ColumnOrder> & val) {
   this->column_orders = val;
 __isset.column_orders = true;
 }
@@ -6432,7 +6432,7 @@ uint32_t FileMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* oprot
   xfer += oprot->writeFieldBegin("schema", ::duckdb_apache::thrift::protocol::T_LIST, 2);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->schema.size()));
-    std::vector<SchemaElement> ::const_iterator _iter191;
+    duckdb::vector<SchemaElement> ::const_iterator _iter191;
     for (_iter191 = this->schema.begin(); _iter191 != this->schema.end(); ++_iter191)
     {
       xfer += (*_iter191).write(oprot);
@@ -6448,7 +6448,7 @@ uint32_t FileMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* oprot
   xfer += oprot->writeFieldBegin("row_groups", ::duckdb_apache::thrift::protocol::T_LIST, 4);
   {
     xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->row_groups.size()));
-    std::vector<RowGroup> ::const_iterator _iter192;
+    duckdb::vector<RowGroup> ::const_iterator _iter192;
     for (_iter192 = this->row_groups.begin(); _iter192 != this->row_groups.end(); ++_iter192)
     {
       xfer += (*_iter192).write(oprot);
@@ -6461,7 +6461,7 @@ uint32_t FileMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* oprot
     xfer += oprot->writeFieldBegin("key_value_metadata", ::duckdb_apache::thrift::protocol::T_LIST, 5);
     {
       xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->key_value_metadata.size()));
-      std::vector<KeyValue> ::const_iterator _iter193;
+      duckdb::vector<KeyValue> ::const_iterator _iter193;
       for (_iter193 = this->key_value_metadata.begin(); _iter193 != this->key_value_metadata.end(); ++_iter193)
       {
         xfer += (*_iter193).write(oprot);
@@ -6479,7 +6479,7 @@ uint32_t FileMetaData::write(::duckdb_apache::thrift::protocol::TProtocol* oprot
     xfer += oprot->writeFieldBegin("column_orders", ::duckdb_apache::thrift::protocol::T_LIST, 7);
     {
       xfer += oprot->writeListBegin(::duckdb_apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->column_orders.size()));
-      std::vector<ColumnOrder> ::const_iterator _iter194;
+      duckdb::vector<ColumnOrder> ::const_iterator _iter194;
       for (_iter194 = this->column_orders.begin(); _iter194 != this->column_orders.end(); ++_iter194)
       {
         xfer += (*_iter194).write(oprot);

package/src/duckdb/third_party/parquet/parquet_types.h

@@ -9,6 +9,8 @@
 
 #include <iosfwd>
 
+#include "duckdb/common/vector.hpp"
+
 #include "thrift/Thrift.h"
 #include "thrift/TApplicationException.h"
 #include "thrift/TBase.h"
@@ -1642,26 +1644,26 @@ class ColumnMetaData : public virtual ::duckdb_apache::thrift::TBase {
 
   virtual ~ColumnMetaData() throw();
   Type::type type;
-  std::vector<Encoding::type>  encodings;
-  std::vector<std::string>  path_in_schema;
+  duckdb::vector<Encoding::type>  encodings;
+  duckdb::vector<std::string>  path_in_schema;
   CompressionCodec::type codec;
   int64_t num_values;
   int64_t total_uncompressed_size;
   int64_t total_compressed_size;
-  std::vector<KeyValue>  key_value_metadata;
+  duckdb::vector<KeyValue>  key_value_metadata;
   int64_t data_page_offset;
   int64_t index_page_offset;
   int64_t dictionary_page_offset;
   Statistics statistics;
-  std::vector<PageEncodingStats>  encoding_stats;
+  duckdb::vector<PageEncodingStats>  encoding_stats;
 
   _ColumnMetaData__isset __isset;
 
   void __set_type(const Type::type val);
 
-  void __set_encodings(const std::vector<Encoding::type> & val);
+  void __set_encodings(const duckdb::vector<Encoding::type> & val);
 
-  void __set_path_in_schema(const std::vector<std::string> & val);
+  void __set_path_in_schema(const duckdb::vector<std::string> & val);
 
   void __set_codec(const CompressionCodec::type val);
 
@@ -1671,7 +1673,7 @@ class ColumnMetaData : public virtual ::duckdb_apache::thrift::TBase {
 
   void __set_total_compressed_size(const int64_t val);
 
-  void __set_key_value_metadata(const std::vector<KeyValue> & val);
+  void __set_key_value_metadata(const duckdb::vector<KeyValue> & val);
 
   void __set_data_page_offset(const int64_t val);
 
@@ -1681,7 +1683,7 @@ class ColumnMetaData : public virtual ::duckdb_apache::thrift::TBase {
 
   void __set_statistics(const Statistics& val);
 
-  void __set_encoding_stats(const std::vector<PageEncodingStats> & val);
+  void __set_encoding_stats(const duckdb::vector<PageEncodingStats> & val);
 
   bool operator == (const ColumnMetaData & rhs) const
   {
@@ -1784,12 +1786,12 @@ class EncryptionWithColumnKey : public virtual ::duckdb_apache::thrift::TBase {
   }
 
   virtual ~EncryptionWithColumnKey() throw();
-  std::vector<std::string>  path_in_schema;
+  duckdb::vector<std::string>  path_in_schema;
   std::string key_metadata;
 
   _EncryptionWithColumnKey__isset __isset;
 
-  void __set_path_in_schema(const std::vector<std::string> & val);
+  void __set_path_in_schema(const duckdb::vector<std::string> & val);
 
   void __set_key_metadata(const std::string& val);
 
@@ -1993,23 +1995,23 @@ class RowGroup : public virtual ::duckdb_apache::thrift::TBase {
   }
 
   virtual ~RowGroup() throw();
-  std::vector<ColumnChunk>  columns;
+  duckdb::vector<ColumnChunk>  columns;
   int64_t total_byte_size;
   int64_t num_rows;
-  std::vector<SortingColumn>  sorting_columns;
+  duckdb::vector<SortingColumn>  sorting_columns;
   int64_t file_offset;
   int64_t total_compressed_size;
   int16_t ordinal;
 
   _RowGroup__isset __isset;
 
-  void __set_columns(const std::vector<ColumnChunk> & val);
+  void __set_columns(const duckdb::vector<ColumnChunk> & val);
 
   void __set_total_byte_size(const int64_t val);
 
   void __set_num_rows(const int64_t val);
 
-  void __set_sorting_columns(const std::vector<SortingColumn> & val);
+  void __set_sorting_columns(const duckdb::vector<SortingColumn> & val);
 
   void __set_file_offset(const int64_t val);
 
@@ -2190,9 +2192,9 @@ class OffsetIndex : public virtual ::duckdb_apache::thrift::TBase {
   }
 
   virtual ~OffsetIndex() throw();
-  std::vector<PageLocation>  page_locations;
+  duckdb::vector<PageLocation>  page_locations;
 
-  void __set_page_locations(const std::vector<PageLocation> & val);
+  void __set_page_locations(const duckdb::vector<PageLocation> & val);
 
   bool operator == (const OffsetIndex & rhs) const
   {
@@ -2230,23 +2232,23 @@ class ColumnIndex : public virtual ::duckdb_apache::thrift::TBase {
   }
 
   virtual ~ColumnIndex() throw();
-  std::vector<bool>  null_pages;
-  std::vector<std::string>  min_values;
-  std::vector<std::string>  max_values;
+  duckdb::vector<bool>  null_pages;
+  duckdb::vector<std::string>  min_values;
+  duckdb::vector<std::string>  max_values;
   BoundaryOrder::type boundary_order;
-  std::vector<int64_t>  null_counts;
+  duckdb::vector<int64_t>  null_counts;
 
   _ColumnIndex__isset __isset;
 
-  void __set_null_pages(const std::vector<bool> & val);
+  void __set_null_pages(const duckdb::vector<bool> & val);
 
-  void __set_min_values(const std::vector<std::string> & val);
+  void __set_min_values(const duckdb::vector<std::string> & val);
 
-  void __set_max_values(const std::vector<std::string> & val);
+  void __set_max_values(const duckdb::vector<std::string> & val);
 
   void __set_boundary_order(const BoundaryOrder::type val);
 
-  void __set_null_counts(const std::vector<int64_t> & val);
+  void __set_null_counts(const duckdb::vector<int64_t> & val);
 
   bool operator == (const ColumnIndex & rhs) const
   {
@@ -2471,12 +2473,12 @@ class FileMetaData : public virtual ::duckdb_apache::thrift::TBase {
 
   virtual ~FileMetaData() throw();
   int32_t version;
-  std::vector<SchemaElement>  schema;
+  duckdb::vector<SchemaElement>  schema;
   int64_t num_rows;
-  std::vector<RowGroup>  row_groups;
-  std::vector<KeyValue>  key_value_metadata;
+  duckdb::vector<RowGroup>  row_groups;
+  duckdb::vector<KeyValue>  key_value_metadata;
   std::string created_by;
-  std::vector<ColumnOrder>  column_orders;
+  duckdb::vector<ColumnOrder>  column_orders;
   EncryptionAlgorithm encryption_algorithm;
   std::string footer_signing_key_metadata;
 
@@ -2484,17 +2486,17 @@ class FileMetaData : public virtual ::duckdb_apache::thrift::TBase {
 
   void __set_version(const int32_t val);
 
-  void __set_schema(const std::vector<SchemaElement> & val);
+  void __set_schema(const duckdb::vector<SchemaElement> & val);
 
   void __set_num_rows(const int64_t val);
 
-  void __set_row_groups(const std::vector<RowGroup> & val);
+  void __set_row_groups(const duckdb::vector<RowGroup> & val);
 
-  void __set_key_value_metadata(const std::vector<KeyValue> & val);
+  void __set_key_value_metadata(const duckdb::vector<KeyValue> & val);
 
   void __set_created_by(const std::string& val);
 
-  void __set_column_orders(const std::vector<ColumnOrder> & val);
+  void __set_column_orders(const duckdb::vector<ColumnOrder> & val);
 
   void __set_encryption_algorithm(const EncryptionAlgorithm& val);
 

package/src/duckdb/third_party/re2/re2/re2.cc

@@ -566,6 +566,15 @@ static int ascii_strcasecmp(const char* a, const char* b, size_t len) {
   return 0;
 }
 
+RE2::Anchor RE2::Anchored() const {
+  if (prog_->anchor_start()) {
+    if (prog_->anchor_end()) {
+      return Anchor::ANCHOR_BOTH;
+    }
+    return Anchor::ANCHOR_START;
+  }
+  return Anchor::UNANCHORED;
+}
 
 /***** Actual matching and rewriting code *****/
 

package/src/duckdb/third_party/re2/re2/re2.h

@@ -475,6 +475,8 @@ class RE2 {
     ANCHOR_BOTH         // Anchor at start and end
   };
 
+  Anchor Anchored() const;
+
   // Return the number of capturing subpatterns, or -1 if the
   // regexp wasn't valid on construction.  The overall match ($0)
   // does not count: if the regexp is "(a)(b)", returns 2.

package/src/duckdb/third_party/thrift/thrift/TToString.h

@@ -26,7 +26,7 @@
 #include <set>
 #include <sstream>
 #include <string>
-#include <vector>
+#include "duckdb/common/vector.hpp"
 
 namespace duckdb_apache {
 namespace thrift {
@@ -68,7 +68,7 @@ template <typename T>
 std::string to_string(const std::set<T>& s);
 
 template <typename T>
-std::string to_string(const std::vector<T>& t);
+std::string to_string(const duckdb::vector<T>& t);
 
 template <typename K, typename V>
 std::string to_string(const typename std::pair<K, V>& v) {
@@ -89,7 +89,7 @@ std::string to_string(const T& beg, const T& end) {
 }
 
 template <typename T>
-std::string to_string(const std::vector<T>& t) {
+std::string to_string(const duckdb::vector<T>& t) {
   std::ostringstream o;
   o << "[" << to_string(t.begin(), t.end()) << "]";
   return o.str();

package/src/duckdb/third_party/thrift/thrift/protocol/TProtocol.h

@@ -36,7 +36,7 @@
 #include <sys/types.h>
 #include <string>
 #include <map>
-#include <vector>
+#include "duckdb/common/vector.hpp"
 #include <climits>
 
 // Use this to get around strict aliasing rules.

package/src/duckdb/third_party/thrift/thrift/protocol/TProtocolDecorator.h

@@ -22,6 +22,7 @@
 
 #include "thrift/protocol/TProtocol.h"
 #include <memory>
+#include "duckdb/common/vector.hpp"
 
 namespace duckdb_apache {
 namespace thrift {
@@ -126,7 +127,7 @@ public:
   uint32_t readSetEnd_virt() override { return protocol->readSetEnd(); }
 
   uint32_t readBool_virt(bool& value) override { return protocol->readBool(value); }
-  uint32_t readBool_virt(std::vector<bool>::reference value) override {
+  uint32_t readBool_virt(duckdb::vector<bool>::reference value) override {
     return protocol->readBool(value);
   }
 

package/src/duckdb/third_party/thrift/thrift/protocol/TVirtualProtocol.h

@@ -21,6 +21,7 @@
 #define _DUCKDB_THRIFT_PROTOCOL_TVIRTUALPROTOCOL_H_ 1
 
 #include "thrift/protocol/TProtocol.h"
+#include "duckdb/common/vector.hpp"
 
 namespace duckdb_apache {
 namespace thrift {
@@ -121,7 +122,7 @@ public:
                              "this protocol does not support reading (yet).");
   }
 
-  uint32_t readBool(std::vector<bool>::reference value) {
+  uint32_t readBool(duckdb::vector<bool>::reference value) {
     (void)value;
     throw TProtocolException(TProtocolException::NOT_IMPLEMENTED,
                              "this protocol does not support reading (yet).");
@@ -439,7 +440,7 @@ public:
     return static_cast<Protocol_*>(this)->readBool(value);
   }
 
-  uint32_t readBool_virt(std::vector<bool>::reference value) override {
+  uint32_t readBool_virt(duckdb::vector<bool>::reference value) override {
     return static_cast<Protocol_*>(this)->readBool(value);
   }
 
@@ -490,12 +491,12 @@ public:
 
   /*
    * Provide a default readBool() implementation for use with
-   * std::vector<bool>, that behaves the same as reading into a normal bool.
+   * duckdb::vector<bool>, that behaves the same as reading into a normal bool.
    *
    * Subclasses can override this if desired, but there normally shouldn't
    * be a need to.
    */
-  uint32_t readBool(std::vector<bool>::reference value) {
+  uint32_t readBool(duckdb::vector<bool>::reference value) {
     bool b = false;
     uint32_t ret = static_cast<Protocol_*>(this)->readBool(b);
     value = b;

package/src/duckdb/ub_extension_icu_third_party_icu_i18n.cpp

@@ -350,15 +350,15 @@
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-strtod.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
-
 #include "extension/icu/third_party/icu/i18n/double-conversion-bignum.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
 
 #include "extension/icu/third_party/icu/i18n/double-conversion-double-to-string.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-string-to-double.cpp"
 
-#include "extension/icu/third_party/icu/i18n/double-conversion-cached-powers.cpp"
+#include "extension/icu/third_party/icu/i18n/double-conversion-fast-dtoa.cpp"
+
+#include "extension/icu/third_party/icu/i18n/double-conversion-bignum-dtoa.cpp"
 

package/src/duckdb/ub_extension_json_json_functions.cpp

@@ -20,6 +20,8 @@
 
 #include "extension/json/json_functions/json_valid.cpp"
 
+#include "extension/json/json_functions/json_serialize_sql.cpp"
+
 #include "extension/json/json_functions/read_json.cpp"
 
 #include "extension/json/json_functions/read_json_objects.cpp"

package/src/duckdb/ub_src_common.cpp

@@ -24,6 +24,8 @@
 
 #include "src/common/file_system.cpp"
 
+#include "src/common/filename_pattern.cpp"
+
 #include "src/common/fsst.cpp"
 
 #include "src/common/gzip_file_system.cpp"
@@ -34,6 +36,8 @@
 
 #include "src/common/local_file_system.cpp"
 
+#include "src/common/multi_file_reader.cpp"
+
 #include "src/common/preserved_error.cpp"
 
 #include "src/common/printer.cpp"
@@ -52,6 +56,8 @@
 
 #include "src/common/types.cpp"
 
+#include "src/common/vector.cpp"
+
 #include "src/common/virtual_file_system.cpp"
 
 #include "src/common/windows_util.cpp"

package/src/duckdb/ub_src_common_adbc.cpp

@@ -0,0 +1,4 @@
+#include "src/common/adbc/adbc.cpp"
+
+#include "src/common/adbc/driver_manager.cpp"
+

package/src/duckdb/ub_src_common_serializer.cpp

@@ -6,3 +6,5 @@
 
 #include "src/common/serializer/buffered_serializer.cpp"
 
+#include "src/common/serializer/enum_serializer.cpp"
+

package/src/duckdb/ub_src_common_sort.cpp

@@ -2,6 +2,8 @@
 
 #include "src/common/sort/merge_sorter.cpp"
 
+#include "src/common/sort/partition_state.cpp"
+
 #include "src/common/sort/radix_sort.cpp"
 
 #include "src/common/sort/sort_state.cpp"