duckdb 0.8.2-dev2044.0 → 0.8.2-dev2090.0

package/src/duckdb/src/common/arrow/arrow_wrapper.cpp

@@ -179,7 +179,8 @@ bool ArrowUtil::TryFetchChunk(QueryResult *result, idx_t chunk_size, ArrowArray
 	auto &current_chunk = result->current_chunk;
 	if (current_chunk.Valid()) {
 		// We start by scanning the non-finished current chunk
-		idx_t cur_consumption = current_chunk.RemainingSize() > chunk_size ? chunk_size : current_chunk.RemainingSize();
+		// Limit the amount we're fetching to the chunk_size
+		idx_t cur_consumption = MinValue<idx_t>(current_chunk.RemainingSize(), chunk_size);
 		count += cur_consumption;
 		appender.Append(*current_chunk.data_chunk, current_chunk.position, current_chunk.position + cur_consumption,
 		                current_chunk.data_chunk->size());

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.8.2-dev2044"
+#define DUCKDB_VERSION "0.8.2-dev2090"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "762396f87b"
+#define DUCKDB_SOURCE_ID "8d8f9f1b79"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/appender/append_data.hpp

@@ -0,0 +1,109 @@
+#pragma once
+
+#include "duckdb/common/types.hpp"
+#include "duckdb/common/types/vector.hpp"
+#include "duckdb/common/arrow/arrow.hpp"
+#include "duckdb/common/arrow/arrow_buffer.hpp"
+#include "duckdb/common/arrow/arrow_options.hpp"
+#include "duckdb/common/array.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Arrow append data
+//===--------------------------------------------------------------------===//
+typedef void (*initialize_t)(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+// append_data: The arrow array we're appending into
+// input: The data we're appending
+// from: The offset into the input we're scanning
+// to: The last index of the input we're scanning
+// input_size: The total size of the 'input' Vector.
+typedef void (*append_vector_t)(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+typedef void (*finalize_t)(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+
+// This struct is used to save state for appending a column
+// afterwards the ownership is passed to the arrow array, as 'private_data'
+// FIXME: we should separate the append state variables from the variables required by the ArrowArray into
+// ArrowAppendState
+struct ArrowAppendData {
+	explicit ArrowAppendData(ArrowOptions &options_p) : options(options_p) {
+	}
+	// the buffers of the arrow vector
+	ArrowBuffer validity;
+	ArrowBuffer main_buffer;
+	ArrowBuffer aux_buffer;
+
+	idx_t row_count = 0;
+	idx_t null_count = 0;
+
+	// function pointers for construction
+	initialize_t initialize = nullptr;
+	append_vector_t append_vector = nullptr;
+	finalize_t finalize = nullptr;
+
+	// child data (if any)
+	vector<unique_ptr<ArrowAppendData>> child_data;
+
+	// the arrow array C API data, only set after Finalize
+	unique_ptr<ArrowArray> array;
+	duckdb::array<const void *, 3> buffers = {{nullptr, nullptr, nullptr}};
+	vector<ArrowArray *> child_pointers;
+
+	ArrowOptions options;
+};
+
+//===--------------------------------------------------------------------===//
+// Append Helper Functions
+//===--------------------------------------------------------------------===//
+static void GetBitPosition(idx_t row_idx, idx_t &current_byte, uint8_t &current_bit) {
+	current_byte = row_idx / 8;
+	current_bit = row_idx % 8;
+}
+
+static void UnsetBit(uint8_t *data, idx_t current_byte, uint8_t current_bit) {
+	data[current_byte] &= ~((uint64_t)1 << current_bit);
+}
+
+static void NextBit(idx_t &current_byte, uint8_t &current_bit) {
+	current_bit++;
+	if (current_bit == 8) {
+		current_byte++;
+		current_bit = 0;
+	}
+}
+
+static void ResizeValidity(ArrowBuffer &buffer, idx_t row_count) {
+	auto byte_count = (row_count + 7) / 8;
+	buffer.resize(byte_count, 0xFF);
+}
+
+static void SetNull(ArrowAppendData &append_data, uint8_t *validity_data, idx_t current_byte, uint8_t current_bit) {
+	UnsetBit(validity_data, current_byte, current_bit);
+	append_data.null_count++;
+}
+
+static void AppendValidity(ArrowAppendData &append_data, UnifiedVectorFormat &format, idx_t from, idx_t to) {
+	// resize the buffer, filling the validity buffer with all valid values
+	idx_t size = to - from;
+	ResizeValidity(append_data.validity, append_data.row_count + size);
+	if (format.validity.AllValid()) {
+		// if all values are valid we don't need to do anything else
+		return;
+	}
+
+	// otherwise we iterate through the validity mask
+	auto validity_data = (uint8_t *)append_data.validity.data();
+	uint8_t current_bit;
+	idx_t current_byte;
+	GetBitPosition(append_data.row_count, current_byte, current_bit);
+	for (idx_t i = from; i < to; i++) {
+		auto source_idx = format.sel->get_index(i);
+		// append the validity mask
+		if (!format.validity.RowIsValid(source_idx)) {
+			SetNull(append_data, validity_data, current_byte, current_bit);
+		}
+		NextBit(current_byte, current_bit);
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/bool_data.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/common/types/vector.hpp"
+
+namespace duckdb {
+
+struct ArrowBoolData {
+public:
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/enum_data.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/common/arrow/appender/scalar_data.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Enums
+//===--------------------------------------------------------------------===//
+template <class TGT>
+struct ArrowEnumData : public ArrowScalarBaseData<TGT> {
+	static idx_t GetLength(string_t input) {
+		return input.GetSize();
+	}
+	static void WriteData(data_ptr_t target, string_t input) {
+		memcpy(target, input.GetData(), input.GetSize());
+	}
+	static void EnumAppendVector(ArrowAppendData &append_data, const Vector &input, idx_t size) {
+		D_ASSERT(input.GetVectorType() == VectorType::FLAT_VECTOR);
+
+		// resize the validity mask and set up the validity buffer for iteration
+		ResizeValidity(append_data.validity, append_data.row_count + size);
+
+		// resize the offset buffer - the offset buffer holds the offsets into the child array
+		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(uint32_t) * (size + 1));
+		auto data = FlatVector::GetData<string_t>(input);
+		auto offset_data = append_data.main_buffer.GetData<uint32_t>();
+		if (append_data.row_count == 0) {
+			// first entry
+			offset_data[0] = 0;
+		}
+		// now append the string data to the auxiliary buffer
+		// the auxiliary buffer's length depends on the string lengths, so we resize as required
+		auto last_offset = offset_data[append_data.row_count];
+		for (idx_t i = 0; i < size; i++) {
+			auto offset_idx = append_data.row_count + i + 1;
+
+			auto string_length = GetLength(data[i]);
+
+			// append the offset data
+			auto current_offset = last_offset + string_length;
+			offset_data[offset_idx] = current_offset;
+
+			// resize the string buffer if required, and write the string data
+			append_data.aux_buffer.resize(current_offset);
+			WriteData(append_data.aux_buffer.data() + last_offset, data[i]);
+
+			last_offset = current_offset;
+		}
+		append_data.row_count += size;
+	}
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
+		result.main_buffer.reserve(capacity * sizeof(TGT));
+		// construct the enum child data
+		auto enum_data = ArrowAppender::InitializeChild(LogicalType::VARCHAR, EnumType::GetSize(type), result.options);
+		EnumAppendVector(*enum_data, EnumType::GetValuesInsertOrder(type), EnumType::GetSize(type));
+		result.child_data.push_back(std::move(enum_data));
+	}
+
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
+		result->n_buffers = 2;
+		result->buffers[1] = append_data.main_buffer.data();
+		// finalize the enum child data, and assign it to the dictionary
+		result->dictionary = ArrowAppender::FinalizeChild(LogicalType::VARCHAR, *append_data.child_data[0]);
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/list.hpp

@@ -0,0 +1,8 @@
+#include "duckdb/common/arrow/appender/bool_data.hpp"
+#include "duckdb/common/arrow/appender/enum_data.hpp"
+#include "duckdb/common/arrow/appender/list_data.hpp"
+#include "duckdb/common/arrow/appender/map_data.hpp"
+#include "duckdb/common/arrow/appender/scalar_data.hpp"
+#include "duckdb/common/arrow/appender/struct_data.hpp"
+#include "duckdb/common/arrow/appender/union_data.hpp"
+#include "duckdb/common/arrow/appender/varchar_data.hpp"

package/src/duckdb/src/include/duckdb/common/arrow/appender/list_data.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+
+namespace duckdb {
+
+struct ArrowListData {
+public:
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+
+public:
+	static void AppendOffsets(ArrowAppendData &append_data, UnifiedVectorFormat &format, idx_t from, idx_t to,
+	                          vector<sel_t> &child_sel);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/map_data.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "duckdb/common/arrow/arrow_appender.hpp"
+#include "duckdb/common/arrow/appender/append_data.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Maps
+//===--------------------------------------------------------------------===//
+struct ArrowMapData {
+public:
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/scalar_data.hpp

@@ -0,0 +1,88 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/function/table/arrow.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Scalar Types
+//===--------------------------------------------------------------------===//
+struct ArrowScalarConverter {
+	template <class TGT, class SRC>
+	static TGT Operation(SRC input) {
+		return input;
+	}
+
+	static bool SkipNulls() {
+		return false;
+	}
+
+	template <class TGT>
+	static void SetNull(TGT &value) {
+	}
+};
+
+struct ArrowIntervalConverter {
+	template <class TGT, class SRC>
+	static TGT Operation(SRC input) {
+		ArrowInterval result;
+		result.months = input.months;
+		result.days = input.days;
+		result.nanoseconds = input.micros * Interval::NANOS_PER_MICRO;
+		return result;
+	}
+
+	static bool SkipNulls() {
+		return true;
+	}
+
+	template <class TGT>
+	static void SetNull(TGT &value) {
+	}
+};
+
+template <class TGT, class SRC = TGT, class OP = ArrowScalarConverter>
+struct ArrowScalarBaseData {
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
+		D_ASSERT(to >= from);
+		idx_t size = to - from;
+		D_ASSERT(size <= input_size);
+		UnifiedVectorFormat format;
+		input.ToUnifiedFormat(input_size, format);
+
+		// append the validity mask
+		AppendValidity(append_data, format, from, to);
+
+		// append the main data
+		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(TGT) * size);
+		auto data = UnifiedVectorFormat::GetData<SRC>(format);
+		auto result_data = append_data.main_buffer.GetData<TGT>();
+
+		for (idx_t i = from; i < to; i++) {
+			auto source_idx = format.sel->get_index(i);
+			auto result_idx = append_data.row_count + i - from;
+
+			if (OP::SkipNulls() && !format.validity.RowIsValid(source_idx)) {
+				OP::template SetNull<TGT>(result_data[result_idx]);
+				continue;
+			}
+			result_data[result_idx] = OP::template Operation<TGT, SRC>(data[source_idx]);
+		}
+		append_data.row_count += size;
+	}
+};
+
+template <class TGT, class SRC = TGT, class OP = ArrowScalarConverter>
+struct ArrowScalarData : public ArrowScalarBaseData<TGT, SRC, OP> {
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
+		result.main_buffer.reserve(capacity * sizeof(TGT));
+	}
+
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
+		result->n_buffers = 2;
+		result->buffers[1] = append_data.main_buffer.data();
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/struct_data.hpp

@@ -0,0 +1,18 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/common/arrow/appender/scalar_data.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Structs
+//===--------------------------------------------------------------------===//
+struct ArrowStructData {
+public:
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/union_data.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Unions
+//===--------------------------------------------------------------------===//
+/**
+ * Based on https://arrow.apache.org/docs/format/Columnar.html#union-layout &
+ * https://arrow.apache.org/docs/format/CDataInterface.html
+ */
+struct ArrowUnionData {
+public:
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity);
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size);
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/appender/varchar_data.hpp

@@ -0,0 +1,105 @@
+#pragma once
+
+#include "duckdb/common/arrow/appender/append_data.hpp"
+#include "duckdb/common/arrow/appender/scalar_data.hpp"
+
+namespace duckdb {
+
+//===--------------------------------------------------------------------===//
+// Varchar
+//===--------------------------------------------------------------------===//
+struct ArrowVarcharConverter {
+	template <class SRC>
+	static idx_t GetLength(SRC input) {
+		return input.GetSize();
+	}
+
+	template <class SRC>
+	static void WriteData(data_ptr_t target, SRC input) {
+		memcpy(target, input.GetData(), input.GetSize());
+	}
+};
+
+struct ArrowUUIDConverter {
+	template <class SRC>
+	static idx_t GetLength(SRC input) {
+		return UUID::STRING_SIZE;
+	}
+
+	template <class SRC>
+	static void WriteData(data_ptr_t target, SRC input) {
+		UUID::ToString(input, char_ptr_cast(target));
+	}
+};
+
+template <class SRC = string_t, class OP = ArrowVarcharConverter, class BUFTYPE = uint64_t>
+struct ArrowVarcharData {
+	static void Initialize(ArrowAppendData &result, const LogicalType &type, idx_t capacity) {
+		result.main_buffer.reserve((capacity + 1) * sizeof(BUFTYPE));
+
+		result.aux_buffer.reserve(capacity);
+	}
+
+	static void Append(ArrowAppendData &append_data, Vector &input, idx_t from, idx_t to, idx_t input_size) {
+		idx_t size = to - from;
+		UnifiedVectorFormat format;
+		input.ToUnifiedFormat(input_size, format);
+
+		// resize the validity mask and set up the validity buffer for iteration
+		ResizeValidity(append_data.validity, append_data.row_count + size);
+		auto validity_data = (uint8_t *)append_data.validity.data();
+
+		// resize the offset buffer - the offset buffer holds the offsets into the child array
+		append_data.main_buffer.resize(append_data.main_buffer.size() + sizeof(BUFTYPE) * (size + 1));
+		auto data = UnifiedVectorFormat::GetData<SRC>(format);
+		auto offset_data = append_data.main_buffer.GetData<BUFTYPE>();
+		if (append_data.row_count == 0) {
+			// first entry
+			offset_data[0] = 0;
+		}
+		// now append the string data to the auxiliary buffer
+		// the auxiliary buffer's length depends on the string lengths, so we resize as required
+		auto last_offset = offset_data[append_data.row_count];
+		idx_t max_offset = append_data.row_count + to - from;
+		if (max_offset > NumericLimits<uint32_t>::Maximum() &&
+		    append_data.options.offset_size == ArrowOffsetSize::REGULAR) {
+			throw InvalidInputException("Arrow Appender: The maximum total string size for regular string buffers is "
+			                            "%u but the offset of %lu exceeds this.",
+			                            NumericLimits<uint32_t>::Maximum(), max_offset);
+		}
+		for (idx_t i = from; i < to; i++) {
+			auto source_idx = format.sel->get_index(i);
+			auto offset_idx = append_data.row_count + i + 1 - from;
+
+			if (!format.validity.RowIsValid(source_idx)) {
+				uint8_t current_bit;
+				idx_t current_byte;
+				GetBitPosition(append_data.row_count + i - from, current_byte, current_bit);
+				SetNull(append_data, validity_data, current_byte, current_bit);
+				offset_data[offset_idx] = last_offset;
+				continue;
+			}
+
+			auto string_length = OP::GetLength(data[source_idx]);
+
+			// append the offset data
+			auto current_offset = last_offset + string_length;
+			offset_data[offset_idx] = current_offset;
+
+			// resize the string buffer if required, and write the string data
+			append_data.aux_buffer.resize(current_offset);
+			OP::WriteData(append_data.aux_buffer.data() + last_offset, data[source_idx]);
+
+			last_offset = current_offset;
+		}
+		append_data.row_count += size;
+	}
+
+	static void Finalize(ArrowAppendData &append_data, const LogicalType &type, ArrowArray *result) {
+		result->n_buffers = 3;
+		result->buffers[1] = append_data.main_buffer.data();
+		result->buffers[2] = append_data.aux_buffer.data();
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/common/arrow/arrow_appender.hpp

@@ -27,6 +27,11 @@ public:
 	//! Returns the underlying arrow array
 	DUCKDB_API ArrowArray Finalize();
 
+public:
+	static void ReleaseArray(ArrowArray *array);
+	static ArrowArray *FinalizeChild(const LogicalType &type, ArrowAppendData &append_data);
+	static unique_ptr<ArrowAppendData> InitializeChild(const LogicalType &type, idx_t capacity, ArrowOptions &options);
+
 private:
 	//! The types of the chunks that will be appended in
 	vector<LogicalType> types;

package/src/duckdb/src/include/duckdb/common/assert.hpp

@@ -10,7 +10,7 @@
 
 #pragma once
 
-#if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT)
+#if (defined(DUCKDB_USE_STANDARD_ASSERT) || !defined(DEBUG)) && !defined(DUCKDB_FORCE_ASSERT) && !defined(__MVS__)
 
 #include <assert.h>
 #define D_ASSERT assert

package/src/duckdb/src/include/duckdb/core_functions/scalar/math_functions.hpp

@@ -101,9 +101,9 @@ struct AtanFun {
 
 struct Atan2Fun {
 	static constexpr const char *Name = "atan2";
-	static constexpr const char *Parameters = "x,y";
-	static constexpr const char *Description = "computes the arctangent (x, y)";
-	static constexpr const char *Example = "atan2(0.5, 0.5)";
+	static constexpr const char *Parameters = "y,x";
+	static constexpr const char *Description = "computes the arctangent (y, x)";
+	static constexpr const char *Example = "atan2(1.0, 0.0)";
 
 	static ScalarFunction GetFunction();
 };

package/src/duckdb/src/parallel/executor.cpp

@@ -107,7 +107,7 @@ void Executor::SchedulePipeline(const shared_ptr<MetaPipeline> &meta_pipeline, S
 			                                  group_stack.pipeline_finish_event, base_stack.pipeline_complete_event);
 
 			// dependencies: base_finish -> pipeline_event -> group_finish
-			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_event);
+			pipeline_stack.pipeline_event.AddDependency(base_stack.pipeline_finish_event);
 			group_stack.pipeline_finish_event.AddDependency(pipeline_stack.pipeline_event);
 
 			// add pipeline stack to event map

package/src/duckdb/src/planner/expression/bound_window_expression.cpp

@@ -61,10 +61,7 @@ bool BoundWindowExpression::KeysAreCompatible(const BoundWindowExpression &other
 		return false;
 	}
 	for (idx_t i = 0; i < orders.size(); i++) {
-		if (orders[i].type != other.orders[i].type) {
-			return false;
-		}
-		if (!Expression::Equals(*orders[i].expression, *other.orders[i].expression)) {
+		if (!orders[i].Equals(other.orders[i])) {
 			return false;
 		}
 	}

package/src/duckdb/third_party/concurrentqueue/lightweightsemaphore.h

@@ -29,6 +29,7 @@ extern "C" {
 #include <chrono>
 #elif defined(__MVS__)
 #include <zos-semaphore.h>
+#include <chrono>
 #endif
 
 namespace duckdb_moodycamel
@@ -162,9 +163,9 @@ public:
 		}
 	}
 };
-#elif defined(__unix__)
+#elif defined(__unix__) || defined(__MVS__)
 //---------------------------------------------------------
-// Semaphore (POSIX, Linux)
+// Semaphore (POSIX, Linux, zOS aka MVS)
 //---------------------------------------------------------
 class Semaphore
 {
@@ -256,80 +257,6 @@ public:
 		}
 	}
 };
-#elif defined(__MVS__)
-//---------------------------------------------------------
-// Semaphore (MVS aka z/OS)
-//---------------------------------------------------------
-class Semaphore
-{
-private:
-	sem_t m_sema;
-
-	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
-
-public:
-	Semaphore(int initialCount = 0)
-	{
-		assert(initialCount >= 0);
-		int rc = sem_init(&m_sema, 0, initialCount);
-		assert(rc == 0);
-		(void)rc;
-	}
-
-	~Semaphore()
-	{
-		sem_destroy(&m_sema);
-	}
-
-	bool wait()
-	{
-		// http://stackoverflow.com/questions/2013181/gdb-causes-sem-wait-to-fail-with-eintr-error
-		int rc;
-		do {
-			rc = sem_wait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool try_wait()
-	{
-		int rc;
-		do {
-			rc = sem_trywait(&m_sema);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	bool timed_wait(std::uint64_t usecs)
-	{
-		struct timespec ts;
-		const int usecs_in_1_sec = 1000000;
-		const int nsecs_in_1_sec = 1000000000;
-
-		ts.tv_sec = usecs / usecs_in_1_sec;
-		ts.tv_nsec = (usecs % usecs_in_1_sec) * 1000;
-
-		int rc;
-		do {
-			rc = sem_timedwait(&m_sema, &ts);
-		} while (rc == -1 && errno == EINTR);
-		return rc == 0;
-	}
-
-	void signal()
-	{
-		while (sem_post(&m_sema) == -1);
-	}
-
-	void signal(int count)
-	{
-		while (count-- > 0)
-		{
-			while (sem_post(&m_sema) == -1);
-		}
-	}
-};
 #else
 #error Unsupported platform! (No semaphore wrapper available)
 #endif