duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

package/src/duckdb/src/optimizer/join_order/estimated_properties.cpp

@@ -1,36 +0,0 @@
-
-#include "duckdb/optimizer/join_order/estimated_properties.hpp"
-
-namespace duckdb {
-
-template <>
-double EstimatedProperties::GetCardinality() const {
-	return cardinality;
-}
-
-template <>
-idx_t EstimatedProperties::GetCardinality() const {
-	auto max_idx_t = NumericLimits<idx_t>::Maximum() - 10000;
-	return MinValue<double>(cardinality, max_idx_t);
-}
-
-template <>
-double EstimatedProperties::GetCost() const {
-	return cost;
-}
-
-template <>
-idx_t EstimatedProperties::GetCost() const {
-	auto max_idx_t = NumericLimits<idx_t>::Maximum() - 10000;
-	return MinValue<double>(cost, max_idx_t);
-}
-
-void EstimatedProperties::SetCardinality(double new_card) {
-	cardinality = new_card;
-}
-
-void EstimatedProperties::SetCost(double new_cost) {
-	cost = new_cost;
-}
-
-} // namespace duckdb

package/src/duckdb/src/parser/parsed_data/comment_on_info.cpp

@@ -1,19 +0,0 @@
-#include "duckdb/parser/parsed_data/comment_on_info.hpp"
-
-namespace duckdb {
-
-CommentOnInfo::CommentOnInfo()
-    : ParseInfo(TYPE), catalog(INVALID_CATALOG), schema(INVALID_SCHEMA), name(""), comment(Value()) {
-}
-
-unique_ptr<CommentOnInfo> CommentOnInfo::Copy() const {
-	auto result = make_uniq<CommentOnInfo>();
-	result->type = type;
-	result->catalog = catalog;
-	result->schema = schema;
-	result->name = name;
-	result->comment = comment;
-	return result;
-}
-
-} // namespace duckdb

package/src/duckdb/src/parser/statement/show_statement.cpp

@@ -1,15 +0,0 @@
-#include "duckdb/parser/statement/show_statement.hpp"
-
-namespace duckdb {
-
-ShowStatement::ShowStatement() : SQLStatement(StatementType::SHOW_STATEMENT), info(make_uniq<ShowSelectInfo>()) {
-}
-
-ShowStatement::ShowStatement(const ShowStatement &other) : SQLStatement(other), info(other.info->Copy()) {
-}
-
-unique_ptr<SQLStatement> ShowStatement::Copy() const {
-	return unique_ptr<ShowStatement>(new ShowStatement(*this));
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/binder/statement/bind_show.cpp

@@ -1,30 +0,0 @@
-#include "duckdb/planner/binder.hpp"
-#include "duckdb/parser/statement/show_statement.hpp"
-#include "duckdb/planner/operator/logical_show.hpp"
-
-namespace duckdb {
-
-BoundStatement Binder::Bind(ShowStatement &stmt) {
-	BoundStatement result;
-
-	if (stmt.info->is_summary) {
-		return BindSummarize(stmt);
-	}
-	auto plan = Bind(*stmt.info->query);
-	stmt.info->types = plan.types;
-	stmt.info->aliases = plan.names;
-
-	auto show = make_uniq<LogicalShow>(std::move(plan.plan));
-	show->types_select = plan.types;
-	show->aliases = plan.names;
-
-	result.plan = std::move(show);
-
-	result.names = {"column_name", "column_type", "null", "key", "default", "extra"};
-	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR,
-	                LogicalType::VARCHAR, LogicalType::VARCHAR, LogicalType::VARCHAR};
-	properties.return_type = StatementReturnType::QUERY_RESULT;
-	return result;
-}
-
-} // namespace duckdb

package/src/duckdb/src/planner/operator/logical_limit_percent.cpp

@@ -1,14 +0,0 @@
-#include "duckdb/planner/operator/logical_limit_percent.hpp"
-#include <cmath>
-
-namespace duckdb {
-
-idx_t LogicalLimitPercent::EstimateCardinality(ClientContext &context) {
-	auto child_cardinality = LogicalOperator::EstimateCardinality(context);
-	if ((limit_percent < 0 || limit_percent > 100) || std::isnan(limit_percent)) {
-		return child_cardinality;
-	}
-	return idx_t(child_cardinality * (limit_percent / 100.0));
-}
-
-} // namespace duckdb

package/src/duckdb/src/storage/statistics/numeric_stats_union.cpp

@@ -1,70 +0,0 @@
-#include "duckdb/storage/statistics/numeric_stats_union.hpp"
-
-namespace duckdb {
-
-template <>
-bool &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.boolean;
-}
-
-template <>
-int8_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.tinyint;
-}
-
-template <>
-int16_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.smallint;
-}
-
-template <>
-int32_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.integer;
-}
-
-template <>
-int64_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.bigint;
-}
-
-template <>
-hugeint_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.hugeint;
-}
-
-template <>
-uhugeint_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.uhugeint;
-}
-
-template <>
-uint8_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.utinyint;
-}
-
-template <>
-uint16_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.usmallint;
-}
-
-template <>
-uint32_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.uinteger;
-}
-
-template <>
-uint64_t &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.ubigint;
-}
-
-template <>
-float &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.float_;
-}
-
-template <>
-double &NumericValueUnion::GetReferenceUnsafe() {
-	return value_.double_;
-}
-
-} // namespace duckdb

