diff --git a/openmetadata-integration-tests/src/test/java/org/openmetadata/it/bootstrap/TestSuiteBootstrap.java b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/bootstrap/TestSuiteBootstrap.java index 0c90c0053ac0..5ada3bac86d1 100644 --- a/openmetadata-integration-tests/src/test/java/org/openmetadata/it/bootstrap/TestSuiteBootstrap.java +++ b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/bootstrap/TestSuiteBootstrap.java @@ -42,6 +42,7 @@ import org.jdbi.v3.sqlobject.SqlObjects; import org.junit.platform.launcher.LauncherSession; import org.junit.platform.launcher.LauncherSessionListener; +import org.openmetadata.it.server.SearchTestImages; import org.openmetadata.it.util.SdkClients; import org.openmetadata.schema.api.configuration.pipelineServiceClient.Parameters; import org.openmetadata.schema.api.configuration.pipelineServiceClient.PipelineServiceClientConfiguration; @@ -350,7 +351,8 @@ private void startSearch() { LOG.info("Starting OpenSearch container with image: {}", image); org.opensearch.testcontainers.OpensearchContainer opensearch = - new org.opensearch.testcontainers.OpensearchContainer<>(image); + new org.opensearch.testcontainers.OpensearchContainer<>( + SearchTestImages.openSearchWithAnalysisPlugins(image)); opensearch.withEnv("discovery.type", "single-node"); opensearch.withEnv("DISABLE_SECURITY_PLUGIN", "true"); opensearch.withEnv("DISABLE_INSTALL_DEMO_CONFIG", "true"); diff --git a/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/ContainerizedServer.java b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/ContainerizedServer.java index ae8eb888189d..6054be132abd 100644 --- a/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/ContainerizedServer.java +++ b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/ContainerizedServer.java @@ -224,7 +224,8 @@ private static MySQLContainer newMysql(final Network network) { } private static OpensearchContainer newOpenSearch(final Network network) { - return new OpensearchContainer<>("opensearchproject/opensearch:3.4.0") + return new OpensearchContainer<>( + SearchTestImages.openSearchWithAnalysisPlugins("opensearchproject/opensearch:3.4.0")) .withNetwork(network) .withNetworkAliases(SEARCH_ALIAS) .withEnv("discovery.type", "single-node") diff --git a/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/SearchTestImages.java b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/SearchTestImages.java new file mode 100644 index 000000000000..4ebc3544816c --- /dev/null +++ b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/server/SearchTestImages.java @@ -0,0 +1,49 @@ +package org.openmetadata.it.server; + +import org.testcontainers.images.builder.ImageFromDockerfile; +import org.testcontainers.utility.DockerImageName; + +/** + * Builds the OpenSearch test image with the language-analysis plugins baked in, so the integration + * tests can exercise every non-English mapping language: {@code analysis-kuromoji} for Japanese and + * {@code analysis-ik} ({@code ik_max_word}/{@code ik_smart}) for Chinese. + * + *

The plugins are installed unconditionally: a run that only uses the English mappings never + * references them, while a run configured for {@code jp}/{@code zh} can create indexes whose text + * fields use those analyzers. This is what lets the search IT suite catch per-language + * mapping/analyzer drift — the jp mappings referencing undefined analyzers went unnoticed precisely + * because CI only ever ran English on a vanilla image. + * + *

{@code analysis-ik} is third-party and ships only as a version-matched release URL; the URL is + * derived from the base image tag so it always matches the OpenSearch version being tested. + */ +public final class SearchTestImages { + + private static final String OPENSEARCH_BASE_REFERENCE = "opensearchproject/opensearch"; + private static final String PLUGIN_INSTALL = + "/usr/share/opensearch/bin/opensearch-plugin install --batch "; + private static final String IK_PLUGIN_URL_TEMPLATE = + "https://release.infinilabs.com/analysis-ik/stable/opensearch-analysis-ik-%s.zip"; + + private SearchTestImages() {} + + /** + * Returns a {@link DockerImageName} for {@code baseImage} with the analysis plugins installed. The + * image is built once per run and reused via Docker's layer cache. + */ + public static DockerImageName openSearchWithAnalysisPlugins(String baseImage) { + String version = baseImage.substring(baseImage.lastIndexOf(':') + 1); + String ikPluginUrl = String.format(IK_PLUGIN_URL_TEMPLATE, version); + String builtImage = + new ImageFromDockerfile() + .withDockerfileFromBuilder( + builder -> + builder + .from(baseImage) + .run(PLUGIN_INSTALL + "analysis-kuromoji") + .run(PLUGIN_INSTALL + ikPluginUrl) + .build()) + .get(); + return DockerImageName.parse(builtImage).asCompatibleSubstituteFor(OPENSEARCH_BASE_REFERENCE); + } +} diff --git a/openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/SearchConsumerFieldBehaviorIT.java b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/SearchConsumerFieldBehaviorIT.java new file mode 100644 index 000000000000..7ab60fda9a11 --- /dev/null +++ b/openmetadata-integration-tests/src/test/java/org/openmetadata/it/tests/SearchConsumerFieldBehaviorIT.java @@ -0,0 +1,582 @@ +package org.openmetadata.it.tests; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import org.apache.hc.core5.http.HttpHost; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.TestInstance; +import org.openmetadata.it.server.SearchTestImages; +import org.openmetadata.schema.type.IndexMappingLanguage; +import org.openmetadata.service.search.opensearch.OsUtils; +import org.opensearch.testcontainers.OpensearchContainer; +import org.testcontainers.junit.jupiter.Container; +import org.testcontainers.junit.jupiter.Testcontainers; +import os.org.opensearch.client.json.jackson.JacksonJsonpMapper; +import os.org.opensearch.client.opensearch.OpenSearchClient; +import os.org.opensearch.client.opensearch.generic.Requests; +import os.org.opensearch.client.transport.httpclient5.ApacheHttpClient5Transport; +import os.org.opensearch.client.transport.httpclient5.ApacheHttpClient5TransportBuilder; + +/** + * Behavioral, per-language guard for the search "consumer contract": rather than asserting a + * mapping declares a field, this indexes a real document into the actual index mapping for + * every supported language ({@code en/jp/ru/zh}) and then runs the actual search / filter / + * aggregation each product feature relies on, asserting it returns the document. A failure is + * reported as a broken feature in a specific language (e.g. "Domain filter is broken in + * [jp]"), which is what an operator can act on — not "index is missing a mapping". + * + *

This is the search-side coverage the suite lacked for non-English languages — without running + * the whole integration-test suite once per language. The container is built with the + * language-analysis plugins ({@link SearchTestImages}), so every language indexes with its + * real analyzers (jp uses {@code kuromoji_tokenizer} via analysis-kuromoji, zh uses {@code + * ik_max_word}/{@code ik_smart} via analysis-ik). Creating the real mappings here therefore also + * catches analyzer drift — e.g. fields referencing analyzers the mapping never defined. + * + *

It would have caught the {@code jp/topic} mapping dropping top-level {@code domains} (the + * domain-filter assertion returns zero hits for {@code jp}) and the jp analyzer references that made + * jp indexes uncreatable. The query types mirror real consumers: a nested query for {@code owners} + * (RBAC isOwner), term filters for tags/tier/certification/domains (Explore facets, RBAC, Data + * Quality), a terms aggregation for {@code testCaseResult.testCaseStatus} (the Data Quality + * execution summary), and a keyword term on {@code fqnParts} (hierarchical search / autocomplete). + * + *

Coverage spans the Explore/RBAC fields on a data-asset index (topic) plus the Data Quality + * test-case index — status aggregation, the nested {@code testSuites.id} filter, the {@code + * entityLink.nonNormalized} per-entity summary aggregation, and the dimension/platform filters — and + * the Incident Manager resolution-status index — status type, assignee, and the {@code + * testCase.fullyQualifiedName.keyword}/{@code testCase.entityFQN.keyword} filters. + */ +@Testcontainers +@TestInstance(TestInstance.Lifecycle.PER_CLASS) +class SearchConsumerFieldBehaviorIT { + + // Discovered from the schema-defined language registry (IndexMappingLanguage) that the loader + // itself uses to pick a per-language mapping file, so a newly added language is exercised + // automatically — and a declared language with no mapping files fails fast in createIndex. + private static final List LANGUAGES = + Arrays.stream(IndexMappingLanguage.values()) + .map(language -> language.toString().toLowerCase(Locale.ROOT)) + .toList(); + + private static final String TAG_FQN = "PII.Sensitive"; + private static final String TIER_FQN = "Tier.Tier1"; + private static final String CERTIFICATION_FQN = "Certification.Gold"; + private static final String DOMAIN_FQN = "Finance"; + private static final String FQN_PART = "svc.ns"; + private static final String OWNER_ID = "11111111-1111-1111-1111-111111111111"; + private static final String DOMAIN_ID = "22222222-2222-2222-2222-222222222222"; + private static final String TOPIC_ID = "33333333-3333-3333-3333-333333333333"; + private static final String TOPIC_FQN = "svc.ns.orders"; + private static final String TEST_CASE_ID = "44444444-4444-4444-4444-444444444444"; + private static final String TEST_CASE_FQN = "svc.ns.orders.columns.amount.notNull"; + private static final String TEST_CASE_STATUS = "Success"; + private static final String ENTITY_FQN = "svc.ns.orders"; + private static final String ENTITY_LINK = "<#E::table::svc.ns.orders>"; + private static final String DQ_DIMENSION = "Completeness"; + private static final String TEST_PLATFORM = "DBT"; + private static final String TEST_SUITE_ID = "55555555-5555-5555-5555-555555555555"; + private static final String RESOLUTION_ID = "66666666-6666-6666-6666-666666666666"; + private static final String RESOLUTION_STATUS_TYPE = "Assigned"; + private static final String ASSIGNEE_ID = "77777777-7777-7777-7777-777777777777"; + private static final String ASSIGNEE_NAME = "john"; + private static final String STATE_ID = "88888888-8888-8888-8888-888888888888"; + + // Native-script sample text per language plus a token its analyzer must produce. + // Keyword/identifier + // fields are language-neutral and never exercise the text analyzers; this is the only check that + // the per-language analyzers actually work — the reason the per-language mappings exist at all. + // jp/zh require kuromoji/IK to segment CJK (the plain standard analyzer splits it into single + // characters, never the 2-char tokens 東京 / 销售); ru requires the Russian stemmer (продажи -> + // продаж); en is the latin baseline. + private static final Map LANGUAGE_SAMPLE_TEXT = + Map.of( + "en", new String[] {"Monthly revenue report", "revenue"}, + "ru", new String[] {"Ежемесячные продажи", "продаж"}, + "jp", new String[] {"東京タワーの売上", "東京"}, + "zh", new String[] {"北京大学的销售报表", "销售"}); + + @Container + static OpensearchContainer opensearch = + new OpensearchContainer<>( + SearchTestImages.openSearchWithAnalysisPlugins("opensearchproject/opensearch:3.4.0")) + .withStartupTimeout(Duration.ofMinutes(5)) + .withEnv("discovery.type", "single-node") + .withEnv("OPENSEARCH_INITIAL_ADMIN_PASSWORD", "Test@12345") + .withEnv("DISABLE_SECURITY_PLUGIN", "true") + .withEnv("DISABLE_INSTALL_DEMO_CONFIG", "true") + .withEnv("OPENSEARCH_JAVA_OPTS", "-Xms512m -Xmx512m"); + + private OpenSearchClient openSearchClient; + private ObjectMapper mapper; + + @BeforeAll + void setUp() throws Exception { + HttpHost httpHost = new HttpHost("http", opensearch.getHost(), opensearch.getMappedPort(9200)); + ApacheHttpClient5Transport transport = + ApacheHttpClient5TransportBuilder.builder(httpHost) + .setMapper(new JacksonJsonpMapper()) + .build(); + openSearchClient = new OpenSearchClient(transport); + mapper = new ObjectMapper(); + + for (String language : LANGUAGES) { + createIndex(topicIndex(language), "/elasticsearch/" + language + "/topic_index_mapping.json"); + indexDocument(topicIndex(language), TOPIC_ID, topicDocument()); + createIndex( + testCaseIndex(language), "/elasticsearch/" + language + "/test_case_index_mapping.json"); + indexDocument(testCaseIndex(language), TEST_CASE_ID, testCaseDocument()); + createIndex( + resolutionIndex(language), + "/elasticsearch/" + language + "/test_case_resolution_status_index_mapping.json"); + indexDocument(resolutionIndex(language), RESOLUTION_ID, resolutionStatusDocument()); + } + } + + @AfterAll + void tearDown() throws Exception { + if (openSearchClient != null) { + openSearchClient._transport().close(); + } + } + + @Test + void tagFilterReturnsAssetInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Tag filter (Explore tag facet, Data Quality tag filter, RBAC tag rules)", + language -> hits(topicIndex(language), termQuery("tags.tagFQN", TAG_FQN)) == 1); + } + + @Test + void tierAggregationHasBucketInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Tier aggregation (Explore tier facet, Data Quality tier widget)", + language -> + aggregationHasBucket( + topicIndex(language), termsAggregation("tier", "tier.tagFQN"), "tier", TIER_FQN)); + } + + @Test + void certificationFilterReturnsAssetInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Certification filter (Explore + Data Quality certification filter, RBAC certification)", + language -> + hits( + topicIndex(language), + termQuery("certification.tagLabel.tagFQN", CERTIFICATION_FQN)) + == 1); + } + + @Test + void ownerNestedRbacQueryReturnsAssetInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Owner RBAC nested query (isOwner access control, owners facet)", + language -> + hits(topicIndex(language), nestedTermQuery("owners", "owners.id", OWNER_ID)) == 1); + } + + @Test + void domainFilterReturnsAssetInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Domain filter (RBAC hasDomain, Data Quality/Incident domain filter, domain asset counts)", + language -> + hits(topicIndex(language), termQuery("domains.fullyQualifiedName", DOMAIN_FQN)) == 1); + } + + @Test + void fqnPartsTermReturnsAssetInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Hierarchical search / autocomplete (fqnParts)", + language -> hits(topicIndex(language), termQuery("fqnParts", FQN_PART)) == 1); + } + + @Test + void dataQualityStatusAggregationHasBucketInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Data Quality status aggregation (Test Suite execution summary, DQ status filter)", + language -> + aggregationHasBucket( + testCaseIndex(language), + termsAggregation("status", "testCaseResult.testCaseStatus"), + "status", + TEST_CASE_STATUS)); + } + + @Test + void testSuiteNestedFilterReturnsTestCaseInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Test suite filter (Data Quality test list + execution summary; nested testSuites.id)", + language -> + hits( + testCaseIndex(language), + nestedTermQuery("testSuites", "testSuites.id", TEST_SUITE_ID)) + == 1); + } + + @Test + void entityLinkSummaryAggregationHasBucketInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Data Quality per-entity execution summary (entityLink.nonNormalized aggregation)", + language -> + aggregationHasBucket( + testCaseIndex(language), + termsAggregation("links", "entityLink.nonNormalized"), + "links", + ENTITY_LINK)); + } + + @Test + void dataQualityDimensionFilterReturnsTestCaseInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Data Quality dimension filter (test list + DQ report by dimension)", + language -> + hits(testCaseIndex(language), termQuery("dataQualityDimension", DQ_DIMENSION)) == 1); + } + + @Test + void testPlatformFilterReturnsTestCaseInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Test platform filter (Data Quality test list)", + language -> hits(testCaseIndex(language), termQuery("testPlatforms", TEST_PLATFORM)) == 1); + } + + @Test + void incidentStatusFilterReturnsIncidentInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Incident Manager status filter (testCaseResolutionStatusType)", + language -> + hits( + resolutionIndex(language), + termQuery("testCaseResolutionStatusType", RESOLUTION_STATUS_TYPE)) + == 1); + } + + @Test + void incidentAssigneeFilterReturnsIncidentInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Incident Manager assignee filter (testCaseResolutionStatusDetails.assignee.name)", + language -> + hits( + resolutionIndex(language), + termQuery("testCaseResolutionStatusDetails.assignee.name", ASSIGNEE_NAME)) + == 1); + } + + @Test + void incidentTestCaseFqnFilterReturnsIncidentInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Incident Manager test-case filter (testCase.fullyQualifiedName.keyword)", + language -> + hits( + resolutionIndex(language), + termQuery("testCase.fullyQualifiedName.keyword", TEST_CASE_FQN)) + == 1); + } + + @Test + void incidentOriginEntityFilterReturnsIncidentInAllLanguages() throws Exception { + assertFeatureWorksInAllLanguages( + "Incident Manager origin-entity filter (testCase.entityFQN.keyword)", + language -> + hits(resolutionIndex(language), termQuery("testCase.entityFQN.keyword", ENTITY_FQN)) + == 1); + } + + @Test + void analysisPluginsInstalled() throws Exception { + try (var response = + openSearchClient + .generic() + .execute(Requests.builder().method("GET").endpoint("/_cat/plugins").build())) { + String plugins = response.getBody().map(b -> b.bodyAsString()).orElse(""); + assertTrue( + plugins.contains("analysis-kuromoji") && plugins.contains("analysis-ik"), + "The integration-test OpenSearch image must ship analysis-kuromoji (jp) and analysis-ik " + + "(zh) so jp/zh mappings index with their real analyzers. Installed: " + + plugins); + } + } + + @Test + void languageAnalyzerSegmentsNativeTextInEachLanguage() throws Exception { + List broken = new ArrayList<>(); + for (Map.Entry entry : LANGUAGE_SAMPLE_TEXT.entrySet()) { + String language = entry.getKey(); + String text = entry.getValue()[0]; + String expectedToken = entry.getValue()[1]; + List tokens = analyzeField(topicIndex(language), "description", text); + if (!tokens.contains(expectedToken)) { + broken.add(language + " expected token '" + expectedToken + "' but got " + tokens); + } + } + assertTrue( + broken.isEmpty(), + "The per-language text analyzer did not segment native-script text into the expected token " + + "— full-text search in that language is broken: " + + broken); + } + + @FunctionalInterface + private interface LanguageProbe { + boolean passes(String language) throws Exception; + } + + private void assertFeatureWorksInAllLanguages(String feature, LanguageProbe probe) + throws Exception { + List broken = new ArrayList<>(); + for (String language : LANGUAGES) { + if (!probe.passes(language)) { + broken.add(language); + } + } + assertTrue( + broken.isEmpty(), + feature + + " is broken in language(s): " + + broken + + ". The search/filter/aggregation this feature relies on did not return the indexed " + + "asset for those languages — the index mapping or analyzer for that language does not " + + "support the query (missing field, wrong type, or wrong analyzer)."); + } + + private int hits(String index, String queryBody) throws Exception { + return runSearch(index, queryBody).path("hits").path("hits").size(); + } + + /** + * Whether an aggregation produced a bucket for {@code expected}, compared case-insensitively. A + * keyword field may carry {@code lowercase_normalizer} (e.g. {@code testCaseResult.testCaseStatus} + * in every language, {@code tier.tagFQN} in en only), which lowercases the stored value and hence + * the bucket key; the feature still works — a bucket exists for our asset — so either case passes. + * A missing field or value produces no bucket at all and still fails the assertion. + */ + private boolean aggregationHasBucket( + String index, String aggBody, String aggName, String expected) throws Exception { + for (String key : bucketKeys(index, aggBody, aggName)) { + if (key.equalsIgnoreCase(expected)) { + return true; + } + } + return false; + } + + private List bucketKeys(String index, String aggBody, String aggName) throws Exception { + List keys = new ArrayList<>(); + JsonNode buckets = runSearch(index, aggBody).path("aggregations").path(aggName).path("buckets"); + for (JsonNode bucket : buckets) { + keys.add(bucket.path("key").asText()); + } + return keys; + } + + private List analyzeField(String index, String field, String text) throws Exception { + String body = mapper.writeValueAsString(Map.of("field", field, "text", text)); + try (var response = + openSearchClient + .generic() + .execute( + Requests.builder() + .method("POST") + .endpoint("/" + index + "/_analyze") + .json(body) + .build())) { + JsonNode tokens = + mapper + .readTree(response.getBody().map(b -> b.bodyAsString()).orElse("{}")) + .path("tokens"); + List result = new ArrayList<>(); + for (JsonNode token : tokens) { + result.add(token.path("token").asText()); + } + return result; + } + } + + private JsonNode runSearch(String index, String body) throws Exception { + try (var response = + openSearchClient + .generic() + .execute( + Requests.builder() + .method("POST") + .endpoint("/" + index + "/_search") + .json(body) + .build())) { + String raw = response.getBody().map(b -> b.bodyAsString()).orElse("{}"); + return mapper.readTree(raw); + } + } + + private void createIndex(String index, String mappingResource) throws Exception { + String rawMapping; + try (InputStream in = getClass().getResourceAsStream(mappingResource)) { + assertNotNull(in, "Mapping resource not found on classpath: " + mappingResource); + rawMapping = new String(in.readAllBytes(), StandardCharsets.UTF_8); + } + String enriched = OsUtils.enrichIndexMappingForOpenSearch(rawMapping); + try (var response = + openSearchClient + .generic() + .execute( + Requests.builder().method("PUT").endpoint("/" + index).json(enriched).build())) { + if (response.getStatus() >= 400) { + throw new IOException( + "Failed to create index " + + index + + ": " + + response.getBody().map(b -> b.bodyAsString()).orElse("no body")); + } + } + } + + private void indexDocument(String index, String id, String document) throws Exception { + try (var response = + openSearchClient + .generic() + .execute( + Requests.builder() + .method("PUT") + .endpoint("/" + index + "/_doc/" + id + "?refresh=true") + .json(document) + .build())) { + if (response.getStatus() >= 400) { + throw new IOException( + "Failed to index document into " + + index + + ": " + + response.getBody().map(b -> b.bodyAsString()).orElse("no body")); + } + } + } + + private String topicDocument() throws Exception { + Map document = + Map.ofEntries( + Map.entry("id", TOPIC_ID), + Map.entry("name", "orders"), + Map.entry("displayName", "Orders"), + Map.entry("fullyQualifiedName", TOPIC_FQN), + Map.entry("deleted", false), + Map.entry("entityType", "topic"), + Map.entry("fqnParts", List.of("svc", "ns", FQN_PART)), + Map.entry("tags", List.of(tagLabel(TAG_FQN))), + Map.entry("tier", tagLabel(TIER_FQN)), + Map.entry("certification", Map.of("tagLabel", Map.of("tagFQN", CERTIFICATION_FQN))), + Map.entry("owners", List.of(Map.of("id", OWNER_ID, "type", "user", "name", "alice"))), + Map.entry( + "domains", + List.of( + Map.of( + "id", + DOMAIN_ID, + "type", + "domain", + "name", + DOMAIN_FQN, + "fullyQualifiedName", + DOMAIN_FQN)))); + return mapper.writeValueAsString(document); + } + + private String testCaseDocument() throws Exception { + Map document = + Map.ofEntries( + Map.entry("id", TEST_CASE_ID), + Map.entry("name", "amount_not_null"), + Map.entry("fullyQualifiedName", TEST_CASE_FQN), + Map.entry("deleted", false), + Map.entry("entityType", "testCase"), + Map.entry("entityFQN", ENTITY_FQN), + Map.entry("originEntityFQN", ENTITY_FQN), + Map.entry("entityLink", ENTITY_LINK), + Map.entry("dataQualityDimension", DQ_DIMENSION), + Map.entry("testPlatforms", List.of(TEST_PLATFORM)), + Map.entry( + "testSuites", + List.of( + Map.of( + "id", + TEST_SUITE_ID, + "name", + "suite", + "fullyQualifiedName", + TEST_CASE_FQN + ".suite"))), + Map.entry( + "testCaseResult", + Map.of("testCaseStatus", TEST_CASE_STATUS, "timestamp", 1700000000000L))); + return mapper.writeValueAsString(document); + } + + private String resolutionStatusDocument() throws Exception { + Map document = + Map.ofEntries( + Map.entry("id", RESOLUTION_ID), + Map.entry("entityType", "testCaseResolutionStatus"), + Map.entry("testCaseResolutionStatusType", RESOLUTION_STATUS_TYPE), + Map.entry( + "testCaseResolutionStatusDetails", + Map.of( + "assignee", Map.of("id", ASSIGNEE_ID, "type", "user", "name", ASSIGNEE_NAME))), + Map.entry( + "testCase", + Map.of( + "name", + "amount_not_null", + "fullyQualifiedName", + TEST_CASE_FQN, + "entityFQN", + ENTITY_FQN)), + Map.entry("stateId", STATE_ID), + Map.entry("@timestamp", 1700000000000L), + Map.entry("timestamp", 1700000000000L)); + return mapper.writeValueAsString(document); + } + + private Map tagLabel(String tagFqn) { + return Map.of( + "tagFQN", tagFqn, + "labelType", "Manual", + "source", "Classification", + "state", "Confirmed"); + } + + private String termQuery(String field, String value) throws Exception { + return mapper.writeValueAsString(Map.of("query", Map.of("term", Map.of(field, value)))); + } + + private String nestedTermQuery(String path, String field, String value) throws Exception { + return mapper.writeValueAsString( + Map.of( + "query", + Map.of("nested", Map.of("path", path, "query", Map.of("term", Map.of(field, value)))))); + } + + private String termsAggregation(String aggName, String field) throws Exception { + return mapper.writeValueAsString( + Map.of("size", 0, "aggs", Map.of(aggName, Map.of("terms", Map.of("field", field))))); + } + + private String topicIndex(String language) { + return "behavior_topic_" + language; + } + + private String testCaseIndex(String language) { + return "behavior_testcase_" + language; + } + + private String resolutionIndex(String language) { + return "behavior_resolution_" + language; + } +} diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/apps/bundles/searchIndex/SearchIndexApp.java b/openmetadata-service/src/main/java/org/openmetadata/service/apps/bundles/searchIndex/SearchIndexApp.java index 7122574a3c97..89a8af8d418e 100644 --- a/openmetadata-service/src/main/java/org/openmetadata/service/apps/bundles/searchIndex/SearchIndexApp.java +++ b/openmetadata-service/src/main/java/org/openmetadata/service/apps/bundles/searchIndex/SearchIndexApp.java @@ -1,8 +1,12 @@ package org.openmetadata.service.apps.bundles.searchIndex; +import static org.openmetadata.common.utils.CommonUtil.nullOrEmpty; + import jakarta.ws.rs.core.Response; +import java.util.Collection; import java.util.List; import java.util.Map; +import java.util.Set; import lombok.Getter; import lombok.extern.slf4j.Slf4j; import org.openmetadata.schema.entity.app.App; @@ -15,6 +19,7 @@ import org.openmetadata.service.exception.AppException; import org.openmetadata.service.jdbi3.AppRepository; import org.openmetadata.service.jdbi3.CollectionDAO; +import org.openmetadata.service.search.IndexMappingVersionTracker; import org.openmetadata.service.search.SearchRepository; import org.quartz.JobExecutionContext; @@ -63,6 +68,24 @@ public void execute(JobExecutionContext ctx) { this.orchestrator = orch; orch.run(jobData); this.jobData = orch.getJobData(); + stampReindexedMappings(this.jobData); + } + + private void stampReindexedMappings(EventPublisherJob job) { + if (job != null && job.getStatus() == EventPublisherJob.Status.COMPLETED) { + Set targeted = job.getEntities(); + Collection toStamp = + (nullOrEmpty(targeted) || targeted.contains(SearchIndexEntityTypes.ALL)) + ? searchRepository.getEntityIndexMap().keySet() + : targeted; + try { + String version = System.getProperty("project.version", "1.8.0-SNAPSHOT"); + new IndexMappingVersionTracker(collectionDAO, version, "system") + .updateMappingVersions(toStamp); + } catch (Exception e) { + LOG.warn("Failed to stamp index mapping versions after reindex", e); + } + } } @Override diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/SystemRepository.java b/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/SystemRepository.java index 5cfc44dd2ceb..bb7c8de152b0 100644 --- a/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/SystemRepository.java +++ b/openmetadata-service/src/main/java/org/openmetadata/service/jdbi3/SystemRepository.java @@ -18,10 +18,12 @@ import jakarta.json.JsonValue; import jakarta.ws.rs.core.Response; import java.util.ArrayList; +import java.util.Collections; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Optional; +import java.util.Set; import java.util.UUID; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -66,6 +68,7 @@ import org.openmetadata.schema.utils.JsonUtils; import org.openmetadata.schema.utils.ResultList; import org.openmetadata.sdk.PipelineServiceClientInterface; +import org.openmetadata.search.IndexMapping; import org.openmetadata.service.Entity; import org.openmetadata.service.OpenMetadataApplicationConfig; import org.openmetadata.service.exception.CustomExceptionMessage; @@ -77,6 +80,8 @@ import org.openmetadata.service.logstorage.LogStorageInterface; import org.openmetadata.service.migration.MigrationValidationClient; import org.openmetadata.service.resources.settings.SettingsCache; +import org.openmetadata.service.search.IndexMappingVersionTracker; +import org.openmetadata.service.search.IndexMappingVersionTracker.MappingDriftState; import org.openmetadata.service.search.SearchRepository; import org.openmetadata.service.search.vector.client.EmbeddingClient; import org.openmetadata.service.secrets.SecretsManager; @@ -108,6 +113,7 @@ public class SystemRepository { private static final String FAILED_TO_UPDATE_SETTINGS = "Failed to Update Settings {}"; public static final String INTERNAL_SERVER_ERROR_WITH_REASON = "Internal Server Error. Reason :"; private static final String VECTOR_EMBEDDING_INDEX_KEY = "vectorEmbedding"; + private static final String REINDEX_STATUS_VALIDATION_KEY = "Search Reindex Status"; private final SystemDAO dao; private final MigrationValidationClient migrationValidationClient; @@ -116,7 +122,10 @@ private enum ValidationStepDescription { SEARCH("Validate that the search client is available."), PIPELINE_SERVICE_CLIENT("Validate that the pipeline service client is available."), JWT_TOKEN("Validate that the ingestion-bot JWT token can be properly decoded."), - MIGRATION("Validate that all the necessary migrations have been properly executed."); + MIGRATION("Validate that all the necessary migrations have been properly executed."), + SEARCH_REINDEX( + "Validate that every deployed search index was built from the current code mapping " + + "(i.e. no reindex is pending)."); public final String key; @@ -555,6 +564,8 @@ public ValidationResponse validateSystem( "Semantic Search", getEmbeddingsValidation(applicationConfig)); } + validation.setAdditionalProperty(REINDEX_STATUS_VALIDATION_KEY, getReindexStatusValidation()); + addExtraValidations(applicationConfig, validation); return validation; @@ -837,14 +848,53 @@ private StepValidation getSearchValidation(OpenMetadataApplicationConfig applica } } + public record ReindexStatus(List stalePending, int untrackedCount) {} + + static ReindexStatus classifyReindexStatus( + Map drift, Set existingIndexes) { + List stalePending = new ArrayList<>(); + int untrackedCount = 0; + for (Map.Entry entry : drift.entrySet()) { + if (existingIndexes.contains(entry.getKey())) { + if (entry.getValue() == MappingDriftState.STALE) { + stalePending.add(entry.getKey()); + } else if (entry.getValue() == MappingDriftState.UNTRACKED) { + untrackedCount++; + } + } + } + Collections.sort(stalePending); + return new ReindexStatus(stalePending, untrackedCount); + } + + static String buildReindexStatusMessage(ReindexStatus status) { + String message; + if (status.stalePending().isEmpty()) { + message = "All deployed indexes were built from the current code mappings."; + if (status.untrackedCount() > 0) { + message += + String.format( + " %d index(es) are not yet version-tracked; run a reindex to enable drift " + + "detection.", + status.untrackedCount()); + } + } else { + message = + String.format( + "WARNING: %d deployed index(es) were built from an older code mapping and need a " + + "reindex: %s", + status.stalePending().size(), status.stalePending()); + } + return message; + } + @VisibleForTesting List findMissingIndexes(SearchRepository searchRepository) { List missing = new ArrayList<>(); boolean semanticSearchEnabled = searchRepository.isVectorEmbeddingEnabled(); try { - Map indexMap = - searchRepository.getEntityIndexMap(); - for (Map.Entry entry : indexMap.entrySet()) { + Map indexMap = searchRepository.getEntityIndexMap(); + for (Map.Entry entry : indexMap.entrySet()) { if (!semanticSearchEnabled && VECTOR_EMBEDDING_INDEX_KEY.equals(entry.getKey())) { continue; } @@ -858,6 +908,38 @@ List findMissingIndexes(SearchRepository searchRepository) { return missing; } + private StepValidation getReindexStatusValidation() { + StepValidation step = + new StepValidation().withDescription(ValidationStepDescription.SEARCH_REINDEX.key); + SearchRepository searchRepository = Entity.getSearchRepository(); + StepValidation result; + if (searchRepository.getSearchClient().isClientAvailable()) { + ReindexStatus status = computeReindexStatus(searchRepository); + result = + step.withPassed(status.stalePending().isEmpty()) + .withMessage(buildReindexStatusMessage(status)); + } else { + result = + step.withPassed(Boolean.TRUE).withMessage("Skipped: search instance is not reachable."); + } + return result; + } + + private ReindexStatus computeReindexStatus(SearchRepository searchRepository) { + ReindexStatus status = new ReindexStatus(new ArrayList<>(), 0); + try { + String version = System.getProperty("project.version", "1.8.0-SNAPSHOT"); + IndexMappingVersionTracker tracker = + new IndexMappingVersionTracker(Entity.getCollectionDAO(), version, "system"); + Set existingIndexes = new HashSet<>(searchRepository.getEntityIndexMap().keySet()); + existingIndexes.removeAll(findMissingIndexes(searchRepository)); + status = classifyReindexStatus(tracker.computeDrift(), existingIndexes); + } catch (Exception e) { + LOG.warn("Failed to compute search reindex status: {}", e.getMessage()); + } + return status; + } + private boolean validateDataInsights() { boolean isValid = false; diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/search/IndexMappingVersionTracker.java b/openmetadata-service/src/main/java/org/openmetadata/service/search/IndexMappingVersionTracker.java index a2971f802642..98a402fde324 100644 --- a/openmetadata-service/src/main/java/org/openmetadata/service/search/IndexMappingVersionTracker.java +++ b/openmetadata-service/src/main/java/org/openmetadata/service/search/IndexMappingVersionTracker.java @@ -7,9 +7,12 @@ import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Objects; import lombok.extern.slf4j.Slf4j; import org.openmetadata.schema.utils.JsonUtils; import org.openmetadata.search.IndexMapping; @@ -32,6 +35,12 @@ public IndexMappingVersionTracker(CollectionDAO daoCollection, String version, S this.updatedBy = updatedBy; } + public enum MappingDriftState { + CURRENT, + STALE, + UNTRACKED + } + public List getChangedMappings() throws IOException { List changedMappings = new ArrayList<>(); Map storedHashes = getStoredMappingHashes(); @@ -57,23 +66,58 @@ public List getChangedMappings() throws IOException { return changedMappings; } + public Map computeDrift() throws IOException { + Map storedHashes = getStoredMappingHashes(); + Map currentMappings = computeCurrentMappings(); + Map drift = new HashMap<>(); + for (Map.Entry entry : currentMappings.entrySet()) { + String storedHash = storedHashes.get(entry.getKey()); + drift.put(entry.getKey(), classifyState(storedHash, entry.getValue().hash())); + } + return Collections.unmodifiableMap(drift); + } + + private MappingDriftState classifyState(String storedHash, String currentHash) { + MappingDriftState state; + if (storedHash == null) { + state = MappingDriftState.UNTRACKED; + } else if (Objects.equals(storedHash, currentHash)) { + state = MappingDriftState.CURRENT; + } else { + state = MappingDriftState.STALE; + } + return state; + } + public void updateMappingVersions() throws IOException { + stamp(computeCurrentMappings()); + } + + public void updateMappingVersions(Collection entityTypes) throws IOException { Map currentMappings = computeCurrentMappings(); - long updatedAt = System.currentTimeMillis(); + Map subset = new HashMap<>(); + for (String entityType : entityTypes) { + MappingEntry mappingEntry = currentMappings.get(entityType); + if (mappingEntry != null) { + subset.put(entityType, mappingEntry); + } + } + stamp(subset); + } - for (Map.Entry entry : currentMappings.entrySet()) { - String entityType = entry.getKey(); + private void stamp(Map mappings) { + long updatedAt = System.currentTimeMillis(); + for (Map.Entry entry : mappings.entrySet()) { MappingEntry mappingEntry = entry.getValue(); - indexMappingVersionDAO.upsertIndexMappingVersion( - entityType, + entry.getKey(), mappingEntry.hash(), JsonUtils.pojoToJson(mappingEntry.json()), version, updatedAt, updatedBy); } - LOG.info("Updated index mapping versions for {} entities", currentMappings.size()); + LOG.info("Updated index mapping versions for {} entities", mappings.size()); } private Map getStoredMappingHashes() { diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchConsumerFields.java b/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchConsumerFields.java new file mode 100644 index 000000000000..b80fa2b8a286 --- /dev/null +++ b/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchConsumerFields.java @@ -0,0 +1,104 @@ +/* + * Copyright 2024 Collate. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.openmetadata.service.search; + +import java.util.List; +import java.util.Set; + +/** + * Single source of truth for the denormalized search-index fields that product features beyond + * Explore depend on. RBAC, Data Quality, Incident Manager, Lineage, and Data Insights all query + * these fields directly, so renaming, retyping, or dropping one of them in a mapping silently + * breaks those consumers (empty facets, wrong access-control results, zeroed Data Quality widgets) + * with no compile-time or boot-time failure. + * + *

{@code SearchConsumerFieldContractTest} references this class so the contract lives in one + * place: it fails CI when a shipped mapping file renames, retypes, or drops one of these fields. + * (Deployed-index staleness is covered separately by {@code SystemRepository}'s "Search Reindex + * Status" check, which compares mapping hashes rather than these specific fields.) + */ +public final class SearchConsumerFields { + private SearchConsumerFields() {} + + /** + * A denormalized leaf field and the type it must keep. Validated "where present" — a mapping that + * does not define the path is out of scope (e.g. {@code testCaseResult.testCaseStatus} exists + * only on the test-case indexes). Catches the dangerous silent break: a retype (keyword to text) + * that kills the aggregations, sorts, and term filters every consumer builds on these fields. + */ + public record ConsumerField(String path, String expectedType, String consumers) {} + + public static final List TYPED_LEAF_FIELDS = + List.of( + new ConsumerField( + "tags.tagFQN", + "keyword", + "RBAC tag rules, Explore tag facet, Data Quality tag filter, column-lineage tags"), + new ConsumerField( + "tier.tagFQN", + "keyword", + "RBAC Tier rules, Explore tier facet, Data Quality tier widgets, Data Insights tier"), + new ConsumerField( + "certification.tagLabel.tagFQN", + "keyword", + "RBAC certification rules, Explore and Data Quality certification filters"), + new ConsumerField( + "classificationTags", "keyword", "Explore classification facet, tag aggregations"), + new ConsumerField("glossaryTags", "keyword", "Explore glossary facet, tag aggregations"), + new ConsumerField( + "domains.fullyQualifiedName", + "keyword", + "RBAC domain rules, Data Quality and Incident domain filters, domain asset counts"), + new ConsumerField( + "fqnParts", "keyword", "Search autocomplete/suggest, hierarchical search"), + new ConsumerField( + "testCaseResult.testCaseStatus", + "keyword", + "Test Suite execution summary, Data Quality status filter"), + new ConsumerField( + "testCaseResolutionStatusType", + "keyword", + "Incident Manager listing and aggregations")); + + /** + * Core data-asset entity types verified to expose the full denormalized field set at the top + * level. Used as a canary: the shared doc-builder pipeline writes these fields into every data + * asset, so if it drops one it drops from all of these at once. {@code table} is intentionally + * excluded — its static mapping does not declare {@code fqnParts} top-level (it is dynamically + * mapped), which would be a false positive for that one field. + */ + public static final Set CANARY_DATA_ASSET_ENTITIES = + Set.of( + "dashboard", + "pipeline", + "topic", + "container", + "mlmodel", + "dashboardDataModel", + "searchIndex", + "apiEndpoint", + "metric", + "chart"); + + /** Top-level denormalized fields every {@link #CANARY_DATA_ASSET_ENTITIES} index must expose. */ + public static final Set CANARY_REQUIRED_TOP_LEVEL_FIELDS = + Set.of( + "fqnParts", + "tier", + "tags", + "owners", + "domains", + "certification", + "classificationTags", + "glossaryTags"); +} diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchRepository.java b/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchRepository.java index 64cbaebd28d7..4ccb3ccf21a9 100644 --- a/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchRepository.java +++ b/openmetadata-service/src/main/java/org/openmetadata/service/search/SearchRepository.java @@ -308,6 +308,7 @@ public void createIndexes() { RecreateIndexHandler recreateIndexHandler = this.createReindexHandler(); ReindexContext context = recreateIndexHandler.reCreateIndexes(entityIndexMap.keySet()); if (context != null) { + List recreated = new ArrayList<>(); for (String entityType : context.getEntities()) { try { String originalIndex = context.getOriginalIndex(entityType).orElse(null); @@ -331,11 +332,24 @@ public void createIndexes() { .parentAliases(parentAliases) .build(); recreateIndexHandler.finalizeReindex(entityReindexContext, true); - + recreated.add(entityType); } catch (Exception ex) { LOG.error("Failed to recreate index for entity {}", entityType, ex); } } + stampRecreatedMappings(recreated); + } + } + + protected void stampRecreatedMappings(List entityTypes) { + if (!nullOrEmpty(entityTypes)) { + try { + String version = System.getProperty("project.version", "1.8.0-SNAPSHOT"); + new IndexMappingVersionTracker(Entity.getCollectionDAO(), version, "system") + .updateMappingVersions(entityTypes); + } catch (Exception e) { + LOG.warn("Failed to stamp index mapping versions after createIndexes: {}", e.getMessage()); + } } } diff --git a/openmetadata-service/src/main/java/org/openmetadata/service/util/OpenMetadataOperations.java b/openmetadata-service/src/main/java/org/openmetadata/service/util/OpenMetadataOperations.java index 352d75497199..8fe2a2076652 100644 --- a/openmetadata-service/src/main/java/org/openmetadata/service/util/OpenMetadataOperations.java +++ b/openmetadata-service/src/main/java/org/openmetadata/service/util/OpenMetadataOperations.java @@ -1790,7 +1790,6 @@ private int executeSearchReindexApp( // Check for index mapping changes only when running from CLI IndexMappingVersionTracker versionTracker = null; - boolean shouldUpdateVersions = false; ReindexingProgressMonitor progressMonitor = null; boolean shouldReindex = true; @@ -1820,8 +1819,6 @@ private int executeSearchReindexApp( } } } else { - shouldUpdateVersions = true; - // If 'all' entities were requested, only reindex changed ones if (entities.contains("all")) { entities = new HashSet<>(changedMappings); @@ -1833,7 +1830,6 @@ private int executeSearchReindexApp( LOG.info( "✅ Smart reindexing: None of the requested entities have mapping changes, skipping reindex"); shouldReindex = false; - shouldUpdateVersions = false; // Send Slack notification if configured if (slackBotToken != null @@ -1917,18 +1913,6 @@ private int executeSearchReindexApp( int result = waitAndReturnReindexingAppStatus(app, currentTime, progressMonitor); - // Update mapping versions after successful reindexing - if (result == 0 && shouldUpdateVersions && versionTracker != null) { - try { - versionTracker.updateMappingVersions(); - LOG.info( - "✅ Smart reindexing: Updated mapping versions in database for future change detection"); - } catch (Exception e) { - LOG.warn("⚠️ Failed to update index mapping versions in database", e); - // Don't fail the operation if version update fails - } - } - return result; } diff --git a/openmetadata-service/src/test/java/org/openmetadata/service/jdbi3/SystemRepositoryReindexStatusTest.java b/openmetadata-service/src/test/java/org/openmetadata/service/jdbi3/SystemRepositoryReindexStatusTest.java new file mode 100644 index 000000000000..a07feaec15b8 --- /dev/null +++ b/openmetadata-service/src/test/java/org/openmetadata/service/jdbi3/SystemRepositoryReindexStatusTest.java @@ -0,0 +1,87 @@ +/* + * Copyright 2024 Collate. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.openmetadata.service.jdbi3; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.Map; +import java.util.Set; +import org.junit.jupiter.api.Test; +import org.openmetadata.service.jdbi3.SystemRepository.ReindexStatus; +import org.openmetadata.service.search.IndexMappingVersionTracker.MappingDriftState; + +class SystemRepositoryReindexStatusTest { + + @Test + void staleEntityWithLiveIndexIsReportedPending() { + Map drift = Map.of("table", MappingDriftState.STALE); + ReindexStatus status = SystemRepository.classifyReindexStatus(drift, Set.of("table")); + assertEquals(1, status.stalePending().size()); + assertTrue(status.stalePending().contains("table")); + } + + @Test + void missingIndexIsSkippedSoItIsNotDoubleReported() { + Map drift = Map.of("table", MappingDriftState.STALE); + ReindexStatus status = SystemRepository.classifyReindexStatus(drift, Set.of()); + assertTrue(status.stalePending().isEmpty()); + assertEquals(0, status.untrackedCount()); + } + + @Test + void untrackedEntityWithLiveIndexIsNotedNotFailed() { + Map drift = Map.of("table", MappingDriftState.UNTRACKED); + ReindexStatus status = SystemRepository.classifyReindexStatus(drift, Set.of("table")); + assertTrue(status.stalePending().isEmpty()); + assertEquals(1, status.untrackedCount()); + } + + @Test + void currentEntityProducesNoFinding() { + Map drift = Map.of("table", MappingDriftState.CURRENT); + ReindexStatus status = SystemRepository.classifyReindexStatus(drift, Set.of("table")); + assertTrue(status.stalePending().isEmpty()); + assertEquals(0, status.untrackedCount()); + } + + @Test + void messageListsStalePendingEntities() { + ReindexStatus status = new ReindexStatus(List.of("dashboard", "table"), 0); + String message = SystemRepository.buildReindexStatusMessage(status); + assertTrue(message.contains("dashboard")); + assertTrue(message.contains("table")); + assertTrue(message.toLowerCase().contains("reindex")); + } + + @Test + void cleanMessageMentionsUntrackedNote() { + ReindexStatus status = new ReindexStatus(List.of(), 3); + String message = SystemRepository.buildReindexStatusMessage(status); + assertTrue(message.contains("3")); + assertTrue(message.toLowerCase().contains("version-tracked")); + } + + @Test + void stalePendingIsReturnedInSortedOrder() { + Map drift = + Map.of( + "topic", MappingDriftState.STALE, + "chart", MappingDriftState.STALE, + "dashboard", MappingDriftState.STALE); + ReindexStatus status = + SystemRepository.classifyReindexStatus(drift, Set.of("topic", "chart", "dashboard")); + assertEquals(List.of("chart", "dashboard", "topic"), status.stalePending()); + } +} diff --git a/openmetadata-service/src/test/java/org/openmetadata/service/search/IndexMappingVersionTrackerTest.java b/openmetadata-service/src/test/java/org/openmetadata/service/search/IndexMappingVersionTrackerTest.java index d936e8f792a4..3f29dffd09c3 100644 --- a/openmetadata-service/src/test/java/org/openmetadata/service/search/IndexMappingVersionTrackerTest.java +++ b/openmetadata-service/src/test/java/org/openmetadata/service/search/IndexMappingVersionTrackerTest.java @@ -416,6 +416,76 @@ void hashesAreStableAcrossMultipleComputations() throws IOException { } } + @Test + void computeDriftClassifiesCurrentStaleAndUntracked() throws IOException { + Map mappings = + buildMappingsFromPairs( + "table", "/elasticsearch/%s/table_index_mapping.json", + "glossaryTerm", "/elasticsearch/%s/glossary_term_index_mapping.json", + "domain", "/elasticsearch/%s/domain_index_mapping.json"); + try (var loaderMock = mockStatic(IndexMappingLoader.class)) { + loaderMock.when(IndexMappingLoader::getInstance).thenReturn(indexMappingLoader); + when(indexMappingLoader.getIndexMapping()).thenReturn(mappings); + + IndexMappingVersionTracker tracker = + new IndexMappingVersionTracker(collectionDAO, "1.2.3", "tester"); + + // Stamp all, capture table's real hash to mark it CURRENT. + tracker.updateMappingVersions(); + verify(indexMappingVersionDAO, times(3)) + .upsertIndexMappingVersion( + entityTypeCaptor.capture(), + hashCaptor.capture(), + anyString(), + anyString(), + anyLong(), + anyString()); + Map realHashes = new HashMap<>(); + for (int i = 0; i < entityTypeCaptor.getAllValues().size(); i++) { + realHashes.put(entityTypeCaptor.getAllValues().get(i), hashCaptor.getAllValues().get(i)); + } + + // table = current hash, glossaryTerm = stale hash, domain = not stored (untracked). + when(indexMappingVersionDAO.getAllMappingVersions()) + .thenReturn( + List.of( + new IndexMappingVersionDAO.IndexMappingVersion("table", realHashes.get("table")), + new IndexMappingVersionDAO.IndexMappingVersion("glossaryTerm", "stale-hash"))); + + Map drift = tracker.computeDrift(); + + assertEquals(IndexMappingVersionTracker.MappingDriftState.CURRENT, drift.get("table")); + assertEquals(IndexMappingVersionTracker.MappingDriftState.STALE, drift.get("glossaryTerm")); + assertEquals(IndexMappingVersionTracker.MappingDriftState.UNTRACKED, drift.get("domain")); + } + } + + @Test + void updateMappingVersionsForSubsetStampsOnlyGivenEntities() throws IOException { + Map mappings = + buildMappingsFromPairs( + "table", "/elasticsearch/%s/table_index_mapping.json", + "glossaryTerm", "/elasticsearch/%s/glossary_term_index_mapping.json", + "domain", "/elasticsearch/%s/domain_index_mapping.json"); + try (var loaderMock = mockStatic(IndexMappingLoader.class)) { + loaderMock.when(IndexMappingLoader::getInstance).thenReturn(indexMappingLoader); + when(indexMappingLoader.getIndexMapping()).thenReturn(mappings); + + new IndexMappingVersionTracker(collectionDAO, "1.2.3", "tester") + .updateMappingVersions(List.of("table", "domain")); + + verify(indexMappingVersionDAO, times(2)) + .upsertIndexMappingVersion( + entityTypeCaptor.capture(), + anyString(), + anyString(), + eq("1.2.3"), + anyLong(), + eq("tester")); + assertEquals(Set.of("domain", "table"), new TreeSet<>(entityTypeCaptor.getAllValues())); + } + } + private static Set diff(Set expected, Set actual) { Set missing = new TreeSet<>(expected); missing.removeAll(actual); diff --git a/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchConsumerFieldContractTest.java b/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchConsumerFieldContractTest.java new file mode 100644 index 000000000000..03e9f8d0e973 --- /dev/null +++ b/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchConsumerFieldContractTest.java @@ -0,0 +1,165 @@ +/* + * Copyright 2024 Collate. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * http://www.apache.org/licenses/LICENSE-2.0 + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.openmetadata.service.search; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import com.fasterxml.jackson.databind.JsonNode; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.openmetadata.schema.utils.JsonUtils; +import org.openmetadata.search.IndexMapping; +import org.openmetadata.search.IndexMappingLoader; +import org.openmetadata.service.search.SearchConsumerFields.ConsumerField; + +/** + * Guards the search-index "consumer contract": the denormalized fields that RBAC, Data Quality, + * Incidents, Lineage, and Data Insights query. A mapping change that renames, retypes, or drops one + * of these fields breaks those features silently at runtime — this test turns that into a CI + * failure that names the affected consumers. Source of truth: {@link SearchConsumerFields}. + */ +class SearchConsumerFieldContractTest { + + private static final List LANGUAGES = List.of("en", "jp", "ru", "zh"); + private static Map allMappings; + + @BeforeAll + static void loadAllMappings() throws IOException { + IndexMappingLoader.init(); + IndexMappingLoader loader = IndexMappingLoader.getInstance(); + allMappings = new HashMap<>(); + for (Map.Entry entry : loader.getIndexMapping().entrySet()) { + String entity = entry.getKey(); + IndexMapping indexMapping = entry.getValue(); + for (String language : LANGUAGES) { + String filePath = indexMapping.getIndexMappingFile(language); + try (InputStream in = + SearchConsumerFieldContractTest.class.getClassLoader().getResourceAsStream(filePath)) { + if (in == null) { + continue; + } + String key = entity + "[" + language + "]"; + allMappings.put( + key, JsonUtils.readTree(new String(in.readAllBytes(), StandardCharsets.UTF_8))); + } + } + } + assertTrue(allMappings.size() > 1, "Should load more than one index mapping"); + } + + @Test + void consumerLeafFieldsKeepTheirTypeWherePresent() { + List violations = new ArrayList<>(); + for (Map.Entry entry : allMappings.entrySet()) { + JsonNode properties = topLevelProperties(entry.getValue()); + if (properties == null) { + continue; + } + for (ConsumerField field : SearchConsumerFields.TYPED_LEAF_FIELDS) { + collectTypeViolation(entry.getKey(), properties, field, violations); + } + } + assertTrue( + violations.isEmpty(), + "Search consumer fields changed type. These fields are queried by RBAC, Data Quality, " + + "Incidents, Lineage, and Data Insights; retyping them silently breaks aggregations, " + + "term filters, and access control. Violations:\n" + + String.join("\n", violations)); + } + + @Test + void coreDataAssetIndexesExposeConsumerFields() { + List violations = new ArrayList<>(); + for (Map.Entry entry : allMappings.entrySet()) { + String entity = entry.getKey().substring(0, entry.getKey().indexOf('[')); + if (SearchConsumerFields.CANARY_DATA_ASSET_ENTITIES.contains(entity)) { + collectMissingFieldViolations(entry.getKey(), entry.getValue(), violations); + } + } + assertTrue( + violations.isEmpty(), + "Core data asset indexes are missing denormalized fields that the shared doc-builder " + + "pipeline is expected to write. Dropping these breaks Explore facets, RBAC, Data " + + "Quality, and Data Insights at once. Violations:\n" + + String.join("\n", violations)); + } + + private static void collectTypeViolation( + String mappingKey, JsonNode properties, ConsumerField field, List violations) { + JsonNode node = findField(properties, field.path()); + if (node != null) { + String type = node.path("type").asText(""); + if (!field.expectedType().equals(type)) { + String actual = type.isEmpty() ? "missing \"type\" (implicit object)" : "\"" + type + "\""; + violations.add( + mappingKey + + " " + + field.path() + + ": expected \"" + + field.expectedType() + + "\" but found " + + actual + + " — breaks: " + + field.consumers()); + } + } + } + + private static void collectMissingFieldViolations( + String mappingKey, JsonNode root, List violations) { + JsonNode properties = topLevelProperties(root); + assertNotNull( + properties, + "Index mapping for '" + + mappingKey + + "' has no properties — mapping file may be malformed."); + for (String required : SearchConsumerFields.CANARY_REQUIRED_TOP_LEVEL_FIELDS) { + if (!properties.has(required)) { + violations.add(mappingKey + " missing top-level field \"" + required + "\""); + } + } + } + + private static JsonNode findField(JsonNode rootProperties, String dottedPath) { + String[] segments = dottedPath.split("\\."); + JsonNode properties = rootProperties; + JsonNode found = null; + for (int i = 0; i < segments.length && properties != null && !properties.isMissingNode(); i++) { + JsonNode node = properties.path(segments[i]); + if (node.isMissingNode()) { + properties = null; + } else if (i == segments.length - 1) { + found = node; + } else { + properties = node.path("properties"); + } + } + return found; + } + + private static JsonNode topLevelProperties(JsonNode root) { + JsonNode properties = root.path("mappings").path("properties"); + if (properties.isMissingNode()) { + properties = root.path("properties"); + } + return properties.isMissingNode() ? null : properties; + } +} diff --git a/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchRepositoryBehaviorTest.java b/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchRepositoryBehaviorTest.java index 157b66db76ce..9f22d43e6c76 100644 --- a/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchRepositoryBehaviorTest.java +++ b/openmetadata-service/src/test/java/org/openmetadata/service/search/SearchRepositoryBehaviorTest.java @@ -30,6 +30,7 @@ import java.util.LinkedHashSet; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.UUID; import org.apache.commons.lang3.tuple.Pair; @@ -2116,13 +2117,13 @@ void createIndexesFinalizesEachRecreatedEntityAndContinuesOnFailure() { when(context.getEntities()) .thenReturn(new LinkedHashSet<>(List.of(Entity.TABLE, Entity.DOMAIN))); when(context.getOriginalIndex(any())) - .thenAnswer(invocation -> java.util.Optional.of("original_" + invocation.getArgument(0))); + .thenAnswer(invocation -> Optional.of("original_" + invocation.getArgument(0))); when(context.getCanonicalIndex(any())) - .thenAnswer(invocation -> java.util.Optional.of("canonical_" + invocation.getArgument(0))); + .thenAnswer(invocation -> Optional.of("canonical_" + invocation.getArgument(0))); when(context.getStagedIndex(any())) - .thenAnswer(invocation -> java.util.Optional.of("staged_" + invocation.getArgument(0))); + .thenAnswer(invocation -> Optional.of("staged_" + invocation.getArgument(0))); when(context.getCanonicalAlias(any())) - .thenAnswer(invocation -> java.util.Optional.of("alias_" + invocation.getArgument(0))); + .thenAnswer(invocation -> Optional.of("alias_" + invocation.getArgument(0))); when(context.getExistingAliases(any())) .thenAnswer(invocation -> Set.of("existing_" + invocation.getArgument(0))); when(context.getParentAliases(any())) @@ -2148,6 +2149,43 @@ void createIndexesFinalizesEachRecreatedEntityAndContinuesOnFailure() { assertEquals(Entity.DOMAIN, contextCaptor.getAllValues().get(1).getEntityType()); } + @Test + void createIndexesStampsOnlySucceededEntities() throws Exception { + SearchRepository spyRepository = spy(repository); + RecreateIndexHandler recreateIndexHandler = mock(RecreateIndexHandler.class); + ReindexContext context = mock(ReindexContext.class); + + doReturn(recreateIndexHandler).when(spyRepository).createReindexHandler(); + when(recreateIndexHandler.reCreateIndexes(any())).thenReturn(context); + when(context.getEntities()) + .thenReturn(new LinkedHashSet<>(List.of(Entity.TABLE, Entity.DOMAIN))); + when(context.getOriginalIndex(any())) + .thenAnswer(invocation -> Optional.of("original_" + invocation.getArgument(0))); + when(context.getCanonicalIndex(any())) + .thenAnswer(invocation -> Optional.of("canonical_" + invocation.getArgument(0))); + when(context.getStagedIndex(any())) + .thenAnswer(invocation -> Optional.of("staged_" + invocation.getArgument(0))); + when(context.getCanonicalAlias(any())) + .thenAnswer(invocation -> Optional.of("alias_" + invocation.getArgument(0))); + when(context.getExistingAliases(any())) + .thenAnswer(invocation -> Set.of("existing_" + invocation.getArgument(0))); + when(context.getParentAliases(any())) + .thenAnswer(invocation -> List.of("parent_" + invocation.getArgument(0))); + + doNothing().when(spyRepository).stampRecreatedMappings(any()); + doNothing() + .doThrow(new RuntimeException("boom")) + .when(recreateIndexHandler) + .finalizeReindex(any(EntityReindexContext.class), eq(true)); + + spyRepository.createIndexes(); + + @SuppressWarnings("unchecked") + ArgumentCaptor> stampCaptor = ArgumentCaptor.forClass(List.class); + verify(spyRepository).stampRecreatedMappings(stampCaptor.capture()); + assertEquals(List.of(Entity.TABLE), stampCaptor.getValue()); + } + @Test void deleteEntityIndexRemovesDomainReferencesAndChildren() throws Exception { EntityInterface domain = mockEntity(Entity.DOMAIN, UUID.randomUUID(), "finance"); diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/api_collection_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/api_collection_index_mapping.json index e125214ddc98..381f461a8103 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/api_collection_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/api_collection_index_mapping.json @@ -25,6 +25,16 @@ } }, "analyzer": { + "om_analyzer_jp": { + "type": "custom", + "tokenizer": "kuromoji_tokenizer", + "filter": [ + "kuromoji_baseform", + "kuromoji_part_of_speech", + "kuromoji_number", + "kuromoji_stemmer" + ] + }, "om_analyzer": { "tokenizer": "standard", "filter": [ @@ -152,7 +162,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/api_endpoint_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/api_endpoint_index_mapping.json index e6e25cde8a52..c26670395e01 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/api_endpoint_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/api_endpoint_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -545,7 +552,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/api_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/api_service_index_mapping.json index ae015a6cfbf5..efac4df758a7 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/api_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/api_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -196,7 +203,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/chart_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/chart_index_mapping.json index 8d30a8b09c3c..4e033e6b99df 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/chart_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/chart_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -300,7 +307,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -372,7 +380,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/container_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/container_index_mapping.json index 47773e2b845d..4bb708fc119c 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/container_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/container_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -676,7 +683,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_data_model_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_data_model_index_mapping.json index 9386a2da3f47..6f4e95693fa2 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_data_model_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_data_model_index_mapping.json @@ -14,6 +14,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -381,7 +388,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -497,7 +505,8 @@ "normalizer": "lowercase_normalizer" }, "dataModelType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "columns": { "properties": { @@ -567,7 +576,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_index_mapping.json index c6bbeefe036c..6bb820af0032 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_index_mapping.json @@ -14,6 +14,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -437,7 +444,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -616,7 +624,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_service_index_mapping.json index e5eb26c5fdd9..341d03f76880 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/dashboard_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -194,7 +201,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/data_products_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/data_products_index_mapping.json index 8530ac688c0d..8736d528b67c 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/data_products_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/data_products_index_mapping.json @@ -490,7 +490,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/database_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/database_index_mapping.json index 4e8543cfc103..05ac8de4ca21 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/database_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/database_index_mapping.json @@ -158,7 +158,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/database_schema_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/database_schema_index_mapping.json index cbf44c10cd80..01fe29b83e96 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/database_schema_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/database_schema_index_mapping.json @@ -485,7 +485,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/database_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/database_service_index_mapping.json index 6630bfec621d..53f0fb4ece0f 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/database_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/database_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -196,7 +203,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/directory_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/directory_index_mapping.json index 9a377c7b800a..16d1c914d4b6 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/directory_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/directory_index_mapping.json @@ -192,7 +192,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -467,7 +468,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/domain_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/domain_index_mapping.json index 144848c8a900..11f630ca222d 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/domain_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/domain_index_mapping.json @@ -14,6 +14,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -234,7 +241,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/drive_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/drive_service_index_mapping.json index b469241dab49..eb64a1d10dc2 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/drive_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/drive_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -191,7 +198,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/file_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/file_index_mapping.json index e3d1746cd9ca..db954269dc3f 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/file_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/file_index_mapping.json @@ -207,7 +207,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -482,7 +483,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_index_mapping.json index b9687fb48ef8..6a8ea9f5b6da 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_index_mapping.json @@ -14,6 +14,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -305,7 +312,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_term_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_term_index_mapping.json index 5e52a1f95c08..12c9f33db446 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_term_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/glossary_term_index_mapping.json @@ -14,6 +14,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -283,7 +290,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -456,7 +464,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/ingestion_pipeline_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/ingestion_pipeline_index_mapping.json index 6e8b2131e907..08802496e153 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/ingestion_pipeline_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/ingestion_pipeline_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -260,7 +267,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -307,7 +315,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -358,7 +367,8 @@ } }, "pipelineType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "pipelineStatuses": { "properties": { diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/messaging_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/messaging_service_index_mapping.json index 7c2ee7bd0c9c..be7a64981a73 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/messaging_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/messaging_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -195,7 +202,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/metadata_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/metadata_service_index_mapping.json index 7a612ff31b91..60647d81dd9c 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/metadata_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/metadata_service_index_mapping.json @@ -200,7 +200,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/metric_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/metric_index_mapping.json index 082fa1201e6e..261ff300f3a6 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/metric_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/metric_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -423,7 +430,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_index_mapping.json index b98478bf0eea..41d2669b01c9 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -622,7 +629,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_service_index_mapping.json index ffea41953286..80968a1daac4 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/mlmodel_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -206,7 +213,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_index_mapping.json index ac62855eb46b..0b4133b35bb2 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -372,7 +379,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -506,7 +514,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_service_index_mapping.json index 98dd8de4aa57..9956e699d570 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/pipeline_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -157,7 +164,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/query_cost_record_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/query_cost_record_index_mapping.json index 227a5dda0b47..da974a232c38 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/query_cost_record_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/query_cost_record_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/query_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/query_index_mapping.json index 22c9bfbff33c..91a7c816cb75 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/query_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/query_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/search_entity_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/search_entity_index_mapping.json index 31247a92daf9..ee486a66dbac 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/search_entity_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/search_entity_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -150,7 +157,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/search_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/search_service_index_mapping.json index ae015a6cfbf5..efac4df758a7 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/search_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/search_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -196,7 +203,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/security_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/security_service_index_mapping.json index 7097ca5cffe9..334ede20a22d 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/security_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/security_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -100,7 +107,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -349,7 +357,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -398,7 +407,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -423,7 +433,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -449,7 +460,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -589,7 +601,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/spreadsheet_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/spreadsheet_index_mapping.json index da38cc093cde..2e2f991eba37 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/spreadsheet_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/spreadsheet_index_mapping.json @@ -192,7 +192,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -467,7 +468,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/storage_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/storage_service_index_mapping.json index 665799638f0d..a6ec278145b9 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/storage_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/storage_service_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -191,7 +198,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/stored_procedure_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/stored_procedure_index_mapping.json index 731bbed20021..7b7200e7bd64 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/stored_procedure_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/stored_procedure_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -559,7 +566,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/table_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/table_index_mapping.json index 3ce2e4559271..bbee140a1edd 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/table_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/table_index_mapping.json @@ -168,7 +168,8 @@ "type": "keyword" }, "tableType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "columns": { "properties": { @@ -856,7 +857,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/tag_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/tag_index_mapping.json index e9d180584a2e..e5a46005bdf5 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/tag_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/tag_index_mapping.json @@ -179,7 +179,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/team_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/team_index_mapping.json index 38ddf70819f3..551f8617c32f 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/team_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/team_index_mapping.json @@ -132,7 +132,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_index_mapping.json index e09604289c2c..2963bfc6198f 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_index_mapping.json @@ -1,6 +1,8 @@ { "settings": { - "index": {}, + "index": { + "max_ngram_diff": 1 + }, "analysis": { "normalizer": { "lowercase_normalizer": { @@ -74,9 +76,6 @@ ] } } - }, - "index": { - "max_ngram_diff": 1 } }, "mappings": { @@ -303,7 +302,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_resolution_status_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_resolution_status_index_mapping.json index c338987dc985..fe00642faa37 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_resolution_status_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_resolution_status_index_mapping.json @@ -587,7 +587,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -757,7 +758,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_result_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_result_index_mapping.json index c3c4796fa655..c808fe84aa93 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_result_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_case_result_index_mapping.json @@ -15,6 +15,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_suite_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_suite_index_mapping.json index c033ef8c1692..4474e4aae062 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/test_suite_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/test_suite_index_mapping.json @@ -1,6 +1,8 @@ { "settings": { - "index": {}, + "index": { + "max_ngram_diff": 1 + }, "analysis": { "normalizer": { "lowercase_normalizer": { @@ -12,6 +14,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -67,9 +76,6 @@ ] } } - }, - "index": { - "max_ngram_diff": 1 } }, "mappings": { @@ -251,7 +257,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/topic_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/topic_index_mapping.json index f0bb7f16a148..44778085e932 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/topic_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/topic_index_mapping.json @@ -11,6 +11,13 @@ } }, "analyzer": { + "om_analyzer": { + "tokenizer": "letter", + "filter": [ + "lowercase", + "om_stemmer" + ] + }, "om_analyzer_jp": { "tokenizer": "kuromoji_tokenizer", "type": "custom", @@ -387,6 +394,53 @@ "type": "text", "analyzer": "om_analyzer" }, + "domains": { + "properties": { + "id": { + "type": "keyword", + "fields": { + "keyword": { + "type": "keyword", + "ignore_above": 36 + } + } + }, + "type": { + "type": "keyword" + }, + "name": { + "type": "keyword", + "fields": { + "keyword": { + "type": "keyword", + "ignore_above": 256 + } + } + }, + "displayName": { + "type": "keyword", + "fields": { + "keyword": { + "type": "keyword", + "normalizer": "lowercase_normalizer", + "ignore_above": 256 + } + } + }, + "fullyQualifiedName": { + "type": "keyword" + }, + "description": { + "type": "text" + }, + "deleted": { + "type": "boolean" + }, + "href": { + "type": "text" + } + } + }, "cleanupPolicies": { "type": "keyword" }, @@ -568,7 +622,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/user_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/user_index_mapping.json index 855c6ce25436..b1bc133e8ce5 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/user_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/user_index_mapping.json @@ -124,7 +124,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/jp/worksheet_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/jp/worksheet_index_mapping.json index e208d6aa8e5d..d0999bfeadd3 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/jp/worksheet_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/jp/worksheet_index_mapping.json @@ -266,7 +266,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -541,7 +542,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/api_collection_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/api_collection_index_mapping.json index 3a6b4292272e..fe40817dbfc4 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/api_collection_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/api_collection_index_mapping.json @@ -187,7 +187,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -269,7 +270,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/api_endpoint_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/api_endpoint_index_mapping.json index 286fa335fb74..03708e6e6952 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/api_endpoint_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/api_endpoint_index_mapping.json @@ -303,7 +303,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -563,7 +564,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/api_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/api_service_index_mapping.json index 3be0ac43516c..676f850aae71 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/api_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/api_service_index_mapping.json @@ -219,7 +219,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -362,7 +363,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/chart_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/chart_index_mapping.json index c753bae4eabd..87fbbc97f2b1 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/chart_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/chart_index_mapping.json @@ -362,7 +362,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -554,7 +555,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/container_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/container_index_mapping.json index 99b8091a736b..48ae62f8524c 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/container_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/container_index_mapping.json @@ -719,7 +719,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_data_model_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_data_model_index_mapping.json index f20daa1fcab5..90c8aa1ac9b5 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_data_model_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_data_model_index_mapping.json @@ -196,7 +196,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -298,7 +299,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_index_mapping.json index a98e727084e8..baa7f13629f5 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_index_mapping.json @@ -471,7 +471,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -649,7 +650,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_service_index_mapping.json index eb32ecf5f194..dc1d7dc458c6 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/dashboard_service_index_mapping.json @@ -208,7 +208,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -361,7 +362,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/data_products_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/data_products_index_mapping.json index ddf3383c1b78..a66771987905 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/data_products_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/data_products_index_mapping.json @@ -321,7 +321,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/database_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/database_index_mapping.json index 28ddf6277ff6..ced4c8d14198 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/database_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/database_index_mapping.json @@ -187,7 +187,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -269,7 +270,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/database_schema_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/database_schema_index_mapping.json index 1c6dc4fd99dd..9f93082a5e3e 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/database_schema_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/database_schema_index_mapping.json @@ -196,7 +196,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -499,7 +500,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/database_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/database_service_index_mapping.json index 5b8b45a1de75..7f560a0ab2b2 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/database_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/database_service_index_mapping.json @@ -219,7 +219,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -365,7 +366,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/directory_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/directory_index_mapping.json index be12a419f4e1..562622b02572 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/directory_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/directory_index_mapping.json @@ -160,7 +160,8 @@ "analyzer": "om_analyzer" }, "serviceType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "service": { "properties": { @@ -175,7 +176,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -197,7 +199,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -224,7 +227,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -237,7 +241,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -307,7 +312,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -320,7 +326,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -360,7 +367,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -384,7 +392,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -403,7 +412,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/domain_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/domain_index_mapping.json index 880557ca73ac..c7947056d53c 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/domain_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/domain_index_mapping.json @@ -302,7 +302,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/drive_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/drive_service_index_mapping.json index 64b9603d1cd9..725b7eefd004 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/drive_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/drive_service_index_mapping.json @@ -280,7 +280,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/file_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/file_index_mapping.json index 7ba08002a671..1d431a82f022 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/file_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/file_index_mapping.json @@ -160,7 +160,8 @@ "analyzer": "om_analyzer" }, "serviceType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "service": { "properties": { @@ -175,7 +176,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -197,7 +199,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -224,7 +227,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -237,7 +241,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -362,7 +367,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -375,7 +381,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -415,7 +422,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -439,7 +447,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -458,7 +467,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_index_mapping.json index 08931778c2ae..b6a1d709adb5 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_index_mapping.json @@ -327,7 +327,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_term_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_term_index_mapping.json index 6779763ead55..7e6338a083fb 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_term_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/glossary_term_index_mapping.json @@ -465,7 +465,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/ingestion_pipeline_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/ingestion_pipeline_index_mapping.json index 38a8601421fe..beb87c5daede 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/ingestion_pipeline_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/ingestion_pipeline_index_mapping.json @@ -335,7 +335,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/messaging_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/messaging_service_index_mapping.json index 4d4360bbd43f..e45b8d30c9f7 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/messaging_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/messaging_service_index_mapping.json @@ -218,7 +218,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -361,7 +362,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/metadata_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/metadata_service_index_mapping.json index 39d7417e8fe7..5f247a5063f9 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/metadata_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/metadata_service_index_mapping.json @@ -263,7 +263,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/metric_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/metric_index_mapping.json index d255839eb1e8..aa31c4db633a 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/metric_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/metric_index_mapping.json @@ -397,7 +397,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_index_mapping.json index 1e0a0a13f43e..ffcef7380738 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_index_mapping.json @@ -313,7 +313,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -639,7 +640,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_service_index_mapping.json index bc3d4d53811e..b9ea4967dbaa 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/mlmodel_service_index_mapping.json @@ -229,7 +229,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -362,7 +363,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_index_mapping.json index 3fbe642d2e72..b8e4506bf020 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_index_mapping.json @@ -196,7 +196,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -542,7 +543,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_service_index_mapping.json index c7a604d4575c..43fb3c6bc553 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/pipeline_service_index_mapping.json @@ -190,7 +190,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -360,7 +361,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/search_entity_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/search_entity_index_mapping.json index a066795f9eb8..9075df50a831 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/search_entity_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/search_entity_index_mapping.json @@ -173,7 +173,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -606,7 +607,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/search_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/search_service_index_mapping.json index 3be0ac43516c..676f850aae71 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/search_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/search_service_index_mapping.json @@ -219,7 +219,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -362,7 +363,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/security_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/security_service_index_mapping.json index a06988289c3f..4998bf197159 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/security_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/security_service_index_mapping.json @@ -293,7 +293,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/spreadsheet_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/spreadsheet_index_mapping.json index 307909569845..5126fbdf8774 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/spreadsheet_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/spreadsheet_index_mapping.json @@ -160,7 +160,8 @@ "analyzer": "om_analyzer" }, "serviceType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "service": { "properties": { @@ -175,7 +176,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -197,7 +199,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -224,7 +227,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -237,7 +241,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -361,7 +366,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -374,7 +380,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -414,7 +421,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -438,7 +446,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -457,7 +466,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/storage_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/storage_service_index_mapping.json index 51fcea9302a0..4a773e192760 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/storage_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/storage_service_index_mapping.json @@ -214,7 +214,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -357,7 +358,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/stored_procedure_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/stored_procedure_index_mapping.json index 37b25ea16527..8ff34d9325df 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/stored_procedure_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/stored_procedure_index_mapping.json @@ -203,7 +203,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -492,7 +493,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/table_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/table_index_mapping.json index 250dd4203077..628ea29ea095 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/table_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/table_index_mapping.json @@ -594,7 +594,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -712,7 +713,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_index_mapping.json index 477674113838..220d520dbe97 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_index_mapping.json @@ -596,7 +596,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_resolution_status_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_resolution_status_index_mapping.json index 38eadd24e585..b1ac9fec5a5a 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_resolution_status_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_resolution_status_index_mapping.json @@ -807,7 +807,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_result_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_result_index_mapping.json index e667feb63890..95d6ff2e7982 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_result_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_case_result_index_mapping.json @@ -337,7 +337,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_suite_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_suite_index_mapping.json index f29f71806cca..bbc2728875a1 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/test_suite_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/test_suite_index_mapping.json @@ -290,7 +290,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/topic_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/topic_index_mapping.json index fbd5ae39dd6f..88606f63358d 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/topic_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/topic_index_mapping.json @@ -259,7 +259,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -475,7 +476,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/ru/worksheet_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/ru/worksheet_index_mapping.json index 4784ac258309..25e61b5a4d23 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/ru/worksheet_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/ru/worksheet_index_mapping.json @@ -160,7 +160,8 @@ "analyzer": "om_analyzer" }, "serviceType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "service": { "properties": { @@ -175,7 +176,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -197,7 +199,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -224,7 +227,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -237,7 +241,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -313,7 +318,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -368,7 +374,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "fullyQualifiedName": { "type": "text" @@ -381,7 +388,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -421,7 +429,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -445,7 +454,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -464,7 +474,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/api_collection_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/api_collection_index_mapping.json index e86da4b52861..8ef7bc9abae4 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/api_collection_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/api_collection_index_mapping.json @@ -164,7 +164,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/api_endpoint_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/api_endpoint_index_mapping.json index 068f66788a37..5379fac29e25 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/api_endpoint_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/api_endpoint_index_mapping.json @@ -540,7 +540,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/api_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/api_service_index_mapping.json index d78a79a5e9d8..03f4bd5e7151 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/api_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/api_service_index_mapping.json @@ -186,7 +186,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/chart_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/chart_index_mapping.json index c250ee0c43d2..4afd9470a412 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/chart_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/chart_index_mapping.json @@ -300,7 +300,8 @@ "type": "keyword", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -372,7 +373,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -564,7 +566,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/container_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/container_index_mapping.json index ed0dd7bbf526..1a6143e92df1 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/container_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/container_index_mapping.json @@ -682,7 +682,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_data_model_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_data_model_index_mapping.json index a74628fddf96..c0f61aad2e07 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_data_model_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_data_model_index_mapping.json @@ -381,7 +381,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -497,7 +498,8 @@ "normalizer": "lowercase_normalizer" }, "dataModelType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "columns": { "properties": { diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_index_mapping.json index 2a0bf0b4ca0a..f1ef5665ca11 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_index_mapping.json @@ -573,7 +573,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_service_index_mapping.json index b8839a092d3d..38e5d72c69af 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/dashboard_service_index_mapping.json @@ -182,7 +182,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/data_products_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/data_products_index_mapping.json index 17f0dc309d3c..f52d9bb5ce3d 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/data_products_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/data_products_index_mapping.json @@ -486,7 +486,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/database_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/database_index_mapping.json index 82b79b92a0cf..da40e43df134 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/database_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/database_index_mapping.json @@ -165,7 +165,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/database_schema_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/database_schema_index_mapping.json index 9b5748f061ee..f038e6e8c5ec 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/database_schema_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/database_schema_index_mapping.json @@ -174,7 +174,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -477,7 +478,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/database_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/database_service_index_mapping.json index 58cd48fb55c8..c34ad186dd41 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/database_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/database_service_index_mapping.json @@ -196,7 +196,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/directory_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/directory_index_mapping.json index 79048659730a..5486da5b4ec0 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/directory_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/directory_index_mapping.json @@ -165,7 +165,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -440,7 +441,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/domain_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/domain_index_mapping.json index 713e3668f894..934264b9bd30 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/domain_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/domain_index_mapping.json @@ -234,7 +234,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/drive_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/drive_service_index_mapping.json index be7c335c69be..d57607c70327 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/drive_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/drive_service_index_mapping.json @@ -168,7 +168,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/file_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/file_index_mapping.json index b59448d76373..9ecd80995724 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/file_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/file_index_mapping.json @@ -180,7 +180,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -455,7 +456,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_index_mapping.json index 4b16d41c17e3..cce5bca11511 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_index_mapping.json @@ -273,7 +273,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_term_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_term_index_mapping.json index dac786d82ed7..ad11ed7b76bf 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_term_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/glossary_term_index_mapping.json @@ -275,7 +275,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, @@ -443,7 +444,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/ingestion_pipeline_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/ingestion_pipeline_index_mapping.json index d93e951a2aa6..924f719f885d 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/ingestion_pipeline_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/ingestion_pipeline_index_mapping.json @@ -312,7 +312,8 @@ "tier": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -365,7 +366,8 @@ } }, "pipelineType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "pipelineStatuses": { "properties": { diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/messaging_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/messaging_service_index_mapping.json index cf49c3bc5287..ea468032a33f 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/messaging_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/messaging_service_index_mapping.json @@ -194,7 +194,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/metadata_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/metadata_service_index_mapping.json index 1efd07403428..9a6c70ce5138 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/metadata_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/metadata_service_index_mapping.json @@ -193,7 +193,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/metric_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/metric_index_mapping.json index 12dc8aaf3fd5..a5f70c9c1fe3 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/metric_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/metric_index_mapping.json @@ -427,7 +427,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_index_mapping.json index 11c8edb1b19c..d26ef24b9b4b 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_index_mapping.json @@ -612,7 +612,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_service_index_mapping.json index 95a597ba8a61..9d7fdf3e9fc9 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/mlmodel_service_index_mapping.json @@ -206,7 +206,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_index_mapping.json index 23c504b3b145..6302fa52f90d 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_index_mapping.json @@ -507,7 +507,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_service_index_mapping.json index 7d7ee6afe986..0a73b34de64c 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/pipeline_service_index_mapping.json @@ -165,7 +165,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/search_entity_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/search_entity_index_mapping.json index 42ff631379d8..ce53111145be 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/search_entity_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/search_entity_index_mapping.json @@ -121,7 +121,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -153,7 +154,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/search_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/search_service_index_mapping.json index d78a79a5e9d8..03f4bd5e7151 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/search_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/search_service_index_mapping.json @@ -186,7 +186,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/security_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/security_service_index_mapping.json index 4815af195e26..71e77aa4ef65 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/security_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/security_service_index_mapping.json @@ -89,7 +89,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -348,7 +349,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -399,7 +401,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", @@ -425,7 +428,8 @@ "tags": { "properties": { "tagFQN": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -452,7 +456,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" @@ -604,7 +609,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/spreadsheet_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/spreadsheet_index_mapping.json index c2a609f00a7c..be70da2fdea1 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/spreadsheet_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/spreadsheet_index_mapping.json @@ -165,7 +165,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -440,7 +441,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/storage_service_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/storage_service_index_mapping.json index 34a246a52b55..ce978840e26f 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/storage_service_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/storage_service_index_mapping.json @@ -189,7 +189,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/stored_procedure_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/stored_procedure_index_mapping.json index e3d692961c18..de9916573e14 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/stored_procedure_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/stored_procedure_index_mapping.json @@ -559,7 +559,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/table_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/table_index_mapping.json index e547e962cfd4..e13ea9e69dd0 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/table_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/table_index_mapping.json @@ -325,7 +325,8 @@ } }, "tableType": { - "type": "keyword" + "type": "keyword", + "normalizer": "lowercase_normalizer" }, "columns": { "properties": { @@ -853,7 +854,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/tag_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/tag_index_mapping.json index cbb68e2d20a7..add701d562a5 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/tag_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/tag_index_mapping.json @@ -185,7 +185,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" } } }, diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/team_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/team_index_mapping.json index a2acb2cf10ac..3ba074810dfd 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/team_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/team_index_mapping.json @@ -122,7 +122,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_index_mapping.json index f178fadba0b3..40d7afde1fce 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_index_mapping.json @@ -1,6 +1,8 @@ { "settings": { - "index": {}, + "index": { + "max_ngram_diff": 1 + }, "analysis": { "normalizer": { "lowercase_normalizer": { @@ -64,9 +66,6 @@ ] } } - }, - "index": { - "max_ngram_diff": 1 } }, "mappings": { @@ -212,7 +211,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_resolution_status_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_resolution_status_index_mapping.json index b1d220eb110a..319969b15b01 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_resolution_status_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_resolution_status_index_mapping.json @@ -746,7 +746,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_result_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_result_index_mapping.json index 905273b2debd..1946c80821dd 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_result_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_case_result_index_mapping.json @@ -327,7 +327,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_suite_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_suite_index_mapping.json index 0d5e19e01b8f..8af00984edb7 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/test_suite_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/test_suite_index_mapping.json @@ -226,7 +226,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/topic_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/topic_index_mapping.json index 7b3001921d28..e72516690a91 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/topic_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/topic_index_mapping.json @@ -458,7 +458,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword" diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/user_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/user_index_mapping.json index 7f8c8c01e67f..bc2f15451119 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/user_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/user_index_mapping.json @@ -92,7 +92,8 @@ "fields": { "keyword": { "type": "keyword", - "ignore_above": 256 + "ignore_above": 256, + "normalizer": "lowercase_normalizer" }, "ngram": { "type": "text", diff --git a/openmetadata-spec/src/main/resources/elasticsearch/zh/worksheet_index_mapping.json b/openmetadata-spec/src/main/resources/elasticsearch/zh/worksheet_index_mapping.json index f00d4e46fc19..9b1441ba82c0 100644 --- a/openmetadata-spec/src/main/resources/elasticsearch/zh/worksheet_index_mapping.json +++ b/openmetadata-spec/src/main/resources/elasticsearch/zh/worksheet_index_mapping.json @@ -241,7 +241,8 @@ "normalizer": "lowercase_normalizer", "ignore_above": 256 } - } + }, + "normalizer": "lowercase_normalizer" }, "displayName": { "type": "keyword", @@ -516,7 +517,8 @@ "type": "text", "analyzer": "om_analyzer" } - } + }, + "normalizer": "lowercase_normalizer" }, "labelType": { "type": "keyword"