duckdb 1.3.4 → 1.4.0

package/src/duckdb/third_party/snappy/snappy-stubs-internal.h

@@ -447,15 +447,15 @@ inline int Bits::FindLSBSetNonZero64(uint64_t n) {
 #endif  // HAVE_BUILTIN_CTZ
 
 // Variable-length integer encoding.
-class Varint {
+class Bignum {
  public:
-  // Maximum lengths of varint encoding of uint32_t.
+  // Maximum lengths of bignum encoding of uint32_t.
   static const int kMax32 = 5;
 
-  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
-  // Never reads a character at or beyond limit.  If a valid/terminated varint32
+  // Attempts to parse a bignum32 from a prefix of the bytes in [ptr,limit-1].
+  // Never reads a character at or beyond limit.  If a valid/terminated bignum32
   // was found in the range, stores it in *OUTPUT and returns a pointer just
-  // past the last byte of the varint32. Else returns NULL.  On success,
+  // past the last byte of the bignum32. Else returns NULL.  On success,
   // "result <= limit".
   static const char* Parse32WithLimit(const char* ptr, const char* limit,
                                       uint32_t* OUTPUT);
@@ -465,11 +465,11 @@ class Varint {
   //            byte just past the last encoded byte.
   static char* Encode32(char* ptr, uint32_t v);
 
-  // EFFECTS    Appends the varint representation of "value" to "*s".
+  // EFFECTS    Appends the bignum representation of "value" to "*s".
   static void Append32(std::string* s, uint32_t value);
 };
 
-inline const char* Varint::Parse32WithLimit(const char* p,
+inline const char* Bignum::Parse32WithLimit(const char* p,
                                             const char* l,
                                             uint32_t* OUTPUT) {
   const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
@@ -485,13 +485,13 @@ inline const char* Varint::Parse32WithLimit(const char* p,
   b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
   if (ptr >= limit) return NULL;
   b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
-  return NULL;       // Value is too long to be a varint32
+  return NULL;       // Value is too long to be a bignum32
  done:
   *OUTPUT = result;
   return reinterpret_cast<const char*>(ptr);
 }
 
-inline char* Varint::Encode32(char* sptr, uint32_t v) {
+inline char* Bignum::Encode32(char* sptr, uint32_t v) {
   // Operate on characters as unsigneds
   uint8_t* ptr = reinterpret_cast<uint8_t*>(sptr);
   static const uint8_t B = 128;
@@ -923,15 +923,15 @@ inline int Bits::FindLSBSetNonZero64(uint64 n) {
 #endif  // End portable versions.
 
 // Variable-length integer encoding.
-class Varint {
+class Bignum {
  public:
-  // Maximum lengths of varint encoding of uint32.
+  // Maximum lengths of bignum encoding of uint32.
   static const int kMax32 = 5;
 
-  // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1].
-  // Never reads a character at or beyond limit.  If a valid/terminated varint32
+  // Attempts to parse a bignum32 from a prefix of the bytes in [ptr,limit-1].
+  // Never reads a character at or beyond limit.  If a valid/terminated bignum32
   // was found in the range, stores it in *OUTPUT and returns a pointer just
-  // past the last byte of the varint32. Else returns NULL.  On success,
+  // past the last byte of the bignum32. Else returns NULL.  On success,
   // "result <= limit".
   static const char* Parse32WithLimit(const char* ptr, const char* limit,
                                       uint32* OUTPUT);
@@ -941,11 +941,11 @@ class Varint {
   //            byte just past the last encoded byte.
   static char* Encode32(char* ptr, uint32 v);
 
-  // EFFECTS    Appends the varint representation of "value" to "*s".
+  // EFFECTS    Appends the bignum representation of "value" to "*s".
   static void Append32(string* s, uint32 value);
 };
 
-inline const char* Varint::Parse32WithLimit(const char* p,
+inline const char* Bignum::Parse32WithLimit(const char* p,
                                             const char* l,
                                             uint32* OUTPUT) {
   const unsigned char* ptr = reinterpret_cast<const unsigned char*>(p);
@@ -961,13 +961,13 @@ inline const char* Varint::Parse32WithLimit(const char* p,
   b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done;
   if (ptr >= limit) return NULL;
   b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done;
-  return NULL;       // Value is too long to be a varint32
+  return NULL;       // Value is too long to be a bignum32
  done:
   *OUTPUT = result;
   return reinterpret_cast<const char*>(ptr);
 }
 
-inline char* Varint::Encode32(char* sptr, uint32 v) {
+inline char* Bignum::Encode32(char* sptr, uint32 v) {
   // Operate on characters as unsigneds
   unsigned char* ptr = reinterpret_cast<unsigned char*>(sptr);
   static const int B = 128;

package/src/duckdb/third_party/snappy/snappy.cc

@@ -729,7 +729,7 @@ static inline char* EmitCopy(char* op, size_t offset, size_t len) {
 bool GetUncompressedLength(const char* start, size_t n, size_t* result) {
   uint32_t v = 0;
   const char* limit = start + n;
-  if (Varint::Parse32WithLimit(start, limit, &v) != NULL) {
+  if (Bignum::Parse32WithLimit(start, limit, &v) != NULL) {
     *result = v;
     return true;
   } else {
@@ -1806,8 +1806,8 @@ size_t Compress(Source* reader, Sink* writer, CompressionOptions options) {
   size_t written = 0;
   size_t N = reader->Available();
   const size_t uncompressed_size = N;
-  char ulength[Varint::kMax32];
-  char* p = Varint::Encode32(ulength, N);
+  char ulength[Bignum::kMax32];
+  char* p = Bignum::Encode32(ulength, N);
   writer->Append(ulength, p - ulength);
   written += (p - ulength);
 
@@ -3058,7 +3058,7 @@ static inline char* EmitCopy(char* op, size_t offset, size_t len) {
 bool GetUncompressedLength(const char* start, size_t n, size_t* result) {
   uint32 v = 0;
   const char* limit = start + n;
-  if (Varint::Parse32WithLimit(start, limit, &v) != NULL) {
+  if (Bignum::Parse32WithLimit(start, limit, &v) != NULL) {
     *result = v;
     return true;
   } else {
@@ -3626,8 +3626,8 @@ size_t Compress(Source* reader, Sink* writer) {
   size_t written = 0;
   size_t N = reader->Available();
   const size_t uncompressed_size = N;
-  char ulength[Varint::kMax32];
-  char* p = Varint::Encode32(ulength, N);
+  char ulength[Bignum::kMax32];
+  char* p = Bignum::Encode32(ulength, N);
   writer->Append(ulength, p-ulength);
   written += (p - ulength);
 

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

@@ -156,8 +156,8 @@ protected:
                                   const int16_t fieldId,
                                   int8_t typeOverride);
   uint32_t writeCollectionBegin(const TType elemType, int32_t size);
-  uint32_t writeVarint32(uint32_t n);
-  uint32_t writeVarint64(uint64_t n);
+  uint32_t writeBignum32(uint32_t n);
+  uint32_t writeBignum64(uint64_t n);
   uint64_t i64ToZigzag(const int64_t l);
   uint32_t i32ToZigzag(const int32_t n);
   inline int8_t getCompactType(const TType ttype);
@@ -206,8 +206,8 @@ public:
   uint32_t readSetEnd() { return 0; }
 
 protected:
-  uint32_t readVarint32(int32_t& i32);
-  uint32_t readVarint64(int64_t& i64);
+  uint32_t readBignum32(int32_t& i32);
+  uint32_t readBignum64(int64_t& i64);
   int32_t zigzagToI32(uint32_t n);
   int64_t zigzagToI64(uint64_t n);
   TType getTType(int8_t type);

package/src/duckdb/third_party/thrift/thrift/protocol/TCompactProtocol.tcc

@@ -93,7 +93,7 @@ uint32_t TCompactProtocolT<Transport_>::writeMessageBegin(
   uint32_t wsize = 0;
   wsize += writeByte(PROTOCOL_ID);
   wsize += writeByte((VERSION_N & VERSION_MASK) | (((int32_t)messageType << TYPE_SHIFT_AMOUNT) & TYPE_MASK));
-  wsize += writeVarint32(seqid);
+  wsize += writeBignum32(seqid);
   wsize += writeString(name);
   return wsize;
 }
@@ -102,7 +102,7 @@ uint32_t TCompactProtocolT<Transport_>::writeMessageBegin(
  * Write a field header containing the field id and field type. If the
  * difference between the current field id and the last one is small (< 15),
  * then the field id will be encoded in the 4 MSB as a delta. Otherwise, the
- * field id will follow the type header as a zigzag varint.
+ * field id will follow the type header as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::writeFieldBegin(const char* name,
@@ -182,7 +182,7 @@ uint32_t TCompactProtocolT<Transport_>::writeMapBegin(const TType keyType,
   if (size == 0) {
     wsize += writeByte(0);
   } else {
-    wsize += writeVarint32(size);
+    wsize += writeBignum32(size);
     wsize += writeByte(getCompactType(keyType) << 4 | getCompactType(valType));
   }
   return wsize;
@@ -225,27 +225,27 @@ uint32_t TCompactProtocolT<Transport_>::writeByte(const int8_t byte) {
 }
 
 /**
- * Write an i16 as a zigzag varint.
+ * Write an i16 as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::writeI16(const int16_t i16) {
-  return writeVarint32(i32ToZigzag(i16));
+  return writeBignum32(i32ToZigzag(i16));
 }
 
 /**
- * Write an i32 as a zigzag varint.
+ * Write an i32 as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::writeI32(const int32_t i32) {
-  return writeVarint32(i32ToZigzag(i32));
+  return writeBignum32(i32ToZigzag(i32));
 }
 
 /**
- * Write an i64 as a zigzag varint.
+ * Write an i64 as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::writeI64(const int64_t i64) {
-  return writeVarint64(i64ToZigzag(i64));
+  return writeBignum64(i64ToZigzag(i64));
 }
 
 /**
@@ -263,7 +263,7 @@ uint32_t TCompactProtocolT<Transport_>::writeDouble(const double dub) {
 }
 
 /**
- * Write a string to the wire with a varint size preceding.
+ * Write a string to the wire with a bignum size preceding.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::writeString(const std::string& str) {
@@ -275,7 +275,7 @@ uint32_t TCompactProtocolT<Transport_>::writeBinary(const std::string& str) {
   if(str.size() > (std::numeric_limits<uint32_t>::max)())
     throw TProtocolException(TProtocolException::SIZE_LIMIT);
   uint32_t ssize = static_cast<uint32_t>(str.size());
-  uint32_t wsize = writeVarint32(ssize) ;
+  uint32_t wsize = writeBignum32(ssize) ;
   // checking ssize + wsize > uint_max, but we don't want to overflow while checking for overflows.
   // transforming the check to ssize > uint_max - wsize
   if(ssize > (std::numeric_limits<uint32_t>::max)() - wsize)
@@ -334,16 +334,16 @@ uint32_t TCompactProtocolT<Transport_>::writeCollectionBegin(const TType elemTyp
                                            << 4 | getCompactType(elemType)));
   } else {
     wsize += writeByte(0xf0 | getCompactType(elemType));
-    wsize += writeVarint32(size);
+    wsize += writeBignum32(size);
   }
   return wsize;
 }
 
 /**
- * Write an i32 as a varint. Results in 1-5 bytes on the wire.
+ * Write an i32 as a bignum. Results in 1-5 bytes on the wire.
  */
 template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeVarint32(uint32_t n) {
+uint32_t TCompactProtocolT<Transport_>::writeBignum32(uint32_t n) {
   uint8_t buf[5];
   uint32_t wsize = 0;
 
@@ -361,10 +361,10 @@ uint32_t TCompactProtocolT<Transport_>::writeVarint32(uint32_t n) {
 }
 
 /**
- * Write an i64 as a varint. Results in 1-10 bytes on the wire.
+ * Write an i64 as a bignum. Results in 1-10 bytes on the wire.
  */
 template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::writeVarint64(uint64_t n) {
+uint32_t TCompactProtocolT<Transport_>::writeBignum64(uint64_t n) {
   uint8_t buf[10];
   uint32_t wsize = 0;
 
@@ -383,7 +383,7 @@ uint32_t TCompactProtocolT<Transport_>::writeVarint64(uint64_t n) {
 
 /**
  * Convert l into a zigzag long. This allows negative numbers to be
- * represented compactly as a varint.
+ * represented compactly as a bignum.
  */
 template <class Transport_>
 uint64_t TCompactProtocolT<Transport_>::i64ToZigzag(const int64_t l) {
@@ -392,7 +392,7 @@ uint64_t TCompactProtocolT<Transport_>::i64ToZigzag(const int64_t l) {
 
 /**
  * Convert n into a zigzag int. This allows negative numbers to be
- * represented compactly as a varint.
+ * represented compactly as a bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::i32ToZigzag(const int32_t n) {
@@ -436,7 +436,7 @@ uint32_t TCompactProtocolT<Transport_>::readMessageBegin(
   }
 
   messageType = (TMessageType)((versionAndType >> TYPE_SHIFT_AMOUNT) & TYPE_BITS);
-  rsize += readVarint32(seqid);
+  rsize += readBignum32(seqid);
   rsize += readString(name);
 
   return rsize;
@@ -490,7 +490,7 @@ uint32_t TCompactProtocolT<Transport_>::readFieldBegin(std::string& name,
   // mask off the 4 MSB of the type header. it could contain a field id delta.
   int16_t modifier = (int16_t)(((uint8_t)byte & 0xf0) >> 4);
   if (modifier == 0) {
-    // not a delta, look ahead for the zigzag varint field id.
+    // not a delta, look ahead for the zigzag bignum field id.
     rsize += readI16(fieldId);
   } else {
     fieldId = (int16_t)(lastFieldId_ + modifier);
@@ -524,7 +524,7 @@ uint32_t TCompactProtocolT<Transport_>::readMapBegin(TType& keyType,
   int8_t kvType = 0;
   int32_t msize = 0;
 
-  rsize += readVarint32(msize);
+  rsize += readBignum32(msize);
   if (msize != 0)
     rsize += readByte(kvType);
 
@@ -544,7 +544,7 @@ uint32_t TCompactProtocolT<Transport_>::readMapBegin(TType& keyType,
 /**
  * Read a list header off the wire. If the list size is 0-14, the size will
  * be packed into the element type header. If it's a longer list, the 4 MSB
- * of the element type header will be 0xF, and a varint will follow with the
+ * of the element type header will be 0xF, and a bignum will follow with the
  * true size.
  */
 template <class Transport_>
@@ -558,7 +558,7 @@ uint32_t TCompactProtocolT<Transport_>::readListBegin(TType& elemType,
 
   lsize = ((uint8_t)size_and_type >> 4) & 0x0f;
   if (lsize == 15) {
-    rsize += readVarint32(lsize);
+    rsize += readBignum32(lsize);
   }
 
   if (lsize < 0) {
@@ -576,7 +576,7 @@ uint32_t TCompactProtocolT<Transport_>::readListBegin(TType& elemType,
 /**
  * Read a set header off the wire. If the set size is 0-14, the size will
  * be packed into the element type header. If it's a longer set, the 4 MSB
- * of the element type header will be 0xF, and a varint will follow with the
+ * of the element type header will be 0xF, and a bignum will follow with the
  * true size.
  */
 template <class Transport_>
@@ -616,34 +616,34 @@ uint32_t TCompactProtocolT<Transport_>::readByte(int8_t& byte) {
 }
 
 /**
- * Read an i16 from the wire as a zigzag varint.
+ * Read an i16 from the wire as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::readI16(int16_t& i16) {
   int32_t value;
-  uint32_t rsize = readVarint32(value);
+  uint32_t rsize = readBignum32(value);
   i16 = (int16_t)zigzagToI32(value);
   return rsize;
 }
 
 /**
- * Read an i32 from the wire as a zigzag varint.
+ * Read an i32 from the wire as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::readI32(int32_t& i32) {
   int32_t value;
-  uint32_t rsize = readVarint32(value);
+  uint32_t rsize = readBignum32(value);
   i32 = zigzagToI32(value);
   return rsize;
 }
 
 /**
- * Read an i64 from the wire as a zigzag varint.
+ * Read an i64 from the wire as a zigzag bignum.
  */
 template <class Transport_>
 uint32_t TCompactProtocolT<Transport_>::readI64(int64_t& i64) {
   int64_t value;
-  uint32_t rsize = readVarint64(value);
+  uint32_t rsize = readBignum64(value);
   i64 = zigzagToI64(value);
   return rsize;
 }
@@ -679,7 +679,7 @@ uint32_t TCompactProtocolT<Transport_>::readBinary(std::string& str) {
   int32_t rsize = 0;
   int32_t size;
 
-  rsize += readVarint32(size);
+  rsize += readBignum32(size);
   // Catch empty string case
   if (size == 0) {
     str = "";
@@ -710,23 +710,23 @@ uint32_t TCompactProtocolT<Transport_>::readBinary(std::string& str) {
 }
 
 /**
- * Read an i32 from the wire as a varint. The MSB of each byte is set
+ * Read an i32 from the wire as a bignum. The MSB of each byte is set
  * if there is another byte to follow. This can read up to 5 bytes.
  */
 template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readVarint32(int32_t& i32) {
+uint32_t TCompactProtocolT<Transport_>::readBignum32(int32_t& i32) {
   int64_t val;
-  uint32_t rsize = readVarint64(val);
+  uint32_t rsize = readBignum64(val);
   i32 = (int32_t)val;
   return rsize;
 }
 
 /**
- * Read an i64 from the wire as a proper varint. The MSB of each byte is set
+ * Read an i64 from the wire as a proper bignum. The MSB of each byte is set
  * if there is another byte to follow. This can read up to 10 bytes.
  */
 template <class Transport_>
-uint32_t TCompactProtocolT<Transport_>::readVarint64(int64_t& i64) {
+uint32_t TCompactProtocolT<Transport_>::readBignum64(int64_t& i64) {
   uint32_t rsize = 0;
   uint64_t val = 0;
   int shift = 0;

package/src/duckdb/third_party/utf8proc/include/utf8proc_wrapper.hpp

@@ -16,7 +16,7 @@
 namespace duckdb {
 class GraphemeIterator;
 
-enum class UnicodeType { INVALID, ASCII, UNICODE };
+enum class UnicodeType { INVALID, ASCII, UTF8 };
 enum class UnicodeInvalidReason { BYTE_MISMATCH, INVALID_UNICODE };
 
 class Utf8Proc {

package/src/duckdb/third_party/utf8proc/utf8proc_wrapper.cpp

@@ -69,7 +69,7 @@ static inline UnicodeType UTF8ExtraByteLoop(const int first_pos_seq, int utf8cha
 		AssignInvalidUTF8Reason(invalid_reason, invalid_pos, first_pos_seq, UnicodeInvalidReason::INVALID_UNICODE);
 		return UnicodeType::INVALID;
 	}
-	return UnicodeType::UNICODE;
+	return UnicodeType::UTF8;
 }
 
 UnicodeType Utf8Proc::Analyze(const char *s, size_t len, UnicodeInvalidReason *invalid_reason, size_t *invalid_pos) {

package/src/duckdb/third_party/vergesort/detail/insertion_sort.h

@@ -0,0 +1,56 @@
+/*
+    pdqsort.h - Pattern-defeating quicksort.
+
+    Copyright (c) 2015 Orson Peters
+    Modified by Morwenn in 2015-2016 to use in vergesort
+
+    This software is provided 'as-is', without any express or implied warranty. In no event will the
+    authors be held liable for any damages arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose, including commercial
+    applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not claim that you wrote the
+       original software. If you use this software in a product, an acknowledgment in the product
+       documentation would be appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be misrepresented as
+       being the original software.
+
+    3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef VERGESORT_DETAIL_INSERTION_SORT_H_
+#define VERGESORT_DETAIL_INSERTION_SORT_H_
+
+#include <iterator>
+#include "detail/prevnext.h"
+
+namespace duckdb_vergesort
+{
+namespace detail
+{
+    // Sorts [begin, end) using insertion sort with the given comparison function.
+    template<typename BidirectionalIterator, typename Compare>
+    void insertion_sort(BidirectionalIterator begin, BidirectionalIterator end, Compare comp) {
+        typedef typename std::iterator_traits<BidirectionalIterator>::value_type T;
+        if (begin == end) return;
+
+        for (BidirectionalIterator cur = detail::next(begin) ; cur != end ; ++cur) {
+            BidirectionalIterator sift = cur;
+            BidirectionalIterator sift_1 = detail::prev(cur);
+
+            // Compare first so we can avoid 2 moves for an element already positioned correctly.
+            if (comp(*sift, *sift_1)) {
+                T tmp = VERGESORT_PREFER_MOVE(*sift);
+
+                do {
+                    *sift-- = VERGESORT_PREFER_MOVE(*sift_1);
+                } while (sift != begin && comp(tmp, *--sift_1));
+
+                *sift = VERGESORT_PREFER_MOVE(tmp);
+            }
+        }
+    }
+}}
+
+#endif // VERGESORT_DETAIL_INSERTION_SORT_H_

package/src/duckdb/third_party/vergesort/detail/is_sorted_until.h

@@ -0,0 +1,51 @@
+/*
+ * vergesort.h - General-purpose hybrid sort
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2016 Morwenn <morwenn29@hotmail.fr>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef VERGESORT_DETAIL_IS_SORTED_UNTIL_H_
+#define VERGESORT_DETAIL_IS_SORTED_UNTIL_H_
+
+namespace duckdb_vergesort
+{
+namespace detail
+{
+    // C++03 implementation of std::is_sorted_until
+    template<typename ForwardIterator, typename Compare>
+    ForwardIterator is_sorted_until(ForwardIterator first, ForwardIterator last,
+                                    Compare compare)
+    {
+        if (first != last) {
+            ForwardIterator next = first;
+            while (++next != last) {
+                if (compare(*next, *first)) {
+                    return next;
+                }
+                first = next;
+            }
+        }
+        return last;
+    }
+}}
+
+#endif // VERGESORT_DETAIL_IS_SORTED_UNTIL_H_

package/src/duckdb/third_party/vergesort/detail/iter_sort3.h

@@ -0,0 +1,48 @@
+/*
+ * vergesort.h - General-purpose hybrid sort
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2016 Morwenn <morwenn29@hotmail.fr>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#ifndef VERGESORT_DETAIL_ITER_SORT3_H_
+#define VERGESORT_DETAIL_ITER_SORT3_H_
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <algorithm>
+
+namespace duckdb_vergesort
+{
+namespace detail
+{
+    template<typename Iterator, typename Compare>
+    void iter_sort3(Iterator a, Iterator b, Iterator c,
+                    Compare compare)
+    {
+        if (compare(*b, *a)) { std::iter_swap(a, b); }
+        if (compare(*c, *b)) { std::iter_swap(b, c); }
+        if (compare(*b, *a)) { std::iter_swap(a, b); }
+    }
+}}
+
+#endif // VERGESORT_DETAIL_ITER_SORT3_H_

package/src/duckdb/third_party/vergesort/detail/log2.h

@@ -0,0 +1,41 @@
+/*
+    pdqsort.h - Pattern-defeating quicksort.
+
+    Copyright (c) 2015 Orson Peters
+    Modified by Morwenn in 2015-2016 to use in vergesort
+
+    This software is provided 'as-is', without any express or implied warranty. In no event will the
+    authors be held liable for any damages arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose, including commercial
+    applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not claim that you wrote the
+       original software. If you use this software in a product, an acknowledgment in the product
+       documentation would be appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be misrepresented as
+       being the original software.
+
+    3. This notice may not be removed or altered from any source distribution.
+*/
+#ifndef VERGESORT_DETAIL_LOG2_H_
+#define VERGESORT_DETAIL_LOG2_H_
+
+namespace duckdb_vergesort
+{
+namespace detail
+{
+    // Returns floor(log2(n)), assumes n > 0
+    template<typename Integer>
+    Integer log2(Integer n)
+    {
+        Integer log = 0;
+        while (n >>= 1) {
+            ++log;
+        }
+        return log;
+    }
+}}
+
+#endif // VERGESORT_DETAIL_LOG2_H_