package/src/duckdb/third_party/fsst/fsst_avx512.cpp

@@ -1,140 +0,0 @@
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-//
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-//
-// 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.
-//
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
-#include "libfsst.hpp"
-
-#if DUCKDB_FSST_ENABLE_INTRINSINCS && (defined(__x86_64__) || defined(_M_X64))
-#include <immintrin.h>
-
-#ifdef _WIN32
-bool duckdb_fsst_hasAVX512() {
-	int info[4];
-	__cpuidex(info, 0x00000007, 0);
-	return (info[1]>>16)&1;
-}
-#else
-#include <cpuid.h>
-bool duckdb_fsst_hasAVX512() {
-	int info[4];
-	__cpuid_count(0x00000007, 0, info[0], info[1], info[2], info[3]);
-	return (info[1]>>16)&1;
-}
-#endif
-#else
-bool duckdb_fsst_hasAVX512() { return false; }
-#endif
-
-// BULK COMPRESSION OF STRINGS
-//
-// In one call of this function, we can compress 512 strings, each of maximum length 511 bytes.
-// strings can be shorter than 511 bytes, no problem, but if they are longer we need to cut them up.
-//
-// In each iteration of the while loop, we find one code in each of the unroll*8 strings, i.e. (8,16,24 or 32) for resp. unroll=1,2,3,4
-// unroll3 performs best on my hardware
-//
-// In the worst case, each final encoded string occupies 512KB bytes (512*1024; with 1024=512xexception, exception = 2 bytes).
-// - hence codeBase is a buffer of 512KB (needs 19 bits jobs), symbolBase of 256KB (needs 18 bits jobs).
-//
-// 'jobX' controls the encoding of each string and is therefore a u64 with format [out:19][pos:9][end:18][cur:18] (low-to-high bits)
-// The field 'pos' tells which string we are processing (0..511). We need this info as strings will complete compressing out-of-order.
-//
-// Strings will have different lengths, and when a string is finished, we reload from the buffer of 512 input strings.
-// This continues until we have less than (8,16,24 or 32; depending on unroll) strings left to process.
-// - so 'processed' is the amount of strings we started processing and it is between [480,512].
-// Note that when we quit, there will still be some (<32) strings that we started to process but which are unfinished.
-// - so 'unfinished' is that amount. These unfinished strings will be encoded further using the scalar method.
-//
-// Apart from the coded strings, we return in a output[] array of size 'processed' the job values of the 'finished' strings.
-// In the following 'unfinished' slots (processed=finished+unfinished) we output the 'job' values of the unfinished strings.
-//
-// For the finished strings, we need [out:19] to see the compressed size and [pos:9] to see which string we refer to.
-// For the unfinished strings, we need all fields of 'job' to continue the compression with scalar code (see SIMD code in compressBatch).
-//
-// THIS IS A SEPARATE CODE FILE NOT BECAUSE OF MY LOVE FOR MODULARIZED CODE BUT BECAUSE IT ALLOWS TO COMPILE IT WITH DIFFERENT FLAGS
-// in particular, unrolling is crucial for gather/scatter performance, but requires registers. the #define all_* expressions however,
-// will be detected to be constants by g++ -O2 and will be precomputed and placed into AVX512 registers - spoiling 9 of them.
-// This reduces the effectiveness of unrolling, hence -O2 makes the loop perform worse than -O1 which skips this optimization.
-// Assembly inspection confirmed that 3-way unroll with -O1 avoids needless load/stores.
-
-size_t duckdb_fsst_compressAVX512(SymbolTable &symbolTable, u8* codeBase, u8* symbolBase, SIMDjob *input, SIMDjob *output, size_t n, size_t unroll) {
-	size_t processed = 0;
-	// define some constants (all_x means that all 8 lanes contain 64-bits value X)
-#if defined(__AVX512F__) and DUCKDB_FSST_ENABLE_INTRINSINCS
-	//__m512i all_suffixLim= _mm512_broadcastq_epi64(_mm_set1_epi64((__m64) (u64) symbolTable->suffixLim)); -- for variants b,c
-	__m512i all_MASK     = _mm512_broadcastq_epi64(_mm_set1_epi64((__m64) (u64) -1));
-	__m512i all_PRIME    = _mm512_broadcastq_epi64(_mm_set1_epi64((__m64) (u64) FSST_HASH_PRIME));
-	__m512i all_ICL_FREE = _mm512_broadcastq_epi64(_mm_set1_epi64((__m64) (u64) FSST_ICL_FREE));
-#define    all_HASH       _mm512_srli_epi64(all_MASK, 64-FSST_HASH_LOG2SIZE)
-#define    all_ONE        _mm512_srli_epi64(all_MASK, 63)
-#define    all_M19        _mm512_srli_epi64(all_MASK, 45)
-#define    all_M18        _mm512_srli_epi64(all_MASK, 46)
-#define    all_M28        _mm512_srli_epi64(all_MASK, 36)
-#define    all_FFFFFF     _mm512_srli_epi64(all_MASK, 40)
-#define    all_FFFF       _mm512_srli_epi64(all_MASK, 48)
-#define    all_FF         _mm512_srli_epi64(all_MASK, 56)
-
-	SIMDjob *inputEnd = input+n;
-	assert(n >= unroll*8 && n <= 512); // should be close to 512
-	__m512i job1, job2, job3, job4; // will contain current jobs, for each unroll 1,2,3,4
-	__mmask8 loadmask1 = 255, loadmask2 = 255*(unroll>1), loadmask3 = 255*(unroll>2), loadmask4 = 255*(unroll>3); // 2b loaded new strings bitmask per unroll
-	u32 delta1 = 8, delta2 = 8*(unroll>1), delta3 = 8*(unroll>2), delta4 = 8*(unroll>3); // #new loads this SIMD iteration per unroll
-
-	if (unroll >= 4) {
-		while (input+delta1+delta2+delta3+delta4 < inputEnd) {
-#include "fsst_avx512_unroll4.inc"
-		}
-	} else if (unroll == 3) {
-		while (input+delta1+delta2+delta3 < inputEnd) {
-#include "fsst_avx512_unroll3.inc"
-		}
-	} else if (unroll == 2) {
-		while (input+delta1+delta2 < inputEnd) {
-#include "fsst_avx512_unroll2.inc"
-		}
-	} else {
-		while (input+delta1 < inputEnd) {
-#include "fsst_avx512_unroll1.inc"
-		}
-	}
-
-	// flush the job states of the unfinished strings at the end of output[]
-	processed = n - (inputEnd - input);
-	u32 unfinished = 0;
-	if (unroll > 1) {
-		if (unroll > 2) {
-			if (unroll > 3) {
-				_mm512_mask_compressstoreu_epi64(output+unfinished, loadmask4=~loadmask4, job4);
-				unfinished += _mm_popcnt_u32((int) loadmask4);
-			}
-			_mm512_mask_compressstoreu_epi64(output+unfinished, loadmask3=~loadmask3, job3);
-			unfinished += _mm_popcnt_u32((int) loadmask3);
-		}
-		_mm512_mask_compressstoreu_epi64(output+unfinished, loadmask2=~loadmask2, job2);
-		unfinished += _mm_popcnt_u32((int) loadmask2);
-	}
-	_mm512_mask_compressstoreu_epi64(output+unfinished, loadmask1=~loadmask1, job1);
-#else
-	(void) symbolTable;
-	(void) codeBase;
-	(void) symbolBase;
-	(void) input;
-	(void) output;
-	(void) n;
-	(void) unroll;
-#endif
-	return processed;
-}

