duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/third_party/skiplist/NodeRefs.h

@@ -0,0 +1,251 @@
+//
+//  NodeRefs.h
+//  SkipList
+//
+//  Created by Paul Ross on 03/12/2015.
+//  Copyright (c) 2017 Paul Ross. All rights reserved.
+//
+
+#ifndef SkipList_NodeRefs_h
+#define SkipList_NodeRefs_h
+
+#include "IntegrityEnums.h"
+
+/// Forward reference
+template<typename T, typename _Compare>
+class Node;
+
+/**
+ * @brief A PoD struct that contains a pointer to a Node and a width that represents the coarser linked list span to the
+ * next Node.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ */
+template<typename T, typename _Compare=std::less<T> >
+struct NodeRef {
+    Node<T, _Compare> *pNode;
+    size_t width;
+};
+
+/******************** SwappableNodeRefStack **********************/
+
+/**
+ * @brief Class that represents a stack of references to other nodes.
+ *
+ * Each reference is a NodeRef so a pointer to a Node and a width.
+ * This just does simple bookkeeping on this stack.
+ *
+ * It also facilitates swapping references with another SwappableNodeRefStack when inserting or removing a Node.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ */
+template<typename T, typename _Compare>
+class SwappableNodeRefStack {
+public:
+    /**
+     * Constructor. Initialises the swap level to 0.
+     */
+    SwappableNodeRefStack() : _swapLevel(0) {}
+
+    // Const methods
+    // -------------
+    // Subscript read/write
+    const NodeRef<T, _Compare> &operator[](size_t level) const;
+
+    NodeRef<T, _Compare> &operator[](size_t level);
+
+    /// Number of nodes referenced.
+    size_t height() const {
+        return _nodes.size();
+    }
+
+    /// The current swap level
+    size_t swapLevel() const { return _swapLevel; }
+
+    /// true if a swap can take place <tt>_swapLevel < height()</tt>
+    bool canSwap() const { return _swapLevel < height(); }
+
+    // Returns true if there is no record of p in my data that
+    // could lead to circular references
+    bool noNodePointerMatches(const Node<T, _Compare> *p) const;
+
+    // Returns true if all pointers in my data are equal to p.
+    bool allNodePointerMatch(const Node<T, _Compare> *p) const;
+
+    // Non-const methods
+    // -----------------
+    /// Add a new reference
+    void push_back(Node<T, _Compare> *p, size_t w) {
+        struct NodeRef<T, _Compare> val = {p, w};
+        _nodes.push_back(val);
+    }
+
+    /// Remove top reference
+    void pop_back() {
+        _nodes.pop_back();
+    }
+
+    // Swap reference at current swap level with another SwappableNodeRefStack
+    void swap(SwappableNodeRefStack<T, _Compare> &val);
+
+    /// Reset the swap level (for example before starting a remove).
+    void resetSwapLevel() { _swapLevel = 0; }
+
+    /// Increment the swap level.
+    /// This is used when removing nodes where the parent node can record to what level it has made its adjustments
+    /// so the grand parent knows where to start.
+    ///
+    /// For this reason the _swapLevel can easily be <tt>>= _nodes.size()</tt>.
+    void incSwapLevel() { ++_swapLevel; }
+
+    IntegrityCheck lacksIntegrity() const;
+
+    // Returns an estimate of the memory usage of an instance
+    size_t size_of() const;
+
+	// Resets to the construction state
+	void clear() { _swapLevel = 0; _nodes.clear(); }
+
+protected:
+    /// Stack of NodeRef node references.
+    std::vector<struct NodeRef<T, _Compare> > _nodes;
+    /// The current swap level.
+    size_t _swapLevel;
+
+private:
+    /// Prevent cctor
+    SwappableNodeRefStack(const SwappableNodeRefStack &that);
+
+    /// Prevent operator=
+    SwappableNodeRefStack &operator=(const SwappableNodeRefStack &that) const;
+};
+
+/**
+ * The readable NodeRef at the given level.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @param level The level.
+ * @return A reference to the Node.
+ */
+template<typename T, typename _Compare>
+const NodeRef<T, _Compare> &SwappableNodeRefStack<T, _Compare>::operator[](size_t level) const {
+    // NOTE: No bounds checking on vector::operator[], so this assert will do
+    assert(level < _nodes.size());
+    return _nodes[level];
+}
+
+/**
+ * The writeable NodeRef at the given level.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @param level The level.
+ * @return A reference to the Node.
+ */
+template<typename T, typename _Compare>
+NodeRef<T, _Compare> &SwappableNodeRefStack<T, _Compare>::operator[](size_t level) {
+    // NOTE: No bounds checking on vector::operator[], so this assert will do
+    assert(level < _nodes.size());
+    return _nodes[level];
+}
+
+/**
+ * Whether all node references are swapped.
+ * Should be true after an insert operation.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @param p The Node.
+ * @return true if all the Node references are swapped (none are referring to the given Node).
+ */
+template<typename T, typename _Compare>
+bool SwappableNodeRefStack<T, _Compare>::noNodePointerMatches(const Node<T, _Compare> *p) const {
+    for (size_t level = height(); level-- > 0;) {
+        if (p == _nodes[level].pNode) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Returns true if all pointers in my data are equal to p.
+ * Should be true after a remove operation.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @param p The Node.
+ * @return true if all the Node references are un-swapped (all are referring to the given Node).
+ */
+template<typename T, typename _Compare>
+bool SwappableNodeRefStack<T, _Compare>::allNodePointerMatch(const Node<T, _Compare> *p) const {
+    for (size_t level = height(); level-- > 0;) {
+        if (p != _nodes[level].pNode) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Swap references with another SwappableNodeRefStack at the current swap level.
+ * This also increments the swap level.
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @param val The SwappableNodeRefStack.
+ */
+template<typename T, typename _Compare>
+void SwappableNodeRefStack<T, _Compare>::swap(SwappableNodeRefStack<T, _Compare> &val) {
+    assert(_swapLevel < height());
+    NodeRef<T, _Compare> temp = val[_swapLevel];
+    val[_swapLevel] = _nodes[_swapLevel];
+    _nodes[_swapLevel] = temp;
+    ++_swapLevel;
+}
+
+/**
+ * This checks the internal consistency of the object. It returns
+ * INTEGRITY_SUCCESS [0] if successful or non-zero on error.
+ * The tests are:
+ *
+ * - Widths must all be >= 1
+ * - Widths must be weakly increasing with increasing level
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @return An IntegrityCheck enum.
+ */
+template<typename T, typename _Compare>
+IntegrityCheck SwappableNodeRefStack<T, _Compare>::lacksIntegrity() const {
+    if (height()) {
+        if (_nodes[0].width != 1) {
+            return NODEREFS_WIDTH_ZERO_NOT_UNITY;
+        }
+        for (size_t level = 1; level < height(); ++level) {
+            if (_nodes[level].width < _nodes[level - 1].width) {
+                return NODEREFS_WIDTH_DECREASING;
+            }
+        }
+    }
+    return INTEGRITY_SUCCESS;
+}
+
+/**
+ * Returns an estimate of the memory usage of an instance
+ *
+ * @tparam T The type of the Skip List Node values.
+ * @tparam _Compare A comparison function for type T.
+ * @return The memory estimate.
+ */
+template<typename T, typename _Compare>
+size_t SwappableNodeRefStack<T, _Compare>::size_of() const {
+    return sizeof(*this) + _nodes.capacity() * sizeof(struct NodeRef<T>);
+}
+
+/********************* END: SwappableNodeRefStack ****************************/
+
+#endif // SkipList_NodeRefs_h

package/src/duckdb/third_party/skiplist/RollingMedian.h

@@ -0,0 +1,202 @@
+#ifndef __SkipList__RollingMedian__
+#define __SkipList__RollingMedian__
+
+/**
+ * @file
+ *
+ * Project: skiplist
+ *
+ * Rolling Median.
+ *
+ * Created by Paul Ross on 18/12/2015.
+ *
+ * Copyright (c) 2015-2023 Paul Ross. All rights reserved.
+ *
+ * @code
+ * MIT License
+ *
+ * Copyright (c) 2015-2023 Paul Ross
+ *
+ * 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.
+ * @endcode
+ */
+
+#include <stdlib.h>
+
+#include "SkipList.h"
+
+namespace OrderedStructs {
+    /**
+     * @brief Namespace for the C++ Rolling Median.
+     */
+    namespace RollingMedian {
+
+/**
+ * Error codes.
+ */
+        enum RollingMedianResult {
+            ROLLING_MEDIAN_SUCCESS = 0,
+            ROLLING_MEDIAN_SOURCE_STRIDE,
+            ROLLING_MEDIAN_DESTINATION_STRIDE,
+            ROLLING_MEDIAN_WIN_LENGTH,
+        };
+
+/**
+ * Return an error code.
+ */
+#define ROLLING_MEDIAN_ERROR_CHECK                      \
+    do {                                                \
+        if (src_stride == 0) {                          \
+            return ROLLING_MEDIAN_SOURCE_STRIDE;        \
+        }                                               \
+        if (dest_stride == 0) {                         \
+            return ROLLING_MEDIAN_DESTINATION_STRIDE;   \
+        }                                               \
+        if (win_length == 0) {                          \
+            return ROLLING_MEDIAN_WIN_LENGTH;           \
+        }                                               \
+    } while (0)
+
+/* Helpers for the destination memory area.
+ * Iterating through the destination to see the replaced values is done thus:
+ *
+ * for (int i = 0;
+ *      i < RollingMedian::dest_size(COUNT, WIN_LENGTH, DEST_STRIDE);
+ *      i += DEST_STRIDE) {
+ *    ...
+ * }
+ */
+
+/**
+ * Returns the size of the destination array for a rolling median on an array
+ * of count values with a window of win_length and a destination stride.
+ *
+ * @param count Number of input values.
+ * @param win_length Window length.
+ * @return Number of destination values.
+ */
+        size_t dest_count(size_t count, size_t win_length) {
+            return 1 + count - win_length;
+        }
+
+/**
+ * Returns the size of the destination array for a rolling median on an array
+ * of count values with a window of win_length and a destination stride.
+ *
+ * @param count Number of input values.
+ * @param win_length Window length.
+ * @param dest_stride The destination stride given a 2D array.
+ * @return Size of destination array.
+ */
+        size_t dest_size(size_t count,
+                         size_t win_length,
+                         size_t dest_stride) {
+            return dest_count(count, win_length) * dest_stride;
+        }
+
+/**
+ * Rolling median where only the odd mid-index is considered.
+ * If the win_length is even then (win_length - 1) / 2 value is used.
+ * See even_odd_index() for a different treatment of even lengths.
+ * This is valid for all types T.
+ * It is up to the caller to ensure that there is enough space in dest for
+ * the results, use dest_size() for this.
+ *
+ * @tparam T Type of the value(s).
+ * @param src Source array of values.
+ * @param src_stride Source stride for 2D arrays.
+ * @param count Number of input values.
+ * @param win_length Window length.
+ * @param dest The destination array.
+ * @param dest_stride The destination stride given a 2D array.
+ * @return The result of the Rolling Median operation as a RollingMedianResult enum.
+ */
+        template<typename T>
+        RollingMedianResult odd_index(const T *src, size_t src_stride,
+                                      size_t count, size_t win_length,
+                                      T *dest, size_t dest_stride) {
+            SkipList::HeadNode<T> sl;
+            const T *tail = src;
+
+            ROLLING_MEDIAN_ERROR_CHECK;
+            for (size_t i = 0; i < count; ++i) {
+                sl.insert(*src);
+                if (i + 1 >= win_length) {
+                    *dest = sl.at(win_length / 2);
+                    dest += dest_stride;
+                    sl.remove(*tail);
+                    tail += src_stride;
+                }
+                src += src_stride;
+            }
+            return ROLLING_MEDIAN_SUCCESS;
+        }
+
+/*
+ */
+/**
+ * Rolling median where the mean of adjacent values is used
+ * when the window size is even length.
+ * This requires T / 2 to be meaningful.
+ * It is up to the caller to ensure that there is enough space in dest for
+ * the results, use dest_size() for this.
+ *
+ * @tparam T Type of the value(s).
+ * @param src Source array of values.
+ * @param src_stride Source stride for 2D arrays.
+ * @param count Number of input values.
+ * @param win_length Window length.
+ * @param dest The destination array.
+ * @param dest_stride The destination stride given a 2D array.
+ * @return The result of the Rolling Median operation as a RollingMedianResult enum.
+ */
+        template<typename T>
+        RollingMedianResult even_odd_index(const T *src, size_t src_stride,
+                                           size_t count, size_t win_length,
+                                           T *dest, size_t dest_stride) {
+            if (win_length % 2 == 1) {
+                return odd_index(src, src_stride,
+                                 count, win_length,
+                                 dest, dest_stride);
+            } else {
+                ROLLING_MEDIAN_ERROR_CHECK;
+                SkipList::HeadNode<T> sl;
+                std::vector<T> buffer;
+
+                const T *tail = src;
+                for (size_t i = 0; i < count; ++i) {
+                    sl.insert(*src);
+                    if (i + 1 >= win_length) {
+                        sl.at((win_length - 1) / 2, 2, buffer);
+                        assert(buffer.size() == 2);
+                        *dest = buffer[0] / 2 + buffer[1] / 2;
+                        dest += dest_stride;
+                        sl.remove(*tail);
+                        tail += src_stride;
+                    }
+                    src += src_stride;
+                }
+            }
+            return ROLLING_MEDIAN_SUCCESS;
+        }
+
+    } // namespace RollingMedian
+} // namespace OrderedStructs
+
+#endif /* defined(__SkipList__RollingMedian__) */

package/src/duckdb/third_party/skiplist/SkipList.cpp

@@ -0,0 +1,40 @@
+//
+//  SkipList.cpp
+//  SkipList
+//
+//  Created by Paul Ross on 19/12/2015.
+//  Copyright (c) 2017 Paul Ross. All rights reserved.
+//
+
+#include <cstdlib>
+#ifdef SKIPLIST_THREAD_SUPPORT
+#include <mutex>
+#endif
+#include <string>
+
+#include "SkipList.h"
+
+namespace duckdb_skiplistlib {
+namespace skip_list {
+
+// This throws an IndexError when the index value >= size.
+// If possible the error will have an informative message.
+#ifdef INCLUDE_METHODS_THAT_USE_STREAMS
+void _throw_exceeds_size(size_t index) {
+    std::ostringstream oss;
+    oss << "Index out of range 0 <= index < " << index;
+    std::string err_msg = oss.str();
+#else
+void _throw_exceeds_size(size_t /* index */) {
+    std::string err_msg = "Index out of range.";
+#endif
+    throw IndexError(err_msg);
+}
+
+#ifdef SKIPLIST_THREAD_SUPPORT
+    std::mutex gSkipListMutex;
+#endif
+
+
+} // namespace SkipList
+} // namespace OrderedStructs