diff --git a/include/collection.h b/include/collection.h index 5a742de6..5b1697bd 100644 --- a/include/collection.h +++ b/include/collection.h @@ -323,7 +323,7 @@ private: const std::vector indices; - const std::string auto_detect_schema; + const std::string fallback_field_type; // methods @@ -409,7 +409,7 @@ public: static constexpr const char* COLLECTION_DEFAULT_SORTING_FIELD_KEY = "default_sorting_field"; static constexpr const char* COLLECTION_CREATED = "created_at"; static constexpr const char* COLLECTION_NUM_MEMORY_SHARDS = "num_memory_shards"; - static constexpr const char* COLLECTION_AUTO_DETECT_SCHEMA = "auto_detect_schema"; + static constexpr const char* COLLECTION_FALLBACK_FIELD_TYPE = "fallback_field_type"; // DON'T CHANGE THESE VALUES! // this key is used as namespace key to store metadata about the document @@ -423,7 +423,7 @@ public: Collection(const std::string& name, const uint32_t collection_id, const uint64_t created_at, const uint32_t next_seq_id, Store *store, const std::vector& fields, const std::string& default_sorting_field, const size_t num_memory_shards, - const float max_memory_ratio, const std::string& auto_detect_schema); + const float max_memory_ratio, const std::string& fallback_field_type); ~Collection(); diff --git a/include/collection_manager.h b/include/collection_manager.h index 0a8bab77..ff253a9a 100644 --- a/include/collection_manager.h +++ b/include/collection_manager.h @@ -125,11 +125,15 @@ public: bool auth_key_matches(const std::string& auth_key_sent, const std::string& action, const std::vector& collections, std::map& params) const; + static Option create_collection(nlohmann::json& req_json, + const size_t num_memory_shards, + const std::string & default_sorting_field); + Option create_collection(const std::string& name, const size_t num_memory_shards, const std::vector & fields, const std::string & default_sorting_field="", const uint64_t created_at = static_cast(std::time(nullptr)), - const std::string& auto_detect_schema = schema_detect_types::OFF); + const std::string& fallback_field_type = ""); locked_resource_view_t get_collection(const std::string & collection_name) const; diff --git a/include/field.h b/include/field.h index a0e01e1a..5adf017c 100644 --- a/include/field.h +++ b/include/field.h @@ -7,6 +7,9 @@ #include "json.hpp" namespace field_types { + // first field value indexed will determine the type + static const std::string AUTO = "auto"; + static const std::string STRING = "string"; static const std::string INT32 = "int32"; static const std::string INT64 = "int64"; @@ -18,6 +21,10 @@ namespace field_types { static const std::string INT64_ARRAY = "int64[]"; static const std::string FLOAT_ARRAY = "float[]"; static const std::string BOOL_ARRAY = "bool[]"; + + static bool is_string_or_array(const std::string type_def) { + return type_def == "string*"; + } } namespace fields { @@ -27,12 +34,6 @@ namespace fields { static const std::string optional = "optional"; } -namespace schema_detect_types { - static const std::string OFF = "off"; - static const std::string STRINGIFY = "stringify"; - static const std::string AUTO = "auto"; -} - static const uint8_t DEFAULT_GEO_RESOLUTION = 7; static const uint8_t FINEST_GEO_RESOLUTION = 15; @@ -61,7 +62,7 @@ struct field { } bool is_auto() const { - return (type == schema_detect_types::AUTO || type == schema_detect_types::STRINGIFY); + return (type == field_types::AUTO); } bool is_single_integer() const { @@ -129,7 +130,11 @@ struct field { } bool has_valid_type() const { - return is_string() || is_integer() || is_float() || is_bool() || is_geopoint() || is_auto(); + bool is_basic_type = is_string() || is_integer() || is_float() || is_bool() || is_geopoint() || is_auto(); + if(!is_basic_type) { + return field_types::is_string_or_array(type); + } + return true; } std::string faceted_name() const { @@ -227,7 +232,7 @@ struct field { } static Option json_fields_to_fields(nlohmann::json& fields_json, - std::string& auto_detect_schema, + std::string& fallback_field_type, std::vector& fields) { size_t num_auto_detect_fields = 0; @@ -251,13 +256,6 @@ struct field { } if(field_json["name"] == "*") { - if(field_json["type"] == schema_detect_types::AUTO || field_json["type"] == schema_detect_types::STRINGIFY) { - auto_detect_schema = field_json["type"]; - num_auto_detect_fields++; - } else { - return Option(400, "The `type` of field `*` is invalid."); - } - if(field_json.count("facet") == 0) { field_json["facet"] = false; } @@ -273,6 +271,19 @@ struct field { if(field_json["facet"] == true) { return Option(400, "Field `*` cannot be a facet field."); } + + field fallback_field(field_json["name"], field_json["type"], field_json["facet"], + field_json["optional"]); + + if(fallback_field.has_valid_type()) { + fallback_field_type = fallback_field.type; + num_auto_detect_fields++; + } else { + return Option(400, "The `type` of field `*` is invalid."); + } + + fields.emplace_back(fallback_field); + continue; } if(field_json.count("facet") == 0) { diff --git a/include/index.h b/include/index.h index 800c4c62..51c41b26 100644 --- a/include/index.h +++ b/include/index.h @@ -246,7 +246,7 @@ private: static void get_doc_changes(const nlohmann::json &document, nlohmann::json &old_doc, nlohmann::json &new_doc, nlohmann::json &del_doc); - static Option coerce_string(const DIRTY_VALUES& dirty_values, const std::string& auto_detect_schema, + static Option coerce_string(const DIRTY_VALUES& dirty_values, const std::string& fallback_field_type, const field& a_field, nlohmann::json &document, const std::string &field_name, nlohmann::json::iterator& array_iter, @@ -378,7 +378,7 @@ public: const std::string & default_sorting_field, const std::unordered_map & search_schema, const std::map & facet_schema, - const std::string& auto_detect_schema); + const std::string& fallback_field_type); static void populate_token_positions(const std::vector &query_suggestion, const std::vector& leaf_to_indices, @@ -396,7 +396,7 @@ public: const std::unordered_map & search_schema, const std::map & facet_schema, bool is_update, - const std::string& auto_detect_schema, + const std::string& fallback_field_type, const DIRTY_VALUES& dirty_values); void refresh_schemas(const std::vector& new_fields); diff --git a/src/collection.cpp b/src/collection.cpp index 40554c77..bf7bdd06 100644 --- a/src/collection.cpp +++ b/src/collection.cpp @@ -40,13 +40,13 @@ struct match_index_t { Collection::Collection(const std::string& name, const uint32_t collection_id, const uint64_t created_at, const uint32_t next_seq_id, Store *store, const std::vector &fields, const std::string& default_sorting_field, const size_t num_memory_shards, - const float max_memory_ratio, const std::string& auto_detect_schema): + const float max_memory_ratio, const std::string& fallback_field_type): name(name), collection_id(collection_id), created_at(created_at), next_seq_id(next_seq_id), store(store), fields(fields), default_sorting_field(default_sorting_field), num_memory_shards(num_memory_shards), max_memory_ratio(max_memory_ratio), - indices(init_indices()), auto_detect_schema(auto_detect_schema) { + indices(init_indices()), fallback_field_type(fallback_field_type) { this->num_documents = 0; } @@ -233,8 +233,8 @@ nlohmann::json Collection::add_many(std::vector& json_lines, nlohma get_document_from_store(get_seq_id_key(seq_id), record.old_doc); } - // if `auto_detect_schema` is enabled, we will have to update schema first before indexing - if(auto_detect_schema != schema_detect_types::OFF) { + // if `fallback_field_type` is enabled, we will have to update schema first before indexing + if(!fallback_field_type.empty()) { Option schema_change_op = check_and_update_schema(record.doc, dirty_values); if(!schema_change_op.ok()) { record.index_failure(schema_change_op.code(), schema_change_op.error()); @@ -354,7 +354,7 @@ Option Collection::index_in_memory(nlohmann::json &document, uint32_t Option validation_op = Index::validate_index_in_memory(document, seq_id, default_sorting_field, search_schema, facet_schema, is_update, - auto_detect_schema, dirty_values); + fallback_field_type, dirty_values); if(!validation_op.ok()) { return validation_op; @@ -382,7 +382,7 @@ size_t Collection::par_index_in_memory(std::vector> & CollectionManager::get_instance().get_thread_pool()->enqueue( [index, index_id, &num_indexed_vec, &iter_batch, this, &m_process, &num_processed, &cv_process]() { size_t num_indexed = Index::batch_memory_index(index, std::ref(iter_batch[index_id]), default_sorting_field, - search_schema, facet_schema, auto_detect_schema); + search_schema, facet_schema, fallback_field_type); std::unique_lock lock(m_process); num_indexed_vec[index_id] = num_indexed; num_processed++; @@ -2273,13 +2273,21 @@ Option Collection::check_and_update_schema(nlohmann::json& document, const const std::string &fname = kv.key(); field new_field(fname, field_type, false, true); - if (auto_detect_schema == schema_detect_types::STRINGIFY) { - if (new_field.is_array()) { - new_field.type = field_types::STRING_ARRAY; - } else { - new_field.type = field_types::STRING; + + if(!fallback_field_type.empty()) { + if (field_types::is_string_or_array(fallback_field_type)) { + // Supporting single/array field detection only for strings, as it does not seem to be too useful for + // other field types. + if (new_field.is_array()) { + new_field.type = field_types::STRING_ARRAY; + } else { + new_field.type = field_types::STRING; + } + } else if(fallback_field_type != field_types::AUTO) { + new_field.type = fallback_field_type; } } + search_schema.emplace(fname, new_field); fields.emplace_back(new_field); new_fields.emplace_back(new_field); @@ -2364,8 +2372,7 @@ DIRTY_VALUES Collection::parse_dirty_values_option(std::string& dirty_values) co if(dirty_values_op.has_value()) { dirty_values_action = dirty_values_op.value(); } else { - dirty_values_action = (auto_detect_schema == schema_detect_types::OFF) ? DIRTY_VALUES::REJECT - : DIRTY_VALUES::COERCE_OR_REJECT; + dirty_values_action = fallback_field_type.empty() ? DIRTY_VALUES::REJECT : DIRTY_VALUES::COERCE_OR_REJECT; } return dirty_values_action; diff --git a/src/collection_manager.cpp b/src/collection_manager.cpp index 3d96c6cd..9be6c2e7 100644 --- a/src/collection_manager.cpp +++ b/src/collection_manager.cpp @@ -38,9 +38,9 @@ Collection* CollectionManager::init_collection(const nlohmann::json & collection collection_meta[Collection::COLLECTION_NUM_MEMORY_SHARDS].get() : DEFAULT_NUM_MEMORY_SHARDS; - std::string auto_detect_schema = collection_meta.count(Collection::COLLECTION_AUTO_DETECT_SCHEMA) != 0 ? - collection_meta[Collection::COLLECTION_AUTO_DETECT_SCHEMA].get() : - schema_detect_types::OFF; + std::string fallback_field_type = collection_meta.count(Collection::COLLECTION_FALLBACK_FIELD_TYPE) != 0 ? + collection_meta[Collection::COLLECTION_FALLBACK_FIELD_TYPE].get() : + ""; LOG(INFO) << "Found collection " << this_collection_name << " with " << num_memory_shards << " memory shards."; @@ -53,7 +53,7 @@ Collection* CollectionManager::init_collection(const nlohmann::json & collection default_sorting_field, num_memory_shards, max_memory_ratio, - auto_detect_schema); + fallback_field_type); return collection; } @@ -315,13 +315,21 @@ Option CollectionManager::create_collection(const std::string& name const std::vector & fields, const std::string& default_sorting_field, const uint64_t created_at, - const std::string& auto_detect_schema) { + const std::string& fallback_field_type) { std::unique_lock lock(mutex); if(store->contains(Collection::get_meta_key(name))) { return Option(409, std::string("A collection with name `") + name + "` already exists."); } + // validated `fallback_field_type` + if(!fallback_field_type.empty()) { + field fallback_field_type_def("temp", fallback_field_type, false); + if(!fallback_field_type_def.has_valid_type()) { + return Option(400, std::string("Field `*` has an invalid type.")); + } + } + nlohmann::json fields_json = nlohmann::json::array();; Option fields_json_op = field::fields_to_json_fields(fields, default_sorting_field, fields_json); @@ -337,11 +345,11 @@ Option CollectionManager::create_collection(const std::string& name collection_meta[Collection::COLLECTION_DEFAULT_SORTING_FIELD_KEY] = default_sorting_field; collection_meta[Collection::COLLECTION_CREATED] = created_at; collection_meta[Collection::COLLECTION_NUM_MEMORY_SHARDS] = num_memory_shards; - collection_meta[Collection::COLLECTION_AUTO_DETECT_SCHEMA] = auto_detect_schema; + collection_meta[Collection::COLLECTION_FALLBACK_FIELD_TYPE] = fallback_field_type; Collection* new_collection = new Collection(name, next_collection_id, created_at, 0, store, fields, default_sorting_field, num_memory_shards, - this->max_memory_ratio, auto_detect_schema); + this->max_memory_ratio, fallback_field_type); next_collection_id++; rocksdb::WriteBatch batch; @@ -835,3 +843,21 @@ nlohmann::json CollectionManager::get_collection_summaries() const { return json_summaries; } + +Option CollectionManager::create_collection(nlohmann::json& req_json, + const size_t num_memory_shards, + const std::string& default_sorting_field) { + std::string fallback_field_type; + std::vector fields; + auto parse_op = field::json_fields_to_fields(req_json["fields"], fallback_field_type, fields); + + if(!parse_op.ok()) { + return Option(parse_op.code(), parse_op.error()); + } + + const auto created_at = static_cast(std::time(nullptr)); + + return CollectionManager::get_instance().create_collection(req_json["name"], num_memory_shards, + fields, default_sorting_field, created_at, + fallback_field_type); +} diff --git a/src/core_api.cpp b/src/core_api.cpp index f47cc9c3..b3bacb08 100644 --- a/src/core_api.cpp +++ b/src/core_api.cpp @@ -121,7 +121,8 @@ bool post_create_collection(http_req & req, http_res & res) { return false; } - if(req_json[NUM_MEMORY_SHARDS].get() == 0) { + size_t num_memory_shards = req_json[NUM_MEMORY_SHARDS].get(); + if(num_memory_shards == 0) { res.set_400(std::string("`") + NUM_MEMORY_SHARDS + "` should be a positive integer."); return false; } @@ -139,9 +140,9 @@ bool post_create_collection(http_req & req, http_res & res) { return false; } - std::string auto_detect_schema = schema_detect_types::OFF; + std::string fallback_field_type; std::vector fields; - auto parse_op = field::json_fields_to_fields(req_json["fields"], auto_detect_schema, fields); + auto parse_op = field::json_fields_to_fields(req_json["fields"], fallback_field_type, fields); if(!parse_op.ok()) { res.set(parse_op.code(), parse_op.error()); @@ -149,11 +150,8 @@ bool post_create_collection(http_req & req, http_res & res) { } const std::string & default_sorting_field = req_json[DEFAULT_SORTING_FIELD].get(); - const auto created_at = static_cast(std::time(nullptr)); - const Option & collection_op = - collectionManager.create_collection(req_json["name"], req_json[NUM_MEMORY_SHARDS].get(), - fields, default_sorting_field, created_at, auto_detect_schema); + collectionManager.create_collection(req_json, num_memory_shards, default_sorting_field); if(collection_op.ok()) { nlohmann::json json_response = collection_op.get()->get_summary_json(); diff --git a/src/index.cpp b/src/index.cpp index 525f5de1..41922b93 100644 --- a/src/index.cpp +++ b/src/index.cpp @@ -273,7 +273,7 @@ Option Index::validate_index_in_memory(nlohmann::json& document, uint3 const std::unordered_map & search_schema, const std::map & facet_schema, bool is_update, - const std::string& auto_detect_schema, + const std::string& fallback_field_type, const DIRTY_VALUES& dirty_values) { bool missing_default_sort_field = (!default_sorting_field.empty() && document.count(default_sorting_field) == 0); @@ -300,7 +300,7 @@ Option Index::validate_index_in_memory(nlohmann::json& document, uint3 bool array_ele_erased = false; if(a_field.type == field_types::STRING && !document[field_name].is_string()) { - Option coerce_op = coerce_string(dirty_values, auto_detect_schema, a_field, document, field_name, dummy_iter, false, array_ele_erased); + Option coerce_op = coerce_string(dirty_values, fallback_field_type, a_field, document, field_name, dummy_iter, false, array_ele_erased); if(!coerce_op.ok()) { return coerce_op; } @@ -353,7 +353,7 @@ Option Index::validate_index_in_memory(nlohmann::json& document, uint3 array_ele_erased = false; if (a_field.type == field_types::STRING_ARRAY && !item.is_string()) { - Option coerce_op = coerce_string(dirty_values, auto_detect_schema, a_field, document, field_name, it, true, array_ele_erased); + Option coerce_op = coerce_string(dirty_values, fallback_field_type, a_field, document, field_name, it, true, array_ele_erased); if (!coerce_op.ok()) { return coerce_op; } @@ -470,7 +470,7 @@ size_t Index::batch_memory_index(Index *index, std::vector & iter_ const std::string & default_sorting_field, const std::unordered_map & search_schema, const std::map & facet_schema, - const std::string& auto_detect_schema) { + const std::string& fallback_field_type) { size_t num_indexed = 0; @@ -485,7 +485,7 @@ size_t Index::batch_memory_index(Index *index, std::vector & iter_ default_sorting_field, search_schema, facet_schema, index_rec.is_update, - auto_detect_schema, + fallback_field_type, index_rec.dirty_values); if(!validation_op.ok()) { @@ -2399,7 +2399,7 @@ void Index::refresh_schemas(const std::vector& new_fields) { } } -Option Index::coerce_string(const DIRTY_VALUES& dirty_values, const std::string& auto_detect_schema, +Option Index::coerce_string(const DIRTY_VALUES& dirty_values, const std::string& fallback_field_type, const field& a_field, nlohmann::json &document, const std::string &field_name, nlohmann::json::iterator& array_iter, bool is_array, bool& array_ele_erased) { diff --git a/test/collection_all_fields_test.cpp b/test/collection_all_fields_test.cpp index 1f592e6c..7798005f 100644 --- a/test/collection_all_fields_test.cpp +++ b/test/collection_all_fields_test.cpp @@ -42,9 +42,14 @@ TEST_F(CollectionAllFieldsTest, IndexDocsWithoutSchema) { std::vector sort_fields = { sort_by("points", "DESC") }; + // try to create collection with random fallback field type + auto bad_coll_op = collectionManager.create_collection("coll_bad", 1, fields, "", 0, "blah"); + ASSERT_FALSE(bad_coll_op.ok()); + ASSERT_EQ("Field `*` has an invalid type.", bad_coll_op.error()); + coll1 = collectionManager.get_collection("coll1").get(); if(coll1 == nullptr) { - auto coll_op = collectionManager.create_collection("coll1", 1, fields, "", 0, schema_detect_types::AUTO); + auto coll_op = collectionManager.create_collection("coll1", 1, fields, "", 0, field_types::AUTO); coll1 = coll_op.get(); } @@ -167,7 +172,7 @@ TEST_F(CollectionAllFieldsTest, HandleArrayTypes) { coll1 = collectionManager.get_collection("coll1").get(); if(coll1 == nullptr) { - coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, schema_detect_types::AUTO).get(); + coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, field_types::AUTO).get(); } nlohmann::json doc; @@ -255,7 +260,7 @@ TEST_F(CollectionAllFieldsTest, ShouldBeAbleToUpdateSchemaDetectedDocs) { coll1 = collectionManager.get_collection("coll1").get(); if (coll1 == nullptr) { - coll1 = collectionManager.create_collection("coll1", 4, fields, "", 0, schema_detect_types::AUTO).get(); + coll1 = collectionManager.create_collection("coll1", 4, fields, "", 0, field_types::AUTO).get(); } nlohmann::json doc; @@ -337,7 +342,7 @@ TEST_F(CollectionAllFieldsTest, StringifyAllValues) { coll1 = collectionManager.get_collection("coll1").get(); if (coll1 == nullptr) { - coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, schema_detect_types::STRINGIFY).get(); + coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, "string*").get(); } nlohmann::json doc; @@ -420,12 +425,44 @@ TEST_F(CollectionAllFieldsTest, StringifyAllValues) { collectionManager.drop_collection("coll1"); } +TEST_F(CollectionAllFieldsTest, StringSingularAllValues) { + Collection *coll1; + + coll1 = collectionManager.get_collection("coll1").get(); + if (coll1 == nullptr) { + coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, "string").get(); + } + + nlohmann::json doc; + doc["title"] = "FIRST"; + doc["int_values"] = {1, 2}; + + Option add_op = coll1->add(doc.dump(), CREATE, "0"); + ASSERT_FALSE(add_op.ok()); + ASSERT_EQ("Field `int_values` must be a string.", add_op.error()); + + doc["int_values"] = 123; + + add_op = coll1->add(doc.dump(), CREATE, "0"); + ASSERT_TRUE(add_op.ok()); + + auto added_doc = add_op.get(); + + ASSERT_EQ("FIRST", added_doc["title"].get()); + ASSERT_EQ("123", added_doc["int_values"].get()); + + auto results = coll1->search("first", {"title"}, "", {}, sort_fields, 0, 10, 1, FREQUENCY, false).get(); + ASSERT_EQ(1, results["hits"].size()); + ASSERT_EQ("FIRST", results["hits"][0]["document"]["title"].get()); + ASSERT_EQ("123", results["hits"][0]["document"]["int_values"].get()); +} + TEST_F(CollectionAllFieldsTest, UpdateOfDocumentsInAutoMode) { Collection *coll1; coll1 = collectionManager.get_collection("coll1").get(); if (coll1 == nullptr) { - coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, schema_detect_types::AUTO).get(); + coll1 = collectionManager.create_collection("coll1", 1, {}, "", 0, field_types::AUTO).get(); } nlohmann::json doc; @@ -449,32 +486,32 @@ TEST_F(CollectionAllFieldsTest, JsonFieldsToFieldsConversion) { nlohmann::json fields_json = nlohmann::json::array(); nlohmann::json all_field; all_field[fields::name] = "*"; - all_field[fields::type] = "stringify"; + all_field[fields::type] = "string*"; fields_json.emplace_back(all_field); - std::string auto_detect_schema; + std::string fallback_field_type; std::vector fields; - auto parse_op = field::json_fields_to_fields(fields_json, auto_detect_schema, fields); + auto parse_op = field::json_fields_to_fields(fields_json, fallback_field_type, fields); ASSERT_TRUE(parse_op.ok()); ASSERT_EQ(1, fields.size()); - ASSERT_EQ("stringify", auto_detect_schema); + ASSERT_EQ("string*", fallback_field_type); ASSERT_EQ(true, fields[0].optional); ASSERT_EQ(false, fields[0].facet); ASSERT_EQ("*", fields[0].name); - ASSERT_EQ("stringify", fields[0].type); + ASSERT_EQ("string*", fields[0].type); // reject when you try to set optional to false or facet to true fields_json[0][fields::optional] = false; - parse_op = field::json_fields_to_fields(fields_json, auto_detect_schema, fields); + parse_op = field::json_fields_to_fields(fields_json, fallback_field_type, fields); ASSERT_FALSE(parse_op.ok()); ASSERT_EQ("Field `*` must be an optional field.", parse_op.error()); fields_json[0][fields::optional] = true; fields_json[0][fields::facet] = true; - parse_op = field::json_fields_to_fields(fields_json, auto_detect_schema, fields); + parse_op = field::json_fields_to_fields(fields_json, fallback_field_type, fields); ASSERT_FALSE(parse_op.ok()); ASSERT_EQ("Field `*` cannot be a facet field.", parse_op.error()); @@ -484,7 +521,7 @@ TEST_F(CollectionAllFieldsTest, JsonFieldsToFieldsConversion) { // can have only one "*" field fields_json.emplace_back(all_field); - parse_op = field::json_fields_to_fields(fields_json, auto_detect_schema, fields); + parse_op = field::json_fields_to_fields(fields_json, fallback_field_type, fields); ASSERT_FALSE(parse_op.ok()); ASSERT_EQ("There can be only one field named `*`.", parse_op.error()); @@ -495,7 +532,7 @@ TEST_F(CollectionAllFieldsTest, JsonFieldsToFieldsConversion) { all_field[fields::type] = "auto"; fields_json.emplace_back(all_field); - parse_op = field::json_fields_to_fields(fields_json, auto_detect_schema, fields); + parse_op = field::json_fields_to_fields(fields_json, fallback_field_type, fields); ASSERT_TRUE(parse_op.ok()); ASSERT_EQ("auto", fields[0].type); } diff --git a/test/collection_manager_test.cpp b/test/collection_manager_test.cpp index 636bcf2e..9c637509 100644 --- a/test/collection_manager_test.cpp +++ b/test/collection_manager_test.cpp @@ -82,7 +82,7 @@ TEST_F(CollectionManagerTest, CollectionCreation) { ASSERT_EQ(3, num_keys); // we already call `collection1->get_next_seq_id` above, which is side-effecting ASSERT_EQ(1, StringUtils::deserialize_uint32_t(next_seq_id)); - ASSERT_EQ("{\"auto_detect_schema\":\"off\",\"created_at\":12345,\"default_sorting_field\":\"points\"," + ASSERT_EQ("{\"created_at\":12345,\"default_sorting_field\":\"points\",\"fallback_field_type\":\"\"," "\"fields\":[{\"facet\":false,\"name\":\"title\",\"optional\":false,\"type\":\"string\"}," "{\"facet\":false,\"name\":\"starring\",\"optional\":false,\"type\":\"string\"}," "{\"facet\":true,\"name\":\"cast\",\"optional\":true,\"type\":\"string[]\"}," @@ -288,7 +288,7 @@ TEST_F(CollectionManagerTest, RestoreAutoSchemaDocsOnRestart) { coll1 = collectionManager.get_collection("coll1").get(); if(coll1 == nullptr) { - coll1 = collectionManager.create_collection("coll1", 1, fields, "max", 0, schema_detect_types::AUTO).get(); + coll1 = collectionManager.create_collection("coll1", 1, fields, "max", 0, field_types::AUTO).get(); } std::string json_line;