package/src/duckdb/third_party/fsst/fsst_avx512.inc

@@ -1,57 +0,0 @@
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-//
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-//
-// 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.
-//
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
-//
-                        // load new jobs in the empty lanes (initially, all lanes are empty, so loadmaskX=11111111, deltaX=8).
-            jobX      = _mm512_mask_expandloadu_epi64(jobX, loadmaskX, input); input += deltaX; 
-                        // load the next 8 input string bytes (uncompressed data, aka 'symbols').
-   __m512i  wordX     = _mm512_i64gather_epi64(_mm512_srli_epi64(jobX, 46), symbolBase, 1); 
-                        // load 16-bits codes from the 2-byte-prefix keyed lookup table. It also store 1-byte codes in all free slots.
-                        // codeX: Lowest 8 bits contain the code. Eleventh bit is whether it is an escaped code. Next 4 bits is length (2 or 1).
-   __m512i  codeX     = _mm512_i64gather_epi64(_mm512_and_epi64(wordX, all_FFFF), symbolTable.shortCodes, sizeof(u16));
-                        // get the first three bytes of the string. 
-   __m512i  posX      = _mm512_mullo_epi64(_mm512_and_epi64(wordX, all_FFFFFF), all_PRIME);
-                        // hash them into a random number: posX = posX*PRIME; posX ^= posX>>SHIFT
-            posX      = _mm512_slli_epi64(_mm512_and_epi64(_mm512_xor_epi64(posX,_mm512_srli_epi64(posX,FSST_SHIFT)), all_HASH), 4);
-                        // lookup in the 3-byte-prefix keyed hash table
-   __m512i  iclX      = _mm512_i64gather_epi64(posX, (((char*) symbolTable.hashTab) + 8), 1);
-                        // speculatively store the first input byte into the second position of the writeX register (in case it turns out to be an escaped byte).
-   __m512i  writeX    = _mm512_slli_epi64(_mm512_and_epi64(wordX, all_FF), 8);
-                        // lookup just like the iclX above, but loads the next 8 bytes. This fetches the actual string bytes in the hash table.
-   __m512i  symbX     = _mm512_i64gather_epi64(posX, (((char*) symbolTable.hashTab) + 0), 1);
-                        // generate the FF..FF mask with an FF for each byte of the symbol (we need to AND the input with this to correctly check equality).
-            posX      = _mm512_srlv_epi64(all_MASK, _mm512_and_epi64(iclX, all_FF));
-                        // check symbol < |str| as well as whether it is an occupied slot (cmplt checks both conditions at once) and check string equality (cmpeq).
-   __mmask8 matchX    = _mm512_cmpeq_epi64_mask(symbX, _mm512_and_epi64(wordX, posX)) & _mm512_cmplt_epi64_mask(iclX, all_ICL_FREE);
-                        // for the hits, overwrite the codes with what comes from the hash table (codes for symbols of length >=3). The rest stays with what shortCodes gave.
-            codeX     = _mm512_mask_mov_epi64(codeX, matchX, _mm512_srli_epi64(iclX, 16));
-                        // write out the code byte as the first output byte. Notice that this byte may also be the escape code 255 (for escapes) coming from shortCodes.
-            writeX    = _mm512_or_epi64(writeX, _mm512_and_epi64(codeX, all_FF));
-                        // zip the irrelevant 6 bytes (just stay with the 2 relevant bytes containing the 16-bits code)
-            codeX     = _mm512_and_epi64(codeX, all_FFFF);
-                        // write out the compressed data. It writes 8 bytes, but only 1 byte is relevant :-(or 2 bytes are, in case of an escape code)
-                        _mm512_i64scatter_epi64(codeBase, _mm512_and_epi64(jobX, all_M19), writeX, 1);
-                        // increase the jobX.cur field in the job with the symbol length (for this, shift away 12 bits from the code) 
-            jobX      = _mm512_add_epi64(jobX, _mm512_slli_epi64(_mm512_srli_epi64(codeX, FSST_LEN_BITS), 46));
-                        // increase the jobX.out' field with one, or two in case of an escape code (add 1 plus the escape bit, i.e the 8th)
-            jobX      = _mm512_add_epi64(jobX, _mm512_add_epi64(all_ONE, _mm512_and_epi64(_mm512_srli_epi64(codeX, 8), all_ONE)));
-                        // test which lanes are done now (jobX.cur==jobX.end), cur starts at bit 46, end starts at bit 28 (the highest 2x18 bits in the jobX register)
-            loadmaskX = _mm512_cmpeq_epi64_mask(_mm512_srli_epi64(jobX, 46), _mm512_and_epi64(_mm512_srli_epi64(jobX, 28), all_M18));
-                        // calculate the amount of lanes in jobX that are done
-            deltaX    = _mm_popcnt_u32((int) loadmaskX); 
-                        // write out the job state for the lanes that are done (we need the final 'jobX.out' value to compute the compressed string length)
-                        _mm512_mask_compressstoreu_epi64(output, loadmaskX, jobX); output += deltaX;

