Add tests for non standart dictionaries and fix bugs

dbms/src/Dictionaries/CacheDictionary.cpp

@@ -611,7 +611,7 @@ void registerDictionaryCache(DictionaryFactory & factory)
         const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
         return std::make_unique<CacheDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, size);
     };
-    factory.registerLayout("cache", create_layout);
+    factory.registerLayout("cache", create_layout, false);
 }
 
 

dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp

@@ -415,7 +415,7 @@ void registerDictionaryComplexKeyCache(DictionaryFactory & factory)
         const DictionaryLifetime dict_lifetime{config, config_prefix + ".lifetime"};
         return std::make_unique<ComplexKeyCacheDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, size);
     };
-    factory.registerLayout("complex_key_cache", create_layout);
+    factory.registerLayout("complex_key_cache", create_layout, true);
 }
 
 

dbms/src/Dictionaries/ComplexKeyHashedDictionary.cpp

@@ -755,7 +755,7 @@ void registerDictionaryComplexKeyHashed(DictionaryFactory & factory)
         const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
         return std::make_unique<ComplexKeyHashedDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty);
     };
-    factory.registerLayout("complex_key_hashed", create_layout);
+    factory.registerLayout("complex_key_hashed", create_layout, true);
 }
 
 

dbms/src/Dictionaries/DictionaryFactory.cpp

@@ -13,10 +13,13 @@ namespace ErrorCodes
     extern const int UNKNOWN_ELEMENT_IN_CONFIG;
 }
 
-void DictionaryFactory::registerLayout(const std::string & layout_type, Creator create_layout)
+void DictionaryFactory::registerLayout(const std::string & layout_type, Creator create_layout, bool is_complex)
 {
     if (!registered_layouts.emplace(layout_type, std::move(create_layout)).second)
         throw Exception("DictionaryFactory: the layout name '" + layout_type + "' is not unique", ErrorCodes::LOGICAL_ERROR);
+
+    layout_complexity[layout_type] = is_complex;
+
 }
 
 

dbms/src/Dictionaries/DictionaryFactory.h

@@ -45,11 +45,15 @@ public:
         const std::string & config_prefix,
         DictionarySourcePtr source_ptr)>;
 
-    void registerLayout(const std::string & layout_type, Creator create_layout);
+    bool isComplex(const std::string & layout_type) const { return layout_complexity.at(layout_type); }
+
+    void registerLayout(const std::string & layout_type, Creator create_layout, bool is_complex);
 
 private:
     using LayoutRegistry = std::unordered_map<std::string, Creator>;
     LayoutRegistry registered_layouts;
+    using LayoutComplexity = std::unordered_map<std::string, bool>;
+    LayoutComplexity layout_complexity;
 };
 
 }

dbms/src/Dictionaries/FlatDictionary.cpp

@@ -724,7 +724,7 @@ void registerDictionaryFlat(DictionaryFactory & factory)
         const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
         return std::make_unique<FlatDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty);
     };
-    factory.registerLayout("flat", create_layout);
+    factory.registerLayout("flat", create_layout, false);
 }
 
 

dbms/src/Dictionaries/HashedDictionary.cpp

@@ -787,8 +787,8 @@ void registerDictionaryHashed(DictionaryFactory & factory)
         const bool sparse = name == "sparse_hashed";
         return std::make_unique<HashedDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty, sparse);
     };
-    factory.registerLayout("hashed", create_layout);
-    factory.registerLayout("sparse_hashed", create_layout);
+    factory.registerLayout("hashed", create_layout, false);
+    factory.registerLayout("sparse_hashed", create_layout, false);
 }
 
 }

dbms/src/Dictionaries/RangeHashedDictionary.cpp

@@ -691,7 +691,7 @@ void registerDictionaryRangeHashed(DictionaryFactory & factory)
         const bool require_nonempty = config.getBool(config_prefix + ".require_nonempty", false);
         return std::make_unique<RangeHashedDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty);
     };
-    factory.registerLayout("range_hashed", create_layout);
+    factory.registerLayout("range_hashed", create_layout, false);
 }
 
 }

dbms/src/Dictionaries/TrieDictionary.cpp

@@ -767,7 +767,7 @@ void registerDictionaryTrie(DictionaryFactory & factory)
         // This is specialised trie for storing IPv4 and IPv6 prefixes.
         return std::make_unique<TrieDictionary>(name, dict_struct, std::move(source_ptr), dict_lifetime, require_nonempty);
     };
-    factory.registerLayout("ip_trie", create_layout);
+    factory.registerLayout("ip_trie", create_layout, true);
 }
 
 }

dbms/src/Dictionaries/getDictionaryConfigurationFromAST.cpp

@@ -13,6 +13,7 @@
 #include <Core/Names.h>
 #include <Parsers/ASTFunctionWithKeyValueArguments.h>
 #include <Parsers/ASTDictionaryAttributeDeclaration.h>
