Revert "Disallow Gorilla codec on non-float columns"

src/Compression/CompressionCodecDelta.cpp

@@ -28,7 +28,6 @@ protected:
 
     bool isCompression() const override { return false; }
     bool isGenericCompression() const override { return false; }
-    bool isDelta() const override { return true; }
 
 private:
     UInt8 delta_bytes_size;

src/Compression/CompressionCodecDoubleDelta.cpp

@@ -133,7 +133,6 @@ protected:
 
     bool isCompression() const override { return true; }
     bool isGenericCompression() const override { return false; }
-    bool isDelta() const override { return true; }
 
 private:
     UInt8 data_bytes_size;

src/Compression/CompressionCodecFPC.cpp

@@ -39,7 +39,6 @@ protected:
 
     bool isCompression() const override { return true; }
     bool isGenericCompression() const override { return false; }
-    bool isFloatingPointTimeSeries() const override { return true; }
 
 private:
     static constexpr UInt32 HEADER_SIZE = 2;

src/Compression/CompressionCodecGorilla.cpp

@@ -123,7 +123,6 @@ protected:
 
     bool isCompression() const override { return true; }
     bool isGenericCompression() const override { return false; }
-    bool isFloatingPointTimeSeries() const override { return true; }
 
 private:
     UInt8 data_bytes_size;
@@ -445,19 +444,14 @@ void CompressionCodecGorilla::doDecompressData(const char * source, UInt32 sourc
 void registerCodecGorilla(CompressionCodecFactory & factory)
 {
     UInt8 method_code = static_cast<UInt8>(CompressionMethodByte::Gorilla);
-    auto codec_builder = [&](const ASTPtr & arguments, const IDataType * column_type) -> CompressionCodecPtr
+    factory.registerCompressionCodecWithType("Gorilla", method_code,
+        [&](const ASTPtr & arguments, const IDataType * column_type) -> CompressionCodecPtr
     {
         if (arguments)
             throw Exception("Codec Gorilla does not accept any arguments", ErrorCodes::BAD_ARGUMENTS);
 
-        if (column_type != nullptr)
-            if (!WhichDataType(*column_type).isFloat())
-                throw Exception(ErrorCodes::BAD_ARGUMENTS, "Gorilla codec is not applicable for {} because the data type is not float",
-                        column_type->getName());
-
         UInt8 data_bytes_size = column_type ? getDataBytesSize(column_type) : 0;
         return std::make_shared<CompressionCodecGorilla>(data_bytes_size);
-    };
+    });
-    factory.registerCompressionCodecWithType("Gorilla", method_code, codec_builder);
 }
 }

src/Compression/CompressionFactoryAdditions.cpp