package/src/duckdb/third_party/fsst/fsst_avx512_unroll1.inc

@@ -1,57 +0,0 @@
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-//
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-//
-// 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, E1PRESS 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.
-//
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
-//
-                        // load new jobs in the empty lanes (initially, all lanes are empty, so loadmask1=11111111, delta1=8).
-            job1      = _mm512_mask_expandloadu_epi64(job1, loadmask1, input); input += delta1; 
-                        // load the next 8 input string bytes (uncompressed data, aka 'symbols').
-   __m512i  word1     = _mm512_i64gather_epi64(_mm512_srli_epi64(job1, 46), symbolBase, 1); 
-                        // load 16-bits codes from the 2-byte-prefix keyed lookup table. It also store 1-byte codes in all free slots.
-                        // code1: Lowest 8 bits contain the code. Eleventh bit is whether it is an escaped code. Next 4 bits is length (2 or 1).
-   __m512i  code1     = _mm512_i64gather_epi64(_mm512_and_epi64(word1, all_FFFF), symbolTable.shortCodes, sizeof(u16));
-                        // get the first three bytes of the string. 
-   __m512i  pos1      = _mm512_mullo_epi64(_mm512_and_epi64(word1, all_FFFFFF), all_PRIME);
-                        // hash them into a random number: pos1 = pos1*PRIME; pos1 ^= pos1>>SHIFT
-            pos1      = _mm512_slli_epi64(_mm512_and_epi64(_mm512_xor_epi64(pos1,_mm512_srli_epi64(pos1,FSST_SHIFT)), all_HASH), 4);
-                        // lookup in the 3-byte-prefix keyed hash table
-   __m512i  icl1      = _mm512_i64gather_epi64(pos1, (((char*) symbolTable.hashTab) + 8), 1);
-                        // speculatively store the first input byte into the second position of the write1 register (in case it turns out to be an escaped byte).
-   __m512i  write1    = _mm512_slli_epi64(_mm512_and_epi64(word1, all_FF), 8);
-                        // lookup just like the icl1 above, but loads the next 8 bytes. This fetches the actual string bytes in the hash table.
-   __m512i  symb1     = _mm512_i64gather_epi64(pos1, (((char*) symbolTable.hashTab) + 0), 1);
-                        // generate the FF..FF mask with an FF for each byte of the symbol (we need to AND the input with this to correctly check equality).
-            pos1      = _mm512_srlv_epi64(all_MASK, _mm512_and_epi64(icl1, all_FF));
-                        // check symbol < |str| as well as whether it is an occupied slot (cmplt checks both conditions at once) and check string equality (cmpeq).
-   __mmask8 match1    = _mm512_cmpeq_epi64_mask(symb1, _mm512_and_epi64(word1, pos1)) & _mm512_cmplt_epi64_mask(icl1, all_ICL_FREE);
-                        // for the hits, overwrite the codes with what comes from the hash table (codes for symbols of length >=3). The rest stays with what shortCodes gave.
-            code1     = _mm512_mask_mov_epi64(code1, match1, _mm512_srli_epi64(icl1, 16));
-                        // write out the code byte as the first output byte. Notice that this byte may also be the escape code 255 (for escapes) coming from shortCodes.
-            write1    = _mm512_or_epi64(write1, _mm512_and_epi64(code1, all_FF));
-                        // zip the irrelevant 6 bytes (just stay with the 2 relevant bytes containing the 16-bits code)
-            code1     = _mm512_and_epi64(code1, all_FFFF);
-                        // write out the compressed data. It writes 8 bytes, but only 1 byte is relevant :-(or 2 bytes are, in case of an escape code)
-                        _mm512_i64scatter_epi64(codeBase, _mm512_and_epi64(job1, all_M19), write1, 1);
-                        // increase the job1.cur field in the job with the symbol length (for this, shift away 12 bits from the code) 
-            job1      = _mm512_add_epi64(job1, _mm512_slli_epi64(_mm512_srli_epi64(code1, FSST_LEN_BITS), 46));
-                        // increase the job1.out' field with one, or two in case of an escape code (add 1 plus the escape bit, i.e the 8th)
-            job1      = _mm512_add_epi64(job1, _mm512_add_epi64(all_ONE, _mm512_and_epi64(_mm512_srli_epi64(code1, 8), all_ONE)));
-                        // test which lanes are done now (job1.cur==job1.end), cur starts at bit 46, end starts at bit 28 (the highest 2x18 bits in the job1 register)
-            loadmask1 = _mm512_cmpeq_epi64_mask(_mm512_srli_epi64(job1, 46), _mm512_and_epi64(_mm512_srli_epi64(job1, 28), all_M18));
-                        // calculate the amount of lanes in job1 that are done
-            delta1    = _mm_popcnt_u32((int) loadmask1); 
-                        // write out the job state for the lanes that are done (we need the final 'job1.out' value to compute the compressed string length)
-                        _mm512_mask_compressstoreu_epi64(output, loadmask1, job1); output += delta1;