+#include <Dictionaries/DictionaryFactory.h>
 
 namespace DB
 {
@@ -411,7 +412,7 @@ DictionaryConfigurationPtr getDictionaryConfigurationFromAST(const ASTCreateQuer
     Names pk_columns = getPrimaryKeyColumns(query.dictionary->primary_key);
     auto dictionary_layout = query.dictionary->layout;
 
-    bool complex = startsWith(dictionary_layout->layout_type, "complex");
+    bool complex = DictionaryFactory::instance().isComplex(dictionary_layout->layout_type);
 
     buildDictionaryAttributesConfiguration(xml_document, structure_element, query.dictionary_attributes_list, pk_columns);
 
@@ -422,7 +423,7 @@ DictionaryConfigurationPtr getDictionaryConfigurationFromAST(const ASTCreateQuer
     buildLifetimeConfiguration(xml_document, current_dictionary, query.dictionary->lifetime);
 
     if (query.dictionary->range)
-        buildRangeConfiguration(xml_document, current_dictionary, query.dictionary->range);
+        buildRangeConfiguration(xml_document, structure_element, query.dictionary->range);
 
     conf->load(xml_document);
     return conf;

dbms/src/Dictionaries/tests/gtest_dictionary_configuration.cpp

@@ -14,11 +14,13 @@
 #include <Parsers/formatAST.h>
 #include <Parsers/parseQuery.h>
 #include <Dictionaries/getDictionaryConfigurationFromAST.h>
+#include <Dictionaries/registerDictionaries.h>
 
 #include <gtest/gtest.h>
 
 using namespace DB;
 
+static bool registered = false;
 /// For debug
 std::string configurationToString(const DictionaryConfigurationPtr & config)
 {
@@ -30,6 +32,12 @@ std::string configurationToString(const DictionaryConfigurationPtr & config)
 
 TEST(ConvertDictionaryAST, SimpleDictConfiguration)
 {
+    if (!registered)
+    {
+        registerDictionaries();
+        registered = true;
+    }
+
     String input = " CREATE DICTIONARY test.dict1"
                    " ("
                    "    key_column UInt64 DEFAULT 0,"
@@ -55,8 +63,8 @@ TEST(ConvertDictionaryAST, SimpleDictConfiguration)
     EXPECT_EQ(config->getInt("dictionary.lifetime.max"), 10);
 
     /// range
-    EXPECT_EQ(config->getString("dictionary.range_min"), "second_column");
-    EXPECT_EQ(config->getString("dictionary.range_max"), "third_column");
+    EXPECT_EQ(config->getString("dictionary.structure.range_min"), "second_column");
+    EXPECT_EQ(config->getString("dictionary.structure.range_max"), "third_column");
 
     /// source
     EXPECT_EQ(config->getString("dictionary.source.clickhouse.host"), "localhost");
@@ -70,7 +78,7 @@ TEST(ConvertDictionaryAST, SimpleDictConfiguration)
     Poco::Util::AbstractConfiguration::Keys keys;
     config->keys("dictionary.structure", keys);
 
-    EXPECT_EQ(keys.size(), 3);
+    EXPECT_EQ(keys.size(), 5); /// + ranged keys
     EXPECT_EQ(config->getString("dictionary.structure." + keys[0] + ".name"), "second_column");
     EXPECT_EQ(config->getString("dictionary.structure." + keys[0] + ".type"), "UInt8");
     EXPECT_EQ(config->getInt("dictionary.structure." + keys[0] + ".null_value"), 1);
@@ -89,6 +97,12 @@ TEST(ConvertDictionaryAST, SimpleDictConfiguration)
 
 TEST(ConvertDictionaryAST, TrickyAttributes)
 {
+    if (!registered)
+    {
+        registerDictionaries();
+        registered = true;
+    }
+
     String input = " CREATE DICTIONARY dict2"
                    " ("
                    "    key_column UInt64 IS_OBJECT_ID,"
@@ -127,6 +141,12 @@ TEST(ConvertDictionaryAST, TrickyAttributes)
 
 TEST(ConvertDictionaryAST, ComplexKeyAndLayoutWithParams)
 {
+    if (!registered)
+    {
+        registerDictionaries();
+        registered = true;
+    }
+
     String input = " CREATE DICTIONARY dict4"
                    " ("
                    "    key_column1 String,"
@@ -172,6 +192,12 @@ TEST(ConvertDictionaryAST, ComplexKeyAndLayoutWithParams)
 
 TEST(ConvertDictionaryAST, ComplexSource)
 {
+    if (!registered)
+    {
+        registerDictionaries();
+        registered = true;
+    }
+
     String input = " CREATE DICTIONARY dict4"
                    " ("
                    "    key_column UInt64,"