@@ -59,17 +59,15 @@ ASTPtr CompressionCodecFactory::validateCodecAndGetPreprocessedAST(
     {
         ASTPtr codecs_descriptions = std::make_shared<ASTExpressionList>();
 
-        bool with_compressing_codec = false;
+        bool is_compression = false;
-        bool with_none_codec = false;
+        bool has_none = false;
         std::optional<size_t> generic_compression_codec_pos;
-        std::optional<size_t> first_delta_codec_pos;
+        std::set<size_t> encryption_codecs;
-        std::optional<size_t> last_floating_point_time_series_codec_pos;
-        std::set<size_t> encryption_codecs_pos;
 
         bool can_substitute_codec_arguments = true;
         for (size_t i = 0, size = func->arguments->children.size(); i < size; ++i)
         {
-            const ASTPtr & inner_codec_ast = func->arguments->children[i];
+            const auto & inner_codec_ast = func->arguments->children[i];
             String codec_family_name;
             ASTPtr codec_arguments;
             if (const auto * family_name = inner_codec_ast->as<ASTIdentifier>())
@@ -85,7 +83,8 @@ ASTPtr CompressionCodecFactory::validateCodecAndGetPreprocessedAST(
             else
                 throw Exception("Unexpected AST element for compression codec", ErrorCodes::UNEXPECTED_AST_STRUCTURE);
 
-            /// Replace "Default" codec by configured default codec which may depend on different settings and data properties at runtime.
+            /// Default codec replaced with current default codec which may depend on different
+            /// settings (and properties of data) in runtime.
             CompressionCodecPtr result_codec;
             if (codec_family_name == DEFAULT_CODEC_NAME)
             {
@@ -137,27 +136,21 @@ ASTPtr CompressionCodecFactory::validateCodecAndGetPreprocessedAST(
                 codecs_descriptions->children.emplace_back(result_codec->getCodecDesc());
             }
 
-            with_compressing_codec |= result_codec->isCompression();
+            is_compression |= result_codec->isCompression();
-            with_none_codec |= result_codec->isNone();
+            has_none |= result_codec->isNone();
 
             if (!generic_compression_codec_pos && result_codec->isGenericCompression())
                 generic_compression_codec_pos = i;
 
             if (result_codec->isEncryption())
-                encryption_codecs_pos.insert(i);
+                encryption_codecs.insert(i);
-
-            if (result_codec->isDelta() && !first_delta_codec_pos.has_value())
-                first_delta_codec_pos = i;
-
-            if (result_codec->isFloatingPointTimeSeries())
-                last_floating_point_time_series_codec_pos = i;
         }
 
         String codec_description = queryToString(codecs_descriptions);
 
         if (sanity_check)
         {
-            if (codecs_descriptions->children.size() > 1 && with_none_codec)
+            if (codecs_descriptions->children.size() > 1 && has_none)
                 throw Exception(
                     "It does not make sense to have codec NONE along with other compression codecs: " + codec_description
                         + ". (Note: you can enable setting 'allow_suspicious_codecs' to skip this check).",
@@ -166,7 +159,7 @@ ASTPtr CompressionCodecFactory::validateCodecAndGetPreprocessedAST(
             /// Allow to explicitly specify single NONE codec if user don't want any compression.
             /// But applying other transformations solely without compression (e.g. Delta) does not make sense.
             /// It's okay to apply encryption codecs solely without anything else.
-            if (!with_compressing_codec && !with_none_codec && encryption_codecs_pos.size() != codecs_descriptions->children.size())
+            if (!is_compression && !has_none && encryption_codecs.size() != codecs_descriptions->children.size())
                 throw Exception(
                     "Compression codec " + codec_description
                         + " does not compress anything."
@@ -178,8 +171,8 @@ ASTPtr CompressionCodecFactory::validateCodecAndGetPreprocessedAST(
 
             /// It does not make sense to apply any non-encryption codecs
             /// after encryption one.
-            if (!encryption_codecs_pos.empty() &&
+            if (!encryption_codecs.empty() &&
-                *encryption_codecs_pos.begin() != codecs_descriptions->children.size() - encryption_codecs_pos.size())
+                *encryption_codecs.begin() != codecs_descriptions->children.size() - encryption_codecs.size())
                 throw Exception("The combination of compression codecs " + codec_description + " is meaningless,"
                                 " because it does not make sense to apply any non-post-processing codecs after"
                                 " post-processing ones. (Note: you can enable setting 'allow_suspicious_codecs'"
@@ -188,18 +181,11 @@ ASTPtr CompressionCodecFactory::validateCodecAndGetPreprocessedAST(
             /// It does not make sense to apply any transformations after generic compression algorithm
             /// So, generic compression can be only one and only at the end.
             if (generic_compression_codec_pos &&
-                *generic_compression_codec_pos != codecs_descriptions->children.size() - 1 - encryption_codecs_pos.size())
+                *generic_compression_codec_pos != codecs_descriptions->children.size() - 1 - encryption_codecs.size())
                 throw Exception("The combination of compression codecs " + codec_description + " is meaningless,"
                     " because it does not make sense to apply any transformations after generic compression algorithm."
                     " (Note: you can enable setting 'allow_suspicious_codecs' to skip this check).", ErrorCodes::BAD_ARGUMENTS);
 
-            /// Floating point time series codecs usually have implicit delta compression (or something equivalent), so it does not make
-            /// sense to run delta compression manually. Another reason for blocking such combination is occasional data corruption (#45195).
-            if (first_delta_codec_pos.has_value() && last_floating_point_time_series_codec_pos.has_value()
-                && (*first_delta_codec_pos < last_floating_point_time_series_codec_pos))
-                throw Exception("The combination of compression codecs " + codec_description + " is meaningless,"
-                    " because it does not make sense to apply delta transformations before floating point time series codecs."
-                    " (Note: you can enable setting 'allow_suspicious_codecs' to skip this check).", ErrorCodes::BAD_ARGUMENTS);
         }
 
         /// For columns with nested types like Tuple(UInt32, UInt64) we

src/Compression/ICompressionCodec.h

@@ -113,12 +113,6 @@ public:
     /// If it does nothing.
     virtual bool isNone() const { return false; }
 
-    /// If the only purpose of the codec is to delta (or double-delta) the data.
-    virtual bool isDelta() const { return false; }
-
-    /// If the codec is specialized for floating point time series.
-    virtual bool isFloatingPointTimeSeries() const { return false; }
-
 protected:
     /// This is used for fuzz testing
     friend int LLVMFuzzerTestOneInput(const uint8_t * data, size_t size);

src/Compression/tests/gtest_compressionCodec.cpp

@@ -529,13 +529,6 @@ public:
 
 TEST_P(CodecTest, TranscodingWithDataType)
 {
-    /// Gorilla can only be applied to floating point columns
-    bool codec_is_gorilla = std::get<0>(GetParam()).codec_statement.find("Gorilla") != std::string::npos;
-    WhichDataType which(std::get<1>(GetParam()).data_type.get());
-    bool data_is_float = which.isFloat();
-    if (codec_is_gorilla && !data_is_float)
-        GTEST_SKIP() << "Skipping Gorilla-compressed integer column";
-
     const auto codec = makeCodec(CODEC_WITH_DATA_TYPE);
     testTranscoding(*codec);
 }
@@ -1211,20 +1204,68 @@ auto DDperformanceTestSequence()
 }
 
 // prime numbers in ascending order with some random repetitions hit all the cases of Gorilla.
-// auto PrimesWithMultiplierGenerator = [](int multiplier = 1)
+auto PrimesWithMultiplierGenerator = [](int multiplier = 1)
-// {
+{
-//     return [multiplier](auto i)
+    return [multiplier](auto i)
-//     {
+    {
-//         static const int vals[] = {
+        static const int vals[] = {
-//              2, 3, 5, 7, 11, 11, 13, 17, 19, 23, 29, 29, 31, 37, 41, 43,
+             2, 3, 5, 7, 11, 11, 13, 17, 19, 23, 29, 29, 31, 37, 41, 43,
-//             47, 47, 53, 59, 61, 61, 67, 71, 73, 79, 83, 89, 89, 97, 101, 103,
+            47, 47, 53, 59, 61, 61, 67, 71, 73, 79, 83, 89, 89, 97, 101, 103,
-//             107, 107, 109, 113, 113, 127, 127, 127
+            107, 107, 109, 113, 113, 127, 127, 127
-//         };
+        };
-//         static const size_t count = sizeof(vals)/sizeof(vals[0]);
+        static const size_t count = sizeof(vals)/sizeof(vals[0]);
-//
+
-//         return static_cast<UInt64>(vals[i % count]) * multiplier;
+        return static_cast<UInt64>(vals[i % count]) * multiplier;
-//     };
+    };
-// };
+};
+
+template <typename ValueType>
+auto GCompatibilityTestSequence()
+{
+    // Also multiply result by some factor to test large values on types that can hold those.
+    return generateSeq<ValueType>(G(PrimesWithMultiplierGenerator(intExp10(sizeof(ValueType)))), 0, 42);
+}
+
+INSTANTIATE_TEST_SUITE_P(Gorilla,
+    CodecTestCompatibility,
+    ::testing::Combine(
+        ::testing::Values(Codec("Gorilla")),
+        ::testing::ValuesIn(std::initializer_list<std::tuple<CodecTestSequence, std::string>>{
+            {
+                GCompatibilityTestSequence<Int8>(),
+                BIN_STR("\x95\x35\x00\x00\x00\x2a\x00\x00\x00\x01\x00\x2a\x00\x00\x00\x14\xe1\xdd\x25\xe5\x7b\x29\x86\xee\x2a\x16\x5a\xc5\x0b\x23\x75\x1b\x3c\xb1\x97\x8b\x5f\xcb\x43\xd9\xc5\x48\xab\x23\xaf\x62\x93\x71\x4a\x73\x0f\xc6\x0a")
+            },
+            {
+                GCompatibilityTestSequence<UInt8>(),
+                BIN_STR("\x95\x35\x00\x00\x00\x2a\x00\x00\x00\x01\x00\x2a\x00\x00\x00\x14\xe1\xdd\x25\xe5\x7b\x29\x86\xee\x2a\x16\x5a\xc5\x0b\x23\x75\x1b\x3c\xb1\x97\x8b\x5f\xcb\x43\xd9\xc5\x48\xab\x23\xaf\x62\x93\x71\x4a\x73\x0f\xc6\x0a")
+            },
+            {
+                GCompatibilityTestSequence<Int16>(),
+                BIN_STR("\x95\x52\x00\x00\x00\x54\x00\x00\x00\x02\x00\x2a\x00\x00\x00\xc8\x00\xdc\xfe\x66\xdb\x1f\x4e\xa7\xde\xdc\xd5\xec\x6e\xf7\x37\x3a\x23\xe7\x63\xf5\x6a\x8e\x99\x37\x34\xf9\xf8\x2e\x76\x35\x2d\x51\xbb\x3b\xc3\x6d\x13\xbf\x86\x53\x9e\x25\xe4\xaf\xaf\x63\xd5\x6a\x6e\x76\x35\x3a\x27\xd3\x0f\x91\xae\x6b\x33\x57\x6e\x64\xcc\x55\x81\xe4")
+            },
+            {
+                GCompatibilityTestSequence<UInt16>(),
+                BIN_STR("\x95\x52\x00\x00\x00\x54\x00\x00\x00\x02\x00\x2a\x00\x00\x00\xc8\x00\xdc\xfe\x66\xdb\x1f\x4e\xa7\xde\xdc\xd5\xec\x6e\xf7\x37\x3a\x23\xe7\x63\xf5\x6a\x8e\x99\x37\x34\xf9\xf8\x2e\x76\x35\x2d\x51\xbb\x3b\xc3\x6d\x13\xbf\x86\x53\x9e\x25\xe4\xaf\xaf\x63\xd5\x6a\x6e\x76\x35\x3a\x27\xd3\x0f\x91\xae\x6b\x33\x57\x6e\x64\xcc\x55\x81\xe4")
+            },
+            {
+                GCompatibilityTestSequence<Int32>(),
+                BIN_STR("\x95\x65\x00\x00\x00\xa8\x00\x00\x00\x04\x00\x2a\x00\x00\x00\x20\x4e\x00\x00\xe4\x57\x63\xc0\xbb\x67\xbc\xce\x91\x97\x99\x15\x9e\xe3\x36\x3f\x89\x5f\x8e\xf2\xec\x8e\xd3\xbf\x75\x43\x58\xc4\x7e\xcf\x93\x43\x38\xc6\x91\x36\x1f\xe7\xb6\x11\x6f\x02\x73\x46\xef\xe0\xec\x50\xfb\x79\xcb\x9c\x14\xfa\x13\xea\x8d\x66\x43\x48\xa0\xde\x3a\xcf\xff\x26\xe0\x5f\x93\xde\x5e\x7f\x6e\x36\x5e\xe6\xb4\x66\x5d\xb0\x0e\xc4")
+            },
+            {
+                GCompatibilityTestSequence<UInt32>(),
+                BIN_STR("\x95\x65\x00\x00\x00\xa8\x00\x00\x00\x04\x00\x2a\x00\x00\x00\x20\x4e\x00\x00\xe4\x57\x63\xc0\xbb\x67\xbc\xce\x91\x97\x99\x15\x9e\xe3\x36\x3f\x89\x5f\x8e\xf2\xec\x8e\xd3\xbf\x75\x43\x58\xc4\x7e\xcf\x93\x43\x38\xc6\x91\x36\x1f\xe7\xb6\x11\x6f\x02\x73\x46\xef\xe0\xec\x50\xfb\x79\xcb\x9c\x14\xfa\x13\xea\x8d\x66\x43\x48\xa0\xde\x3a\xcf\xff\x26\xe0\x5f\x93\xde\x5e\x7f\x6e\x36\x5e\xe6\xb4\x66\x5d\xb0\x0e\xc4")
+            },
+            {
+                GCompatibilityTestSequence<Int64>(),
+                BIN_STR("\x95\x91\x00\x00\x00\x50\x01\x00\x00\x08\x00\x2a\x00\x00\x00\x00\xc2\xeb\x0b\x00\x00\x00\x00\xe3\x2b\xa0\xa6\x19\x85\x98\xdc\x45\x74\x74\x43\xc2\x57\x41\x4c\x6e\x42\x79\xd9\x8f\x88\xa5\x05\xf3\xf1\x94\xa3\x62\x1e\x02\xdf\x05\x10\xf1\x15\x97\x35\x2a\x50\x71\x0f\x09\x6c\x89\xf7\x65\x1d\x11\xb7\xcc\x7d\x0b\x70\xc1\x86\x88\x48\x47\x87\xb6\x32\x26\xa7\x86\x87\x88\xd3\x93\x3d\xfc\x28\x68\x85\x05\x0b\x13\xc6\x5f\xd4\x70\xe1\x5e\x76\xf1\x9f\xf3\x33\x2a\x14\x14\x5e\x40\xc1\x5c\x28\x3f\xec\x43\x03\x05\x11\x91\xe8\xeb\x8e\x0a\x0e\x27\x21\x55\xcb\x39\xbc\x6a\xff\x11\x5d\x81\xa0\xa6\x10")
+            },
+            {
+                GCompatibilityTestSequence<UInt64>(),
+                BIN_STR("\x95\x91\x00\x00\x00\x50\x01\x00\x00\x08\x00\x2a\x00\x00\x00\x00\xc2\xeb\x0b\x00\x00\x00\x00\xe3\x2b\xa0\xa6\x19\x85\x98\xdc\x45\x74\x74\x43\xc2\x57\x41\x4c\x6e\x42\x79\xd9\x8f\x88\xa5\x05\xf3\xf1\x94\xa3\x62\x1e\x02\xdf\x05\x10\xf1\x15\x97\x35\x2a\x50\x71\x0f\x09\x6c\x89\xf7\x65\x1d\x11\xb7\xcc\x7d\x0b\x70\xc1\x86\x88\x48\x47\x87\xb6\x32\x26\xa7\x86\x87\x88\xd3\x93\x3d\xfc\x28\x68\x85\x05\x0b\x13\xc6\x5f\xd4\x70\xe1\x5e\x76\xf1\x9f\xf3\x33\x2a\x14\x14\x5e\x40\xc1\x5c\x28\x3f\xec\x43\x03\x05\x11\x91\xe8\xeb\x8e\x0a\x0e\x27\x21\x55\xcb\x39\xbc\x6a\xff\x11\x5d\x81\xa0\xa6\x10")
+            },
+        })
+    )
+);
 
 // These 'tests' try to measure performance of encoding and decoding and hence only make sense to be run locally,
 // also they require pretty big data to run against and generating this data slows down startup of unit test process.

tests/performance/codecs_int_insert.xml

@@ -13,6 +13,7 @@
                 <value>Delta</value>
                 <value>T64</value>
                 <value>DoubleDelta</value>
+                <value>Gorilla</value>
             </values>
         </substitution>
         <substitution>

tests/performance/codecs_int_select.xml

@@ -13,6 +13,7 @@
                 <value>Delta</value>
                 <value>T64</value>
                 <value>DoubleDelta</value>
+                <value>Gorilla</value>
             </values>
         </substitution>
         <substitution>

tests/queries/0_stateless/01272_suspicious_codecs.reference

@@ -6,8 +6,6 @@ CREATE TABLE default.codecs5\n(\n    `a` UInt8 CODEC(LZ4, ZSTD(1))\n)\nENGINE =
 CREATE TABLE default.codecs6\n(\n    `a` UInt8 CODEC(Delta(1))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs7\n(\n    `a` UInt8 CODEC(Delta(1), Delta(1))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs8\n(\n    `a` UInt8 CODEC(LZ4, Delta(1))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
-CREATE TABLE default.codecs9\n(\n    `a` Float64 CODEC(Delta(8), FPC(12))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
-CREATE TABLE default.codecs10\n(\n    `a` Float64 CODEC(DoubleDelta, Gorilla)\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs1\n(\n    `a` UInt8 CODEC(NONE, NONE)\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs2\n(\n    `a` UInt8 CODEC(NONE, LZ4)\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs3\n(\n    `a` UInt8 CODEC(LZ4, NONE)\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
@@ -16,5 +14,3 @@ CREATE TABLE default.codecs5\n(\n    `a` UInt8 CODEC(LZ4, ZSTD(1))\n)\nENGINE =
 CREATE TABLE default.codecs6\n(\n    `a` UInt8 CODEC(Delta(1))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs7\n(\n    `a` UInt8 CODEC(Delta(1), Delta(1))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
 CREATE TABLE default.codecs8\n(\n    `a` UInt8 CODEC(LZ4, Delta(1))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
-CREATE TABLE default.codecs9\n(\n    `a` Float64 CODEC(Delta(8), FPC(12))\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192
-CREATE TABLE default.codecs10\n(\n    `a` Float64 CODEC(DoubleDelta, Gorilla)\n)\nENGINE = MergeTree\nORDER BY tuple()\nSETTINGS index_granularity = 8192

tests/queries/0_stateless/01272_suspicious_codecs.sql

@@ -11,28 +11,24 @@ CREATE TABLE codecs
     c Float32 CODEC(Gorilla),
     d UInt8 CODEC(Delta, LZ4),
     e Float64 CODEC(Gorilla, ZSTD),
-    f UInt64 CODEC(Delta, Delta, T64),
+    f UInt32 CODEC(Delta, Delta, Gorilla),
     g DateTime CODEC(DoubleDelta),
     h DateTime64 CODEC(DoubleDelta, LZ4),
-    i String CODEC(NONE),
+    i String CODEC(NONE)
-    j Float64 (Gorilla, Delta),
-    k Float32 (FPC, DoubleDelta)
 ) ENGINE = MergeTree ORDER BY tuple();
 
 DROP TABLE codecs;
 
 -- test what should not work
 
-CREATE TABLE codecs (a UInt8 CODEC(NONE, NONE)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(NONE, NONE)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(NONE, LZ4)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(NONE, LZ4)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(LZ4, NONE)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(LZ4, NONE)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(LZ4, LZ4)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(LZ4, LZ4)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(LZ4, ZSTD)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(LZ4, ZSTD)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(Delta)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(Delta)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(Delta, Delta)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(Delta, Delta)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(LZ4, Delta)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
+CREATE TABLE codecs (a UInt8 CODEC(LZ4, Delta)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError 36 }
-CREATE TABLE codecs (a UInt8 CODEC(Delta, FPC)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
-CREATE TABLE codecs (a UInt8 CODEC(DoubleDelta, Gorilla)) ENGINE = MergeTree ORDER BY tuple(); -- { serverError BAD_ARGUMENTS }
 
 -- test that sanity check is not performed in ATTACH query
 
@@ -44,8 +40,6 @@ DROP TABLE IF EXISTS codecs5;
 DROP TABLE IF EXISTS codecs6;
 DROP TABLE IF EXISTS codecs7;
 DROP TABLE IF EXISTS codecs8;
-DROP TABLE IF EXISTS codecs9;
-DROP TABLE IF EXISTS codecs10;
 
 SET allow_suspicious_codecs = 1;
 
@@ -57,8 +51,6 @@ CREATE TABLE codecs5 (a UInt8 CODEC(LZ4, ZSTD)) ENGINE = MergeTree ORDER BY tupl
 CREATE TABLE codecs6 (a UInt8 CODEC(Delta)) ENGINE = MergeTree ORDER BY tuple();
 CREATE TABLE codecs7 (a UInt8 CODEC(Delta, Delta)) ENGINE = MergeTree ORDER BY tuple();
 CREATE TABLE codecs8 (a UInt8 CODEC(LZ4, Delta)) ENGINE = MergeTree ORDER BY tuple();
-CREATE TABLE codecs9 (a Float64 CODEC(Delta, FPC)) ENGINE = MergeTree ORDER BY tuple();
-CREATE TABLE codecs10 (a Float64 CODEC(DoubleDelta, Gorilla)) ENGINE = MergeTree ORDER BY tuple();
 
 SET allow_suspicious_codecs = 0;
 
@@ -70,8 +62,6 @@ SHOW CREATE TABLE codecs5;
 SHOW CREATE TABLE codecs6;
 SHOW CREATE TABLE codecs7;
 SHOW CREATE TABLE codecs8;
-SHOW CREATE TABLE codecs9;
-SHOW CREATE TABLE codecs10;
 
 DETACH TABLE codecs1;
 DETACH TABLE codecs2;
@@ -81,8 +71,6 @@ DETACH TABLE codecs5;
 DETACH TABLE codecs6;
 DETACH TABLE codecs7;
 DETACH TABLE codecs8;
-DETACH TABLE codecs9;
-DETACH TABLE codecs10;
 
 ATTACH TABLE codecs1;
 ATTACH TABLE codecs2;
@@ -92,8 +80,6 @@ ATTACH TABLE codecs5;
 ATTACH TABLE codecs6;
 ATTACH TABLE codecs7;
 ATTACH TABLE codecs8;
-ATTACH TABLE codecs9;
-ATTACH TABLE codecs10;
 
 SHOW CREATE TABLE codecs1;
 SHOW CREATE TABLE codecs2;
@@ -103,8 +89,6 @@ SHOW CREATE TABLE codecs5;
 SHOW CREATE TABLE codecs6;
 SHOW CREATE TABLE codecs7;
 SHOW CREATE TABLE codecs8;
-SHOW CREATE TABLE codecs9;
-SHOW CREATE TABLE codecs10;
 
 SELECT * FROM codecs1;
 SELECT * FROM codecs2;
@@ -114,8 +98,6 @@ SELECT * FROM codecs5;
 SELECT * FROM codecs6;
 SELECT * FROM codecs7;
 SELECT * FROM codecs8;
-SELECT * FROM codecs9;
-SELECT * FROM codecs10;
 
 DROP TABLE codecs1;
 DROP TABLE codecs2;
@@ -125,5 +107,3 @@ DROP TABLE codecs5;
 DROP TABLE codecs6;
 DROP TABLE codecs7;
 DROP TABLE codecs8;
-DROP TABLE codecs9;
-DROP TABLE codecs10;

tests/queries/0_stateless/02533_gorilla_on_nonfloat.sql

@@ -1,4 +0,0 @@
-DROP TABLE IF EXISTS test;
-CREATE TABLE test (id UInt64, val Decimal(15,5) CODEC (Gorilla)) ENGINE = MergeTree() ORDER BY id; -- { serverError BAD_ARGUMENTS }
-CREATE TABLE test (id UInt64, val FixedString(2) CODEC (Gorilla)) ENGINE = MergeTree() ORDER BY id; -- { serverError BAD_ARGUMENTS }
-CREATE TABLE test (id UInt64, val UInt64 CODEC (Gorilla)) ENGINE = MergeTree() ORDER BY id; -- { serverError BAD_ARGUMENTS }