package/src/duckdb/third_party/fsst/fsst_avx512_unroll2.inc

@@ -1,114 +0,0 @@
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-// this software is distributed under the MIT License (http://www.opensource.org/licenses/MIT):
-//
-//
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-// Copyright 2018-2020, CWI, TU Munich, FSU Jena
-//
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files
-// 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,
-// (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
-// 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:
-// 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 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, E1PRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, E2PRESS 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
-// 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
-// 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.
-// IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-//
-//
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
-// You can contact the authors via the FSST source repository : https://github.com/cwida/fsst
-//
-//
-                        // load new jobs in the empty lanes (initially, all lanes are empty, so loadmask1=11111111, delta1=8).
-                        // load new jobs in the empty lanes (initially, all lanes are empty, so loadmask2=11111111, delta2=8).
-            job1      = _mm512_mask_expandloadu_epi64(job1, loadmask1, input); input += delta1; 
-            job2      = _mm512_mask_expandloadu_epi64(job2, loadmask2, input); input += delta2; 
-                        // load the next 8 input string bytes (uncompressed data, aka 'symbols').
-                        // load the next 8 input string bytes (uncompressed data, aka 'symbols').
-   __m512i  word1     = _mm512_i64gather_epi64(_mm512_srli_epi64(job1, 46), symbolBase, 1); 
-   __m512i  word2     = _mm512_i64gather_epi64(_mm512_srli_epi64(job2, 46), symbolBase, 1); 
-                        // load 16-bits codes from the 2-byte-prefix keyed lookup table. It also store 1-byte codes in all free slots.
-                        // load 16-bits codes from the 2-byte-prefix keyed lookup table. It also store 1-byte codes in all free slots.
-                        // code1: Lowest 8 bits contain the code. Eleventh bit is whether it is an escaped code. Next 4 bits is length (2 or 1).
-                        // code2: Lowest 8 bits contain the code. Eleventh bit is whether it is an escaped code. Next 4 bits is length (2 or 1).
-   __m512i  code1     = _mm512_i64gather_epi64(_mm512_and_epi64(word1, all_FFFF), symbolTable.shortCodes, sizeof(u16));
-   __m512i  code2     = _mm512_i64gather_epi64(_mm512_and_epi64(word2, all_FFFF), symbolTable.shortCodes, sizeof(u16));
-                        // get the first three bytes of the string. 
-                        // get the first three bytes of the string. 
-   __m512i  pos1      = _mm512_mullo_epi64(_mm512_and_epi64(word1, all_FFFFFF), all_PRIME);
-   __m512i  pos2      = _mm512_mullo_epi64(_mm512_and_epi64(word2, all_FFFFFF), all_PRIME);
-                        // hash them into a random number: pos1 = pos1*PRIME; pos1 ^= pos1>>SHIFT
-                        // hash them into a random number: pos2 = pos2*PRIME; pos2 ^= pos2>>SHIFT
-            pos1      = _mm512_slli_epi64(_mm512_and_epi64(_mm512_xor_epi64(pos1,_mm512_srli_epi64(pos1,FSST_SHIFT)), all_HASH), 4);
-            pos2      = _mm512_slli_epi64(_mm512_and_epi64(_mm512_xor_epi64(pos2,_mm512_srli_epi64(pos2,FSST_SHIFT)), all_HASH), 4);
-                        // lookup in the 3-byte-prefix keyed hash table
-                        // lookup in the 3-byte-prefix keyed hash table
-   __m512i  icl1      = _mm512_i64gather_epi64(pos1, (((char*) symbolTable.hashTab) + 8), 1);
-   __m512i  icl2      = _mm512_i64gather_epi64(pos2, (((char*) symbolTable.hashTab) + 8), 1);
-                        // speculatively store the first input byte into the second position of the write1 register (in case it turns out to be an escaped byte).
-                        // speculatively store the first input byte into the second position of the write2 register (in case it turns out to be an escaped byte).
-   __m512i  write1    = _mm512_slli_epi64(_mm512_and_epi64(word1, all_FF), 8);
-   __m512i  write2    = _mm512_slli_epi64(_mm512_and_epi64(word2, all_FF), 8);
-                        // lookup just like the icl1 above, but loads the next 8 bytes. This fetches the actual string bytes in the hash table.
-                        // lookup just like the icl2 above, but loads the next 8 bytes. This fetches the actual string bytes in the hash table.
-   __m512i  symb1     = _mm512_i64gather_epi64(pos1, (((char*) symbolTable.hashTab) + 0), 1);
-   __m512i  symb2     = _mm512_i64gather_epi64(pos2, (((char*) symbolTable.hashTab) + 0), 1);
-                        // generate the FF..FF mask with an FF for each byte of the symbol (we need to AND the input with this to correctly check equality).
-                        // generate the FF..FF mask with an FF for each byte of the symbol (we need to AND the input with this to correctly check equality).
-            pos1      = _mm512_srlv_epi64(all_MASK, _mm512_and_epi64(icl1, all_FF));
-            pos2      = _mm512_srlv_epi64(all_MASK, _mm512_and_epi64(icl2, all_FF));
-                        // check symbol < |str| as well as whether it is an occupied slot (cmplt checks both conditions at once) and check string equality (cmpeq).
-                        // check symbol < |str| as well as whether it is an occupied slot (cmplt checks both conditions at once) and check string equality (cmpeq).
-   __mmask8 match1    = _mm512_cmpeq_epi64_mask(symb1, _mm512_and_epi64(word1, pos1)) & _mm512_cmplt_epi64_mask(icl1, all_ICL_FREE);
-   __mmask8 match2    = _mm512_cmpeq_epi64_mask(symb2, _mm512_and_epi64(word2, pos2)) & _mm512_cmplt_epi64_mask(icl2, all_ICL_FREE);
-                        // for the hits, overwrite the codes with what comes from the hash table (codes for symbols of length >=3). The rest stays with what shortCodes gave.
-                        // for the hits, overwrite the codes with what comes from the hash table (codes for symbols of length >=3). The rest stays with what shortCodes gave.
-            code1     = _mm512_mask_mov_epi64(code1, match1, _mm512_srli_epi64(icl1, 16));
-            code2     = _mm512_mask_mov_epi64(code2, match2, _mm512_srli_epi64(icl2, 16));
-                        // write out the code byte as the first output byte. Notice that this byte may also be the escape code 255 (for escapes) coming from shortCodes.
-                        // write out the code byte as the first output byte. Notice that this byte may also be the escape code 255 (for escapes) coming from shortCodes.
-            write1    = _mm512_or_epi64(write1, _mm512_and_epi64(code1, all_FF));
-            write2    = _mm512_or_epi64(write2, _mm512_and_epi64(code2, all_FF));
-                        // zip the irrelevant 6 bytes (just stay with the 2 relevant bytes containing the 16-bits code)
-                        // zip the irrelevant 6 bytes (just stay with the 2 relevant bytes containing the 16-bits code)
-            code1     = _mm512_and_epi64(code1, all_FFFF);
-            code2     = _mm512_and_epi64(code2, all_FFFF);
-                        // write out the compressed data. It writes 8 bytes, but only 1 byte is relevant :-(or 2 bytes are, in case of an escape code)
-                        // write out the compressed data. It writes 8 bytes, but only 1 byte is relevant :-(or 2 bytes are, in case of an escape code)
-                        _mm512_i64scatter_epi64(codeBase, _mm512_and_epi64(job1, all_M19), write1, 1);
-                        _mm512_i64scatter_epi64(codeBase, _mm512_and_epi64(job2, all_M19), write2, 1);
-                        // increase the job1.cur field in the job with the symbol length (for this, shift away 12 bits from the code) 
-                        // increase the job2.cur field in the job with the symbol length (for this, shift away 12 bits from the code) 
-            job1      = _mm512_add_epi64(job1, _mm512_slli_epi64(_mm512_srli_epi64(code1, FSST_LEN_BITS), 46));
-            job2      = _mm512_add_epi64(job2, _mm512_slli_epi64(_mm512_srli_epi64(code2, FSST_LEN_BITS), 46));
-                        // increase the job1.out' field with one, or two in case of an escape code (add 1 plus the escape bit, i.e the 8th)
-                        // increase the job2.out' field with one, or two in case of an escape code (add 1 plus the escape bit, i.e the 8th)
-            job1      = _mm512_add_epi64(job1, _mm512_add_epi64(all_ONE, _mm512_and_epi64(_mm512_srli_epi64(code1, 8), all_ONE)));
-            job2      = _mm512_add_epi64(job2, _mm512_add_epi64(all_ONE, _mm512_and_epi64(_mm512_srli_epi64(code2, 8), all_ONE)));
-                        // test which lanes are done now (job1.cur==job1.end), cur starts at bit 46, end starts at bit 28 (the highest 2x18 bits in the job1 register)
-                        // test which lanes are done now (job2.cur==job2.end), cur starts at bit 46, end starts at bit 28 (the highest 2x18 bits in the job2 register)
-            loadmask1 = _mm512_cmpeq_epi64_mask(_mm512_srli_epi64(job1, 46), _mm512_and_epi64(_mm512_srli_epi64(job1, 28), all_M18));
-            loadmask2 = _mm512_cmpeq_epi64_mask(_mm512_srli_epi64(job2, 46), _mm512_and_epi64(_mm512_srli_epi64(job2, 28), all_M18));
-                        // calculate the amount of lanes in job1 that are done
-                        // calculate the amount of lanes in job2 that are done
-            delta1    = _mm_popcnt_u32((int) loadmask1); 
-            delta2    = _mm_popcnt_u32((int) loadmask2); 
-                        // write out the job state for the lanes that are done (we need the final 'job1.out' value to compute the compressed string length)
-                        // write out the job state for the lanes that are done (we need the final 'job2.out' value to compute the compressed string length)
-                        _mm512_mask_compressstoreu_epi64(output, loadmask1, job1); output += delta1;
-                        _mm512_mask_compressstoreu_epi64(output, loadmask2, job2); output += delta2;