diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedField.java b/server/src/main/java/org/opensearch/index/mapper/DerivedField.java
index 7ebe4e5f0b0e8..7bd97b0bfc81a 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedField.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedField.java
@@ -28,18 +28,31 @@ public class DerivedField implements Writeable, ToXContentFragment {
 
     private final String name;
     private final String type;
+
+    private final String sourceIndexedField;
+
     private final Script script;
 
-    public DerivedField(String name, String type, Script script) {
+    public DerivedField(String name, String type, Script script, String sourceIndexedField) {
         this.name = name;
         this.type = type;
         this.script = script;
+        this.sourceIndexedField = sourceIndexedField;
+    }
+
+    public DerivedField(String name, String type, Script script) {
+        this(name, type, script, null);
     }
 
     public DerivedField(StreamInput in) throws IOException {
         name = in.readString();
         type = in.readString();
         script = new Script(in);
+        if (in.readBoolean()) {
+            sourceIndexedField = in.readString();
+        } else {
+            sourceIndexedField = null;
+        }
     }
 
     @Override
@@ -47,6 +60,12 @@ public void writeTo(StreamOutput out) throws IOException {
         out.writeString(name);
         out.writeString(type);
         script.writeTo(out);
+        if (sourceIndexedField != null) {
+            out.writeBoolean(true);
+            out.writeString(sourceIndexedField);
+        } else {
+            out.writeBoolean(false);
+        }
     }
 
     @Override
@@ -54,6 +73,9 @@ public XContentBuilder toXContent(XContentBuilder builder, ToXContent.Params par
         builder.startObject(name);
         builder.field("type", type);
         builder.field("script", script);
+        if (sourceIndexedField != null) {
+            builder.field("source_indexed_field", sourceIndexedField);
+        }
         builder.endObject();
         return builder;
     }
@@ -70,9 +92,13 @@ public Script getScript() {
         return script;
     }
 
+    public String getSourceIndexedField() {
+        return sourceIndexedField;
+    }
+
     @Override
     public int hashCode() {
-        return Objects.hash(name, type, script);
+        return Objects.hash(name, type, script, sourceIndexedField);
     }
 
     @Override
@@ -84,7 +110,10 @@ public boolean equals(Object obj) {
             return false;
         }
         DerivedField other = (DerivedField) obj;
-        return Objects.equals(name, other.name) && Objects.equals(type, other.type) && Objects.equals(script, other.script);
+        return Objects.equals(name, other.name)
+            && Objects.equals(type, other.type)
+            && Objects.equals(script, other.script)
+            && Objects.equals(sourceIndexedField, other.sourceIndexedField);
     }
 
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
index c6ae71320c35c..c69252332da6f 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldMapper.java
@@ -10,13 +10,12 @@
 
 import org.apache.lucene.index.IndexableField;
 import org.opensearch.core.xcontent.XContentBuilder;
+import org.opensearch.index.analysis.IndexAnalyzers;
 import org.opensearch.script.Script;
 
 import java.io.IOException;
 import java.util.Arrays;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.function.Function;
 
 /**
@@ -28,6 +27,8 @@ public class DerivedFieldMapper extends ParametrizedFieldMapper {
 
     public static final String CONTENT_TYPE = "derived";
 
+    protected final IndexAnalyzers indexAnalyzers;
+
     private static DerivedFieldMapper toType(FieldMapper in) {
         return (DerivedFieldMapper) in;
     }
@@ -38,9 +39,10 @@ private static DerivedFieldMapper toType(FieldMapper in) {
      * @opensearch.internal
      */
     public static class Builder extends ParametrizedFieldMapper.Builder {
-        // TODO: The type of parameter may change here if the actual underlying FieldType object is needed
         private final Parameter<String> type = Parameter.stringParam("type", false, m -> toType(m).type, "");
 
+        private final IndexAnalyzers indexAnalyzers;
+
         private final Parameter<Script> script = new Parameter<>(
             "script",
             false,
@@ -49,51 +51,66 @@ public static class Builder extends ParametrizedFieldMapper.Builder {
             m -> toType(m).script
         ).setSerializerCheck((id, ic, value) -> value != null);
 
-        public Builder(String name) {
+        private final Parameter<String> sourceIndexedField = Parameter.stringParam(
+            "source_indexed_field",
+            true,
+            m -> toType(m).sourceIndexedField,
+            ""
+        );
+
+        public Builder(String name, IndexAnalyzers indexAnalyzers) {
             super(name);
+            this.indexAnalyzers = indexAnalyzers;
         }
 
-        public Builder(DerivedField derivedField) {
+        public Builder(DerivedField derivedField, IndexAnalyzers indexAnalyzers) {
             super(derivedField.getName());
             this.type.setValue(derivedField.getType());
             this.script.setValue(derivedField.getScript());
+            this.sourceIndexedField.setValue(derivedField.getSourceIndexedField());
+            this.indexAnalyzers = indexAnalyzers;
         }
 
         @Override
         protected List<Parameter<?>> getParameters() {
-            return Arrays.asList(type, script);
+            return Arrays.asList(type, script, sourceIndexedField);
         }
 
         @Override
         public DerivedFieldMapper build(BuilderContext context) {
-            FieldMapper fieldMapper = DerivedFieldSupportedTypes.getFieldMapperFromType(type.getValue(), name, context);
+            FieldMapper fieldMapper = DerivedFieldSupportedTypes.getFieldMapperFromType(type.getValue(), name, context, indexAnalyzers);
             Function<Object, IndexableField> fieldFunction = DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(
                 type.getValue(),
                 name
             );
             DerivedFieldType ft = new DerivedFieldType(
-                new DerivedField(buildFullName(context), type.getValue(), script.getValue()),
+                new DerivedField(buildFullName(context), type.getValue(), script.getValue(), sourceIndexedField.getValue()),
                 fieldMapper,
-                fieldFunction
+                fieldFunction,
+                indexAnalyzers
             );
-            return new DerivedFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), this);
+            return new DerivedFieldMapper(name, ft, multiFieldsBuilder.build(this, context), copyTo.build(), this, indexAnalyzers);
         }
     }
 
-    public static final TypeParser PARSER = new TypeParser((n, c) -> new Builder(n));
+    public static final TypeParser PARSER = new TypeParser((n, c) -> new Builder(n, c.getIndexAnalyzers()));
     private final String type;
     private final Script script;
+    private final String sourceIndexedField;
 
     protected DerivedFieldMapper(
         String simpleName,
         MappedFieldType mappedFieldType,
         MultiFields multiFields,
         CopyTo copyTo,
-        Builder builder
+        Builder builder,
+        IndexAnalyzers indexAnalyzers
     ) {
         super(simpleName, mappedFieldType, multiFields, copyTo);
         this.type = builder.type.getValue();
         this.script = builder.script.getValue();
+        this.sourceIndexedField = builder.sourceIndexedField.getValue();
+        this.indexAnalyzers = indexAnalyzers;
     }
 
     @Override
@@ -110,7 +127,7 @@ protected void parseCreateField(ParseContext context) throws IOException {
 
     @Override
     public ParametrizedFieldMapper.Builder getMergeBuilder() {
-        return new Builder(simpleName()).init(this);
+        return new Builder(simpleName(), this.indexAnalyzers).init(this);
     }
 
     @Override
@@ -133,26 +150,4 @@ public Script getScript() {
         return script;
     }
 
-    public static Map<String, DerivedFieldType> getAllDerivedFieldTypeFromObject(
-        Map<String, Object> derivedFieldObject,
-        MapperService mapperService
-    ) {
-        Map<String, DerivedFieldType> derivedFieldTypes = new HashMap<>();
-        DocumentMapper documentMapper = mapperService.documentMapperParser().parse(DerivedFieldMapper.CONTENT_TYPE, derivedFieldObject);
-        if (documentMapper != null && documentMapper.mappers() != null) {
-            for (Mapper mapper : documentMapper.mappers()) {
-                if (mapper instanceof DerivedFieldMapper) {
-                    DerivedFieldType derivedFieldType = ((DerivedFieldMapper) mapper).fieldType();
-                    derivedFieldTypes.put(derivedFieldType.name(), derivedFieldType);
-                }
-            }
-        }
-        return derivedFieldTypes;
-    }
-
-    public static DerivedFieldType getDerivedFieldType(DerivedField derivedField, MapperService mapperService) {
-        BuilderContext builderContext = new Mapper.BuilderContext(mapperService.getIndexSettings().getSettings(), new ContentPath(1));
-        Builder builder = new Builder(derivedField);
-        return builder.build(builderContext).fieldType();
-    }
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolver.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolver.java
new file mode 100644
index 0000000000000..8b111c00fecba
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldResolver.java
@@ -0,0 +1,243 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.LeafReaderContext;
+import org.opensearch.common.annotation.PublicApi;
+import org.opensearch.common.regex.Regex;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.core.common.bytes.BytesReference;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.Script;
+import org.opensearch.search.lookup.SourceLookup;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+import static org.opensearch.common.xcontent.XContentFactory.jsonBuilder;
+
+@PublicApi(since = "2.14.0")
+public class DerivedFieldResolver {
+    private final QueryShardContext queryShardContext;
+    private final Map<String, MappedFieldType> derivedFieldTypeMap = new ConcurrentHashMap<>();
+    private final FieldTypeInference typeInference;
+
+    public DerivedFieldResolver(
+        QueryShardContext queryShardContext,
+        Map<String, Object> derivedFieldsObject,
+        List<DerivedField> derivedFields
+    ) {
+        this.queryShardContext = queryShardContext;
+        if (derivedFieldsObject != null) {
+            Map<String, Object> derivedFieldObject = new HashMap<>();
+            derivedFieldObject.put(DerivedFieldMapper.CONTENT_TYPE, derivedFieldsObject);
+            derivedFieldTypeMap.putAll(getAllDerivedFieldTypeFromObject(derivedFieldObject));
+        }
+        if (derivedFields != null) {
+            for (DerivedField derivedField : derivedFields) {
+                derivedFieldTypeMap.put(derivedField.getName(), getDerivedFieldType(derivedField));
+            }
+        }
+        this.typeInference = new FieldTypeInference(queryShardContext);
+    }
+
+    public Set<String> resolvePattern(String pattern) {
+        Set<String> matchingDerivedFields = new HashSet<>();
+        for (String fieldName : derivedFieldTypeMap.keySet()) {
+            if (!matchingDerivedFields.contains(fieldName) && Regex.simpleMatch(pattern, fieldName)) {
+                matchingDerivedFields.add(fieldName);
+            }
+        }
+        return matchingDerivedFields;
+    }
+
+    public MappedFieldType resolve(String fieldName) {
+        if (derivedFieldTypeMap.containsKey(fieldName)) {
+            return derivedFieldTypeMap.get(fieldName);
+        }
+        MappedFieldType derivedFieldType = queryShardContext.getMapperService().fieldType(fieldName);
+        if (derivedFieldType != null) {
+            return derivedFieldType;
+        }
+        if (fieldName.contains(".")) {
+            DerivedFieldType parentDerivedField = getParentDerivedField(fieldName);
+            if (parentDerivedField == null) {
+                return null;
+            }
+            String subFieldName = fieldName.substring(fieldName.indexOf(".") + 1);
+            Mapper inferredFieldMapper = typeInference.infer(subFieldName, parentDerivedField.derivedField.getScript());
+            Mapper.BuilderContext builderContext = new Mapper.BuilderContext(
+                this.queryShardContext.getMapperService().getIndexSettings().getSettings(),
+                new ContentPath(1)
+            );
+            derivedFieldType = new DerivedObjectFieldType(
+                new DerivedField(
+                    fieldName,
+                    inferredFieldMapper.typeName(),
+                    parentDerivedField.derivedField.getScript(),
+                    parentDerivedField.derivedField.getSourceIndexedField()
+                ),
+                DerivedFieldSupportedTypes.getFieldMapperFromType(
+                    inferredFieldMapper.typeName(),
+                    fieldName,
+                    builderContext,
+                    queryShardContext.getIndexAnalyzers()
+                ),
+                DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(inferredFieldMapper.typeName(), fieldName),
+                queryShardContext.getIndexAnalyzers()
+            );
+            if (derivedFieldType != null) {
+                derivedFieldTypeMap.put(fieldName, derivedFieldType);
+            }
+            return derivedFieldType;
+        }
+        return null;
+    }
+
+    private DerivedFieldType getParentDerivedField(String fieldName) {
+        String parentFieldName = fieldName.split("\\.")[0];
+        DerivedFieldType parentDerivedFieldType = (DerivedFieldType) derivedFieldTypeMap.get(parentFieldName);
+        if (parentDerivedFieldType == null) {
+            parentDerivedFieldType = (DerivedFieldType) this.queryShardContext.getMapperService().fieldType(parentFieldName);
+        }
+        return parentDerivedFieldType;
+    }
+
+    private Map<String, DerivedFieldType> getAllDerivedFieldTypeFromObject(Map<String, Object> derivedFieldObject) {
+        Map<String, DerivedFieldType> derivedFieldTypes = new HashMap<>();
+        DocumentMapper documentMapper = this.queryShardContext.getMapperService()
+            .documentMapperParser()
+            .parse(DerivedFieldMapper.CONTENT_TYPE, derivedFieldObject);
+        if (documentMapper != null && documentMapper.mappers() != null) {
+            for (Mapper mapper : documentMapper.mappers()) {
+                if (mapper instanceof DerivedFieldMapper) {
+                    DerivedFieldType derivedFieldType = ((DerivedFieldMapper) mapper).fieldType();
+                    derivedFieldTypes.put(derivedFieldType.name(), derivedFieldType);
+                }
+            }
+        }
+        return derivedFieldTypes;
+    }
+
+    private DerivedFieldType getDerivedFieldType(DerivedField derivedField) {
+        Mapper.BuilderContext builderContext = new Mapper.BuilderContext(
+            this.queryShardContext.getMapperService().getIndexSettings().getSettings(),
+            new ContentPath(1)
+        );
+        DerivedFieldMapper.Builder builder = new DerivedFieldMapper.Builder(
+            derivedField,
+            this.queryShardContext.getMapperService().getIndexAnalyzers()
+        );
+        return builder.build(builderContext).fieldType();
+    }
+
+    static class FieldTypeInference {
+        private final QueryShardContext queryShardContext;
+
+        public FieldTypeInference(QueryShardContext queryShardContext) {
+            this.queryShardContext = queryShardContext;
+        }
+
+        public Mapper infer(String name, Script script) {
+            try {
+                DerivedObjectFieldType.DerivedObjectFieldValueFetcher valueFetcher =
+                    new DerivedObjectFieldType.DerivedObjectFieldValueFetcher(
+                        name,
+                        DerivedFieldType.getDerivedFieldLeafFactory(script, queryShardContext, queryShardContext.lookup()),
+                        o -> o // raw object returned will be used to infer the type without modifying it
+                    );
+                int iter = 0;
+                int totalDocs = queryShardContext.getIndexReader().numDocs();
+                // this will lead to the probability of more than 0.95 to select on the document containing this field,
+                // when at least 5% of the overall documents contain the field
+                int limit = Math.min(totalDocs, 50);
+                int[] docs = getSortedRandomNum(limit, totalDocs, 10000);
+                int offset = 0;
+                int leaf = 0;
+                LeafReaderContext leafReaderContext = queryShardContext.getIndexReader().leaves().get(leaf);
+                valueFetcher.setNextReader(leafReaderContext);
+                SourceLookup sourceLookup = new SourceLookup();
+                while (iter < limit) {
+                    int docID = docs[iter] - offset;
+                    if (docID >= leafReaderContext.reader().numDocs()) {
+                        leaf++;
+                        offset += leafReaderContext.reader().numDocs();
+                        docID = docs[iter] - offset;
+                        leafReaderContext = queryShardContext.getIndexReader().leaves().get(leaf);
+                        valueFetcher.setNextReader(leafReaderContext);
+                    }
+                    sourceLookup.setSegmentAndDocument(leafReaderContext, docID);
+                    List<Object> objects = valueFetcher.fetchValues(sourceLookup);
+                    Mapper inferredMapper = inferTypeFromObject(name, objects.get(0));
+                    if (inferredMapper == null) {
+                        iter++;
+                        continue;
+                    }
+                    return inferredMapper;
+                }
+            } catch (IllegalArgumentException e) {
+                // TODO remove illegal argument exception from DerivedFieldSupportedTypes and let consumers handle themselves.
+                // If inference didn't work, defaulting to keyword field type
+                // TODO: warning?
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+            // the field isn't found in documents where it was checked
+            // TODO: should fallback to keyword field type>
+            throw new MapperException(
+                "Unable to infer the derived field ["
+                    + name
+                    + "] within object type. "
+                    + "Ensure the field is present in majority of the documents"
+            );
+        }
+
+        public static int[] getSortedRandomNum(int k, int n, int attempts) {
+
+            Set<Integer> generatedNumbers = new HashSet<>();
+            Random random = new Random();
+            int itr = 0;
+            while (generatedNumbers.size() < k && itr++ < attempts) {
+                int randomNumber = random.nextInt(n);
+                generatedNumbers.add(randomNumber);
+            }
+            int[] result = new int[k];
+            int i = 0;
+            for (int number : generatedNumbers) {
+                result[i++] = number;
+            }
+            Arrays.sort(result);
+            return result;
+        }
+
+        private Mapper inferTypeFromObject(String name, Object o) throws IOException {
+            // TODO error handling - 1. missing value? 2. Multi-valued field?
+            if (o == null) {
+                return null;
+            }
+            DocumentMapper mapper = queryShardContext.getMapperService().documentMapper();
+            SourceToParse sourceToParse = new SourceToParse(
+                queryShardContext.index().getName(),
+                "_id",
+                BytesReference.bytes(jsonBuilder().startObject().field(name, o).endObject()),
+                JsonXContent.jsonXContent.mediaType()
+            );
+            ParsedDocument parsedDocument = mapper.parse(sourceToParse);
+            Mapping mapping = parsedDocument.dynamicMappingsUpdate();
+            return mapping.root.getMapper(name);
+        }
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java
index aa6936bf6529a..9cedf4f9ab2cc 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldSupportedTypes.java
@@ -11,24 +11,27 @@
 import org.apache.lucene.document.DoubleField;
 import org.apache.lucene.document.Field;
 import org.apache.lucene.document.FieldType;
+import org.apache.lucene.document.FloatField;
 import org.apache.lucene.document.InetAddressPoint;
 import org.apache.lucene.document.KeywordField;
 import org.apache.lucene.document.LatLonPoint;
 import org.apache.lucene.document.LongField;
 import org.apache.lucene.document.LongPoint;
+import org.apache.lucene.document.TextField;
 import org.apache.lucene.index.IndexOptions;
 import org.apache.lucene.index.IndexableField;
 import org.opensearch.Version;
 import org.opensearch.common.Booleans;
+import org.opensearch.common.TriFunction;
 import org.opensearch.common.collect.Tuple;
 import org.opensearch.common.geo.GeoPoint;
 import org.opensearch.common.lucene.Lucene;
 import org.opensearch.common.network.InetAddresses;
+import org.opensearch.index.analysis.IndexAnalyzers;
 
 import java.net.InetAddress;
 import java.util.Arrays;
 import java.util.Map;
-import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
@@ -39,7 +42,7 @@
  */
 public enum DerivedFieldSupportedTypes {
 
-    BOOLEAN("boolean", (name, context) -> {
+    BOOLEAN("boolean", (name, context, indexAnalyzers) -> {
         BooleanFieldMapper.Builder builder = new BooleanFieldMapper.Builder(name);
         return builder.build(context);
     }, name -> o -> {
@@ -53,7 +56,7 @@ public enum DerivedFieldSupportedTypes {
         }
         return new Field(name, value ? "T" : "F", BooleanFieldMapper.Defaults.FIELD_TYPE);
     }, o -> o),
-    DATE("date", (name, context) -> {
+    DATE("date", (name, context, indexAnalyzers) -> {
         // TODO: should we support mapping settings exposed by a given field type from derived fields too?
         // for example, support `format` for date type?
         DateFieldMapper.Builder builder = new DateFieldMapper.Builder(
@@ -65,7 +68,7 @@ public enum DerivedFieldSupportedTypes {
         );
         return builder.build(context);
     }, name -> o -> new LongPoint(name, (long) o), o -> DateFieldMapper.getDefaultDateTimeFormatter().formatMillis((long) o)),
-    GEO_POINT("geo_point", (name, context) -> {
+    GEO_POINT("geo_point", (name, context, indexAnalyzers) -> {
         GeoPointFieldMapper.Builder builder = new GeoPointFieldMapper.Builder(name);
         return builder.build(context);
     }, name -> o -> {
@@ -75,7 +78,7 @@ public enum DerivedFieldSupportedTypes {
         }
         return new LatLonPoint(name, (double) ((Tuple<?, ?>) o).v1(), (double) ((Tuple<?, ?>) o).v2());
     }, o -> new GeoPoint((double) ((Tuple) o).v1(), (double) ((Tuple) o).v2())),
-    IP("ip", (name, context) -> {
+    IP("ip", (name, context, indexAnalyzers) -> {
         IpFieldMapper.Builder builder = new IpFieldMapper.Builder(name, false, Version.CURRENT);
         return builder.build(context);
     }, name -> o -> {
@@ -87,7 +90,7 @@ public enum DerivedFieldSupportedTypes {
         }
         return new InetAddressPoint(name, address);
     }, o -> o),
-    KEYWORD("keyword", (name, context) -> {
+    KEYWORD("keyword", (name, context, indexAnalyzers) -> {
         FieldType dummyFieldType = new FieldType();
         dummyFieldType.setIndexOptions(IndexOptions.DOCS_AND_FREQS);
         KeywordFieldMapper.Builder keywordBuilder = new KeywordFieldMapper.Builder(name);
@@ -102,17 +105,28 @@ public enum DerivedFieldSupportedTypes {
             keywordBuilder
         );
     }, name -> o -> new KeywordField(name, (String) o, Field.Store.NO), o -> o),
-    LONG("long", (name, context) -> {
+    TEXT("text", (name, context, indexAnalyzers) -> {
+        FieldType dummyFieldType = new FieldType();
+        dummyFieldType.setIndexOptions(IndexOptions.DOCS_AND_FREQS);
+        TextFieldMapper.Builder textBuilder = new TextFieldMapper.Builder(name, indexAnalyzers);
+        return textBuilder.build(context);
+    }, name -> o -> new TextField(name, (String) o, Field.Store.NO), o -> o),
+    LONG("long", (name, context, indexAnalyzers) -> {
         NumberFieldMapper.Builder longBuilder = new NumberFieldMapper.Builder(name, NumberFieldMapper.NumberType.LONG, false, false);
         return longBuilder.build(context);
     }, name -> o -> new LongField(name, Long.parseLong(o.toString()), Field.Store.NO), o -> o),
-    DOUBLE("double", (name, context) -> {
+    DOUBLE("double", (name, context, indexAnalyzers) -> {
         NumberFieldMapper.Builder doubleBuilder = new NumberFieldMapper.Builder(name, NumberFieldMapper.NumberType.DOUBLE, false, false);
         return doubleBuilder.build(context);
-    }, name -> o -> new DoubleField(name, Double.parseDouble(o.toString()), Field.Store.NO), o -> o);
+    }, name -> o -> new DoubleField(name, Double.parseDouble(o.toString()), Field.Store.NO), o -> o),
+    FLOAT("float", (name, context, indexAnalyzers) -> {
+        NumberFieldMapper.Builder floatBuilder = new NumberFieldMapper.Builder(name, NumberFieldMapper.NumberType.FLOAT, false, false);
+        return floatBuilder.build(context);
+    }, name -> o -> new FloatField(name, Float.parseFloat(o.toString()), Field.Store.NO), o -> o),
+    OBJECT("object", KEYWORD::getFieldMapper, name -> o -> new KeywordField(name, (String) o, Field.Store.NO), o -> o);
 
     final String name;
-    private final BiFunction<String, Mapper.BuilderContext, FieldMapper> builder;
+    private final TriFunction<String, Mapper.BuilderContext, IndexAnalyzers, FieldMapper> builder;
 
     private final Function<String, Function<Object, IndexableField>> indexableFieldBuilder;
 
@@ -120,7 +134,7 @@ public enum DerivedFieldSupportedTypes {
 
     DerivedFieldSupportedTypes(
         String name,
-        BiFunction<String, Mapper.BuilderContext, FieldMapper> builder,
+        TriFunction<String, Mapper.BuilderContext, IndexAnalyzers, FieldMapper> builder,
         Function<String, Function<Object, IndexableField>> indexableFieldBuilder,
         Function<Object, Object> valueForDisplay
     ) {
@@ -134,8 +148,8 @@ public String getName() {
         return name;
     }
 
-    private FieldMapper getFieldMapper(String name, Mapper.BuilderContext context) {
-        return builder.apply(name, context);
+    private FieldMapper getFieldMapper(String name, Mapper.BuilderContext context, IndexAnalyzers indexAnalyzers) {
+        return builder.apply(name, context, indexAnalyzers);
     }
 
     private Function<Object, IndexableField> getIndexableFieldGenerator(String name) {
@@ -149,11 +163,16 @@ private Function<Object, Object> getValueForDisplayGenerator() {
     private static final Map<String, DerivedFieldSupportedTypes> enumMap = Arrays.stream(DerivedFieldSupportedTypes.values())
         .collect(Collectors.toMap(DerivedFieldSupportedTypes::getName, enumValue -> enumValue));
 
-    public static FieldMapper getFieldMapperFromType(String type, String name, Mapper.BuilderContext context) {
+    public static FieldMapper getFieldMapperFromType(
+        String type,
+        String name,
+        Mapper.BuilderContext context,
+        IndexAnalyzers indexAnalyzers
+    ) {
         if (!enumMap.containsKey(type)) {
             throw new IllegalArgumentException("Type [" + type + "] isn't supported in Derived field context.");
         }
-        return enumMap.get(type).getFieldMapper(name, context);
+        return enumMap.get(type).getFieldMapper(name, context, indexAnalyzers);
     }
 
     public static Function<Object, IndexableField> getIndexableFieldGeneratorType(String type, String name) {
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java
index 8b480819acd0e..e85d2acdef4b2 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldType.java
@@ -19,10 +19,12 @@
 import org.opensearch.common.time.DateMathParser;
 import org.opensearch.common.unit.Fuzziness;
 import org.opensearch.geometry.Geometry;
+import org.opensearch.index.analysis.IndexAnalyzers;
 import org.opensearch.index.analysis.NamedAnalyzer;
 import org.opensearch.index.query.DerivedFieldQuery;
 import org.opensearch.index.query.QueryShardContext;
 import org.opensearch.script.DerivedFieldScript;
+import org.opensearch.script.Script;
 import org.opensearch.search.lookup.SearchLookup;
 
 import java.io.IOException;
@@ -37,13 +39,10 @@
  * Contains logic to execute different type of queries on a derived field of given type.
  * @opensearch.internal
  */
-public final class DerivedFieldType extends MappedFieldType implements GeoShapeQueryable {
-
-    private final DerivedField derivedField;
-
-    FieldMapper typeFieldMapper;
-
-    final Function<Object, IndexableField> indexableFieldGenerator;
+public class DerivedFieldType extends MappedFieldType implements GeoShapeQueryable {
+    final DerivedField derivedField;
+    private final FieldMapper typeFieldMapper;
+    private final Function<Object, IndexableField> indexableFieldGenerator;
 
     public DerivedFieldType(
         DerivedField derivedField,
@@ -60,10 +59,24 @@ public DerivedFieldType(
         this.indexableFieldGenerator = fieldFunction;
     }
 
-    public DerivedFieldType(DerivedField derivedField, FieldMapper typeFieldMapper, Function<Object, IndexableField> fieldFunction) {
+    public DerivedFieldType(
+        DerivedField derivedField,
+        FieldMapper typeFieldMapper,
+        Function<Object, IndexableField> fieldFunction,
+        IndexAnalyzers indexAnalyzers
+    ) {
         this(derivedField, false, false, false, Collections.emptyMap(), typeFieldMapper, fieldFunction);
     }
 
+    @Override
+    public TextSearchInfo getTextSearchInfo() {
+        return typeFieldMapper.fieldType().getTextSearchInfo();
+    }
+
+    TextFieldMapper.TextFieldType getSourceIndexedFieldType(String sourceIndexedField, QueryShardContext context) {
+        return null;
+    }
+
     @Override
     public String typeName() {
         return "derived";
@@ -73,12 +86,16 @@ public String getType() {
         return derivedField.getType();
     }
 
-    public MappedFieldType getTypeMappedFieldType() {
-        return typeFieldMapper.mappedFieldType;
+    public FieldMapper getFieldMapper() {
+        return typeFieldMapper;
+    }
+
+    public Function<Object, IndexableField> getIndexableFieldGenerator() {
+        return indexableFieldGenerator;
     }
 
     public NamedAnalyzer getIndexAnalyzer() {
-        return typeFieldMapper.mappedFieldType.indexAnalyzer();
+        return getFieldMapper().mappedFieldType.indexAnalyzer();
     }
 
     @Override
@@ -88,31 +105,45 @@ public DerivedFieldValueFetcher valueFetcher(QueryShardContext context, SearchLo
         }
         Function<Object, Object> valueForDisplay = DerivedFieldSupportedTypes.getValueForDisplayGenerator(getType());
         return new DerivedFieldValueFetcher(
-            getDerivedFieldLeafFactory(context, searchLookup == null ? context.lookup() : searchLookup),
-            valueForDisplay,
-            indexableFieldGenerator
+            getDerivedFieldLeafFactory(derivedField.getScript(), context, searchLookup == null ? context.lookup() : searchLookup),
+            valueForDisplay
         );
     }
 
     @Override
     public Query termQuery(Object value, QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.termQuery(value, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.termQuery(value, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query termQueryCaseInsensitive(Object value, @Nullable QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.termQueryCaseInsensitive(value, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.termQueryCaseInsensitive(value, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query termsQuery(List<?> values, @Nullable QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.termsQuery(values, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.termsQuery(values, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -137,7 +168,7 @@ public Query rangeQuery(
             context
         );
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -150,8 +181,13 @@ public Query fuzzyQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -173,8 +209,13 @@ public Query fuzzyQuery(
             method,
             context
         );
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.fuzzyQuery(value, fuzziness, prefixLength, maxExpansions, transpositions, method, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -185,8 +226,13 @@ public Query prefixQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.prefixQuery(value, method, caseInsensitive, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.prefixQuery(value, method, caseInsensitive, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -197,15 +243,25 @@ public Query wildcardQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.wildcardQuery(value, method, caseInsensitive, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.wildcardQuery(value, method, caseInsensitive, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query normalizedWildcardQuery(String value, @Nullable MultiTermQuery.RewriteMethod method, QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.normalizedWildcardQuery(value, method, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.normalizedWildcardQuery(value, method, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -218,30 +274,50 @@ public Query regexpQuery(
         QueryShardContext context
     ) {
         Query query = typeFieldMapper.mappedFieldType.regexpQuery(value, syntaxFlags, matchFlags, maxDeterminizedStates, method, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.regexpQuery(value, syntaxFlags, matchFlags, maxDeterminizedStates, method, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query phraseQuery(TokenStream stream, int slop, boolean enablePositionIncrements, QueryShardContext context) throws IOException {
         Query query = typeFieldMapper.mappedFieldType.phraseQuery(stream, slop, enablePositionIncrements, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.phraseQuery(stream, slop, enablePositionIncrements, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query multiPhraseQuery(TokenStream stream, int slop, boolean enablePositionIncrements, QueryShardContext context)
         throws IOException {
         Query query = typeFieldMapper.mappedFieldType.multiPhraseQuery(stream, slop, enablePositionIncrements, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.multiPhraseQuery(stream, slop, enablePositionIncrements, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query phrasePrefixQuery(TokenStream stream, int slop, int maxExpansions, QueryShardContext context) throws IOException {
         Query query = typeFieldMapper.mappedFieldType.phrasePrefixQuery(stream, slop, maxExpansions, context);
+        TextFieldMapper.TextFieldType sourceIndexedFieldType = getSourceIndexedFieldType(derivedField.getSourceIndexedField(), context);
+        Query filterQuery = null;
+        if (sourceIndexedFieldType != null) {
+            filterQuery = sourceIndexedFieldType.phrasePrefixQuery(stream, slop, maxExpansions, context);
+        }
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, filterQuery, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -255,14 +331,14 @@ public SpanQuery spanPrefixQuery(String value, SpanMultiTermQueryWrapper.SpanRew
     public Query distanceFeatureQuery(Object origin, String pivot, float boost, QueryShardContext context) {
         Query query = typeFieldMapper.mappedFieldType.distanceFeatureQuery(origin, pivot, boost, context);
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
     public Query geoShapeQuery(Geometry shape, String fieldName, ShapeRelation relation, QueryShardContext context) {
         Query query = ((GeoShapeQueryable) (typeFieldMapper.mappedFieldType)).geoShapeQuery(shape, fieldName, relation, context);
         DerivedFieldValueFetcher valueFetcher = valueFetcher(context, context.lookup(), null);
-        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer());
+        return new DerivedFieldQuery(query, valueFetcher, context.lookup(), getIndexAnalyzer(), indexableFieldGenerator);
     }
 
     @Override
@@ -275,7 +351,11 @@ public boolean isAggregatable() {
         return false;
     }
 
-    private DerivedFieldScript.LeafFactory getDerivedFieldLeafFactory(QueryShardContext context, SearchLookup searchLookup) {
+    public static DerivedFieldScript.LeafFactory getDerivedFieldLeafFactory(
+        Script script,
+        QueryShardContext context,
+        SearchLookup searchLookup
+    ) {
         if (!context.documentMapper("").sourceMapper().enabled()) {
             throw new IllegalArgumentException(
                 "DerivedFieldQuery error: unable to fetch fields from _source field: _source is disabled in the mappings "
@@ -284,7 +364,7 @@ private DerivedFieldScript.LeafFactory getDerivedFieldLeafFactory(QueryShardCont
                     + "]"
             );
         }
-        DerivedFieldScript.Factory factory = context.compile(derivedField.getScript(), DerivedFieldScript.CONTEXT);
-        return factory.newFactory(derivedField.getScript().getParams(), searchLookup);
+        DerivedFieldScript.Factory factory = context.compile(script, DerivedFieldScript.CONTEXT);
+        return factory.newFactory(script.getParams(), searchLookup);
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
index 2d9379e04c512..93799b3aa59b6 100644
--- a/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedFieldValueFetcher.java
@@ -25,21 +25,15 @@
  * {@link #setNextReader(LeafReaderContext)} whenever a segment is switched.
  */
 @PublicApi(since = "2.14.0")
-public final class DerivedFieldValueFetcher implements ValueFetcher {
+public class DerivedFieldValueFetcher implements ValueFetcher {
     private DerivedFieldScript derivedFieldScript;
     private final DerivedFieldScript.LeafFactory derivedFieldScriptFactory;
 
     private final Function<Object, Object> valueForDisplay;
-    private final Function<Object, IndexableField> indexableFieldFunction;
 
-    public DerivedFieldValueFetcher(
-        DerivedFieldScript.LeafFactory derivedFieldScriptFactory,
-        Function<Object, Object> valueForDisplay,
-        Function<Object, IndexableField> indexableFieldFunction
-    ) {
+    public DerivedFieldValueFetcher(DerivedFieldScript.LeafFactory derivedFieldScriptFactory, Function<Object, Object> valueForDisplay) {
         this.derivedFieldScriptFactory = derivedFieldScriptFactory;
         this.valueForDisplay = valueForDisplay;
-        this.indexableFieldFunction = indexableFieldFunction;
     }
 
     @Override
@@ -55,17 +49,21 @@ public List<Object> fetchValues(SourceLookup lookup) {
         return result;
     }
 
-    private List<Object> fetchValuesInternal(SourceLookup lookup) {
+    public List<Object> fetchValuesInternal(SourceLookup lookup) {
         derivedFieldScript.setDocument(lookup.docId());
         derivedFieldScript.execute();
         return derivedFieldScript.getEmittedValues();
     }
 
-    public List<IndexableField> getIndexableField(SourceLookup lookup) {
+    public List<IndexableField> getIndexableField(SourceLookup lookup, Function<Object, IndexableField> indexableFieldFunction) {
         List<Object> values = fetchValuesInternal(lookup);
         List<IndexableField> indexableFields = new ArrayList<>();
         for (Object v : values) {
-            indexableFields.add(indexableFieldFunction.apply(v));
+            if (v != null) {
+                indexableFields.add(indexableFieldFunction.apply(v));
+            } else {
+                // TODO: should we throw exception for missing fields here?
+            }
         }
         return indexableFields;
     }
diff --git a/server/src/main/java/org/opensearch/index/mapper/DerivedObjectFieldType.java b/server/src/main/java/org/opensearch/index/mapper/DerivedObjectFieldType.java
new file mode 100644
index 0000000000000..6ab2cc95b263f
--- /dev/null
+++ b/server/src/main/java/org/opensearch/index/mapper/DerivedObjectFieldType.java
@@ -0,0 +1,92 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * The OpenSearch Contributors require contributions made to
+ * this file be licensed under the Apache-2.0 license or a
+ * compatible open source license.
+ */
+
+package org.opensearch.index.mapper;
+
+import org.apache.lucene.index.IndexableField;
+import org.opensearch.common.xcontent.XContentHelper;
+import org.opensearch.common.xcontent.json.JsonXContent;
+import org.opensearch.index.analysis.IndexAnalyzers;
+import org.opensearch.index.query.QueryShardContext;
+import org.opensearch.script.DerivedFieldScript;
+import org.opensearch.search.lookup.SearchLookup;
+import org.opensearch.search.lookup.SourceLookup;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+public class DerivedObjectFieldType extends DerivedFieldType {
+
+    public DerivedObjectFieldType(
+        DerivedField derivedField,
+        FieldMapper typeFieldMapper,
+        Function<Object, IndexableField> fieldFunction,
+        IndexAnalyzers indexAnalyzers
+    ) {
+        super(derivedField, typeFieldMapper, fieldFunction, indexAnalyzers);
+    }
+
+    @Override
+    TextFieldMapper.TextFieldType getSourceIndexedFieldType(String sourceIndexedField, QueryShardContext context) {
+        if (sourceIndexedField == null || sourceIndexedField.isEmpty()) {
+            return null;
+        }
+        // TODO error handling
+        MappedFieldType mappedFieldType = context.fieldMapper(sourceIndexedField);
+        if (!(mappedFieldType instanceof TextFieldMapper.TextFieldType)) {
+            // TODO: throw validation error?
+            return null;
+        }
+        return (TextFieldMapper.TextFieldType) mappedFieldType;
+    }
+
+    @Override
+    public DerivedFieldValueFetcher valueFetcher(QueryShardContext context, SearchLookup searchLookup, String format) {
+        if (format != null) {
+            throw new IllegalArgumentException("Field [" + name() + "] of type [" + typeName() + "] doesn't support formats.");
+        }
+        Function<Object, Object> valueForDisplay = DerivedFieldSupportedTypes.getValueForDisplayGenerator(getType());
+        return new DerivedObjectFieldValueFetcher(
+            getSubField(),
+            getDerivedFieldLeafFactory(derivedField.getScript(), context, searchLookup == null ? context.lookup() : searchLookup),
+            valueForDisplay
+        );
+    }
+
+    public static class DerivedObjectFieldValueFetcher extends DerivedFieldValueFetcher {
+        private final String subField;
+
+        public DerivedObjectFieldValueFetcher(
+            String subField,
+            DerivedFieldScript.LeafFactory derivedFieldScriptFactory,
+            Function<Object, Object> valueForDisplay
+        ) {
+            super(derivedFieldScriptFactory, valueForDisplay);
+            this.subField = subField;
+        }
+
+        @Override
+        public List<Object> fetchValuesInternal(SourceLookup lookup) {
+            List<Object> jsonObjects = super.fetchValuesInternal(lookup);
+            // TODO add check for valid json and error handling around the same if mismatch
+            // parse the value of field from the json object and return that instead
+            List<Object> result = new ArrayList<>();
+            for (Object o : jsonObjects) {
+                Map<String, Object> s = XContentHelper.convertToMap(JsonXContent.jsonXContent, (String) o, false);
+                result.add(s.get(subField));
+            }
+            return result;
+        }
+    }
+
+    private String getSubField() {
+        return name().split("\\.")[1];
+    }
+}
diff --git a/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java b/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java
index 42ac61bf98f73..dfc66f57c62ca 100644
--- a/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java
+++ b/server/src/main/java/org/opensearch/index/query/DerivedFieldQuery.java
@@ -29,6 +29,7 @@
 import java.io.IOException;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.Function;
 
 /**
  * DerivedFieldQuery used for querying derived fields. It contains the logic to execute an input lucene query against
@@ -36,21 +37,45 @@
  */
 public final class DerivedFieldQuery extends Query {
     private final Query query;
+
+    private final Query filterQuery;
+
     private final DerivedFieldValueFetcher valueFetcher;
     private final SearchLookup searchLookup;
     private final Analyzer indexAnalyzer;
 
+    private final Function<Object, IndexableField> indexableFieldGenerator;
+
     /**
      * @param query lucene query to be executed against the derived field
      * @param valueFetcher DerivedFieldValueFetcher ValueFetcher to fetch the value of a derived field from _source
      *                     using LeafSearchLookup
      * @param searchLookup SearchLookup to get the LeafSearchLookup look used by valueFetcher to fetch the _source
      */
-    public DerivedFieldQuery(Query query, DerivedFieldValueFetcher valueFetcher, SearchLookup searchLookup, Analyzer indexAnalyzer) {
+    public DerivedFieldQuery(
+        Query query,
+        DerivedFieldValueFetcher valueFetcher,
+        SearchLookup searchLookup,
+        Analyzer indexAnalyzer,
+        Function<Object, IndexableField> indexableFieldGenerator
+    ) {
+        this(query, null, valueFetcher, searchLookup, indexAnalyzer, indexableFieldGenerator);
+    }
+
+    public DerivedFieldQuery(
+        Query query,
+        Query filterQuery,
+        DerivedFieldValueFetcher valueFetcher,
+        SearchLookup searchLookup,
+        Analyzer indexAnalyzer,
+        Function<Object, IndexableField> indexableFieldGenerator
+    ) {
         this.query = query;
+        this.filterQuery = filterQuery;
         this.valueFetcher = valueFetcher;
         this.searchLookup = searchLookup;
         this.indexAnalyzer = indexAnalyzer;
+        this.indexableFieldGenerator = indexableFieldGenerator;
     }
 
     @Override
@@ -64,23 +89,40 @@ public Query rewrite(IndexSearcher indexSearcher) throws IOException {
         if (rewritten == query) {
             return this;
         }
-        return new DerivedFieldQuery(rewritten, valueFetcher, searchLookup, indexAnalyzer);
+        Query rewrittenFilterQuery = filterQuery == null ? filterQuery : indexSearcher.rewrite(filterQuery);
+        return new DerivedFieldQuery(rewritten, rewrittenFilterQuery, valueFetcher, searchLookup, indexAnalyzer, indexableFieldGenerator);
     }
 
     @Override
     public Weight createWeight(IndexSearcher searcher, ScoreMode scoreMode, float boost) throws IOException {
 
+        Weight filterQueryWeight = filterQuery == null ? null : filterQuery.createWeight(searcher, scoreMode, boost);
+
         return new ConstantScoreWeight(this, boost) {
             @Override
-            public Scorer scorer(LeafReaderContext context) {
-                DocIdSetIterator approximation = DocIdSetIterator.all(context.reader().maxDoc());
+            public Scorer scorer(LeafReaderContext context) throws IOException {
+                DocIdSetIterator approximation;
+
+                if (filterQueryWeight != null) {
+                    Scorer scorer = filterQueryWeight.scorer(context);
+                    if (scorer == null) {
+                        // none of the docs are matching
+                        return null;
+                    }
+                    approximation = scorer.iterator();
+                } else {
+                    approximation = DocIdSetIterator.all(context.reader().maxDoc());
+                }
                 valueFetcher.setNextReader(context);
                 LeafSearchLookup leafSearchLookup = searchLookup.getLeafSearchLookup(context);
                 TwoPhaseIterator twoPhase = new TwoPhaseIterator(approximation) {
                     @Override
                     public boolean matches() {
                         leafSearchLookup.source().setSegmentAndDocument(context, approximation.docID());
-                        List<IndexableField> indexableFields = valueFetcher.getIndexableField(leafSearchLookup.source());
+                        List<IndexableField> indexableFields = valueFetcher.getIndexableField(
+                            leafSearchLookup.source(),
+                            indexableFieldGenerator
+                        );
                         // TODO: in case of errors from script, should it be ignored and treated as missing field
                         // by using a configurable setting?
                         MemoryIndex memoryIndex = new MemoryIndex();
@@ -126,6 +168,8 @@ public int hashCode() {
 
     @Override
     public String toString(String f) {
-        return "DerivedFieldQuery (Query: [ " + query.toString(f) + "])";
+        return "DerivedFieldQuery (Query: [ " + query.toString(f) + "]" + filterQuery != null
+            ? " FilterQuery: [ " + filterQuery.toString(f) + "])"
+            : ")";
     }
 }
diff --git a/server/src/main/java/org/opensearch/index/query/QueryShardContext.java b/server/src/main/java/org/opensearch/index/query/QueryShardContext.java
index 64643ad6d2c94..d3be3a9e55f35 100644
--- a/server/src/main/java/org/opensearch/index/query/QueryShardContext.java
+++ b/server/src/main/java/org/opensearch/index/query/QueryShardContext.java
@@ -45,7 +45,6 @@
 import org.opensearch.common.TriFunction;
 import org.opensearch.common.annotation.PublicApi;
 import org.opensearch.common.lucene.search.Queries;
-import org.opensearch.common.regex.Regex;
 import org.opensearch.common.util.BigArrays;
 import org.opensearch.core.action.ActionListener;
 import org.opensearch.core.common.ParsingException;
@@ -59,6 +58,8 @@
 import org.opensearch.index.cache.bitset.BitsetFilterCache;
 import org.opensearch.index.fielddata.IndexFieldData;
 import org.opensearch.index.mapper.ContentPath;
+import org.opensearch.index.mapper.DerivedFieldResolver;
+import org.opensearch.index.mapper.DerivedFieldType;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.MappedFieldType;
 import org.opensearch.index.mapper.Mapper;
@@ -88,6 +89,8 @@
 import java.util.function.Predicate;
 import java.util.function.Supplier;
 
+import static java.util.Collections.emptyList;
+import static java.util.Collections.emptyMap;
 import static java.util.Collections.unmodifiableMap;
 
 /**
@@ -121,7 +124,7 @@ public class QueryShardContext extends QueryRewriteContext {
     private final ValuesSourceRegistry valuesSourceRegistry;
     private BitSetProducer parentFilter;
 
-    private Map<String, MappedFieldType> derivedFieldTypeMap = new HashMap<>();
+    private DerivedFieldResolver derivedFieldResolver;
 
     public QueryShardContext(
         int shardId,
@@ -268,6 +271,7 @@ private QueryShardContext(
         this.fullyQualifiedIndex = fullyQualifiedIndex;
         this.allowExpensiveQueries = allowExpensiveQueries;
         this.valuesSourceRegistry = valuesSourceRegistry;
+        this.derivedFieldResolver = new DerivedFieldResolver(this, emptyMap(), emptyList());
     }
 
     private void reset() {
@@ -333,17 +337,9 @@ public Map<String, Query> copyNamedQueries() {
      * type then the fields will be returned with a type prefix.
      */
     public Set<String> simpleMatchToIndexNames(String pattern) {
-        Set<String> matchingFields = mapperService.simpleMatchToFullName(pattern);
-        if (derivedFieldTypeMap != null && !derivedFieldTypeMap.isEmpty()) {
-            Set<String> matchingDerivedFields = new HashSet<>(matchingFields);
-            for (String fieldName : derivedFieldTypeMap.keySet()) {
-                if (!matchingDerivedFields.contains(fieldName) && Regex.simpleMatch(pattern, fieldName)) {
-                    matchingDerivedFields.add(fieldName);
-                }
-            }
-            return matchingDerivedFields;
-        }
-        return matchingFields;
+        Set<String> allMatchingFields = new HashSet<>(mapperService.simpleMatchToFullName(pattern));
+        allMatchingFields.addAll(derivedFieldResolver.resolvePattern(pattern));
+        return allMatchingFields;
     }
 
     /**
@@ -409,12 +405,8 @@ public ValuesSourceRegistry getValuesSourceRegistry() {
         return valuesSourceRegistry;
     }
 
-    public void setDerivedFieldTypes(Map<String, MappedFieldType> derivedFieldTypeMap) {
-        this.derivedFieldTypeMap = derivedFieldTypeMap;
-    }
-
-    public MappedFieldType getDerivedFieldType(String fieldName) {
-        return derivedFieldTypeMap == null ? null : derivedFieldTypeMap.get(fieldName);
+    public void setDerivedFieldResolver(DerivedFieldResolver derivedFieldResolver) {
+        this.derivedFieldResolver = derivedFieldResolver;
     }
 
     public void setAllowUnmappedFields(boolean allowUnmappedFields) {
@@ -427,9 +419,14 @@ public void setMapUnmappedFieldAsString(boolean mapUnmappedFieldAsString) {
 
     MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMapping) {
         if (fieldMapping != null) {
+            if (fieldMapping instanceof DerivedFieldType) {
+                // resolveDerivedFieldType() will give precedence to search time definitions over index mapping, thus
+                // calling it instead of directly returning
+                return resolveDerivedFieldType(name);
+            }
+            return fieldMapping;
+        } else if ((fieldMapping = resolveDerivedFieldType(name)) != null) {
             return fieldMapping;
-        } else if (getDerivedFieldType(name) != null) {
-            return getDerivedFieldType(name);
         } else if (allowUnmappedFields) {
             return fieldMapping;
         } else if (mapUnmappedFieldAsString) {
@@ -440,6 +437,10 @@ MappedFieldType failIfFieldMappingNotFound(String name, MappedFieldType fieldMap
         }
     }
 
+    public MappedFieldType resolveDerivedFieldType(String name) {
+        return derivedFieldResolver.resolve(name);
+    }
+
     private SearchLookup lookup = null;
 
     /**
diff --git a/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java b/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java
index c55d88439b11f..c4237cd94a834 100644
--- a/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java
+++ b/server/src/main/java/org/opensearch/index/query/VectorGeoPointShapeQueryProcessor.java
@@ -81,7 +81,7 @@ private void validateIsGeoPointFieldType(String fieldName, QueryShardContext con
         MappedFieldType fieldType = context.fieldMapper(fieldName);
         if (fieldType instanceof GeoPointFieldMapper.GeoPointFieldType == false
             && !(fieldType instanceof DerivedFieldType
-                && (((DerivedFieldType) fieldType).getTypeMappedFieldType() instanceof GeoPointFieldMapper.GeoPointFieldType))) {
+                && (((DerivedFieldType) fieldType).getFieldMapper().fieldType() instanceof GeoPointFieldMapper.GeoPointFieldType))) {
             throw new QueryShardException(
                 context,
                 "Expected "
diff --git a/server/src/main/java/org/opensearch/search/SearchService.java b/server/src/main/java/org/opensearch/search/SearchService.java
index 744d3a19f1593..8c6a385c8fc80 100644
--- a/server/src/main/java/org/opensearch/search/SearchService.java
+++ b/server/src/main/java/org/opensearch/search/SearchService.java
@@ -77,9 +77,7 @@
 import org.opensearch.index.IndexService;
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.engine.Engine;
-import org.opensearch.index.mapper.DerivedField;
-import org.opensearch.index.mapper.DerivedFieldMapper;
-import org.opensearch.index.mapper.MappedFieldType;
+import org.opensearch.index.mapper.DerivedFieldResolver;
 import org.opensearch.index.query.InnerHitContextBuilder;
 import org.opensearch.index.query.MatchAllQueryBuilder;
 import org.opensearch.index.query.MatchNoneQueryBuilder;
@@ -1081,24 +1079,13 @@ private DefaultSearchContext createSearchContext(ReaderContext reader, ShardSear
             if (request.source() != null
                 && request.source().size() != 0
                 && (request.source().getDerivedFieldsObject() != null || request.source().getDerivedFields() != null)) {
-                Map<String, MappedFieldType> derivedFieldTypeMap = new HashMap<>();
-                if (request.source().getDerivedFieldsObject() != null) {
-                    Map<String, Object> derivedFieldObject = new HashMap<>();
-                    derivedFieldObject.put(DerivedFieldMapper.CONTENT_TYPE, request.source().getDerivedFieldsObject());
-                    derivedFieldTypeMap.putAll(
-                        DerivedFieldMapper.getAllDerivedFieldTypeFromObject(derivedFieldObject, searchContext.mapperService())
-                    );
-                }
-                if (request.source().getDerivedFields() != null) {
-                    for (DerivedField derivedField : request.source().getDerivedFields()) {
-                        derivedFieldTypeMap.put(
-                            derivedField.getName(),
-                            DerivedFieldMapper.getDerivedFieldType(derivedField, searchContext.mapperService())
-                        );
-                    }
-                }
-                context.setDerivedFieldTypes(derivedFieldTypeMap);
-                searchContext.getQueryShardContext().setDerivedFieldTypes(derivedFieldTypeMap);
+                DerivedFieldResolver derivedFieldResolver = new DerivedFieldResolver(
+                    searchContext.getQueryShardContext(),
+                    request.source().getDerivedFieldsObject(),
+                    request.source().getDerivedFields()
+                );
+                context.setDerivedFieldResolver(derivedFieldResolver);
+                searchContext.getQueryShardContext().setDerivedFieldResolver(derivedFieldResolver);
             }
             Rewriteable.rewrite(request.getRewriteable(), context, true);
             assert searchContext.getQueryShardContext().isCacheable();
diff --git a/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java b/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
index 07248a0719c3a..9c4afd929aaa8 100644
--- a/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
+++ b/server/src/main/java/org/opensearch/search/builder/SearchSourceBuilder.java
@@ -997,10 +997,14 @@ public List<DerivedField> getDerivedFields() {
      * @param script script associated with derived field
      */
     public SearchSourceBuilder derivedField(String name, String type, Script script) {
+        return derivedField(name, type, script, null);
+    }
+
+    public SearchSourceBuilder derivedField(String name, String type, Script script, String sourceIndexedField) {
         if (derivedFields == null) {
             derivedFields = new ArrayList<>();
         }
-        derivedFields.add(new DerivedField(name, type, script));
+        derivedFields.add(new DerivedField(name, type, script, sourceIndexedField));
         return this;
     }
 
diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java
index b16f06e7e3989..41a7e9934fc4d 100644
--- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java
+++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/HighlightPhase.java
@@ -145,8 +145,8 @@ private Map<String, Function<HitContext, FieldHighlightContext>> contextBuilders
             boolean fieldNameContainsWildcards = field.field().contains("*");
             for (String fieldName : fieldNamesToHighlight) {
                 MappedFieldType fieldType = context.mapperService().fieldType(fieldName);
-                if (fieldType == null && context.getQueryShardContext().getDerivedFieldType(fieldName) != null) {
-                    fieldType = context.getQueryShardContext().getDerivedFieldType(fieldName);
+                if (fieldType == null) {
+                    fieldType = context.getQueryShardContext().resolveDerivedFieldType(fieldName);
                 }
                 if (fieldType == null) {
                     continue;
diff --git a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java
index c791c8bc05054..510773c8bb2b6 100644
--- a/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java
+++ b/server/src/main/java/org/opensearch/search/fetch/subphase/highlight/UnifiedHighlighter.java
@@ -160,9 +160,9 @@ CustomUnifiedHighlighter buildHighlighter(FieldHighlightContext fieldContext) th
         Integer fieldMaxAnalyzedOffset = fieldContext.field.fieldOptions().maxAnalyzerOffset();
         int numberOfFragments = fieldContext.field.fieldOptions().numberOfFragments();
         Analyzer analyzer = getAnalyzer(fieldContext.context.mapperService().documentMapper());
-        if (fieldContext.context.getQueryShardContext().getDerivedFieldType(fieldContext.fieldName) != null) {
-            analyzer = ((DerivedFieldType) fieldContext.context.getQueryShardContext().getDerivedFieldType(fieldContext.fieldName))
-                .getIndexAnalyzer();
+        MappedFieldType derivedFieldType = fieldContext.context.getQueryShardContext().resolveDerivedFieldType(fieldContext.fieldName);
+        if (derivedFieldType != null) {
+            analyzer = ((DerivedFieldType) derivedFieldType).getIndexAnalyzer();
         }
         if (fieldMaxAnalyzedOffset != null) {
             analyzer = getLimitedOffsetAnalyzer(analyzer, fieldMaxAnalyzedOffset);
diff --git a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java
index 897848008fd5f..6b050ce4e70ff 100644
--- a/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java
+++ b/server/src/test/java/org/opensearch/index/mapper/DerivedFieldTypeTests.java
@@ -30,61 +30,62 @@ private DerivedFieldType createDerivedFieldType(String type) {
         when(context.path()).thenReturn(new ContentPath());
         return new DerivedFieldType(
             new DerivedField(type + " _derived_field", type, new Script("")),
-            DerivedFieldSupportedTypes.getFieldMapperFromType(type, type + "_derived_field", context),
-            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, type + "_derived_field")
+            DerivedFieldSupportedTypes.getFieldMapperFromType(type, type + "_derived_field", context, null),
+            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, type + "_derived_field"),
+            null
         );
     }
 
     public void testBooleanType() {
         DerivedFieldType dft = createDerivedFieldType("boolean");
-        assertTrue(dft.typeFieldMapper instanceof BooleanFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(true) instanceof Field);
-        assertTrue(dft.indexableFieldGenerator.apply(false) instanceof Field);
+        assertTrue(dft.getFieldMapper() instanceof BooleanFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(true) instanceof Field);
+        assertTrue(dft.getIndexableFieldGenerator().apply(false) instanceof Field);
     }
 
     public void testDateType() {
         DerivedFieldType dft = createDerivedFieldType("date");
-        assertTrue(dft.typeFieldMapper instanceof DateFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(System.currentTimeMillis()) instanceof LongPoint);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply("blah"));
+        assertTrue(dft.getFieldMapper() instanceof DateFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(System.currentTimeMillis()) instanceof LongPoint);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply("blah"));
     }
 
     public void testGeoPointType() {
         DerivedFieldType dft = createDerivedFieldType("geo_point");
-        assertTrue(dft.typeFieldMapper instanceof GeoPointFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(new Tuple<>(10.0, 20.0)) instanceof LatLonPoint);
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of(10.0)));
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of()));
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of("10")));
-        expectThrows(ClassCastException.class, () -> dft.indexableFieldGenerator.apply(List.of(10.0, 20.0, 30.0)));
+        assertTrue(dft.getFieldMapper() instanceof GeoPointFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(new Tuple<>(10.0, 20.0)) instanceof LatLonPoint);
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of(10.0)));
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of()));
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of("10")));
+        expectThrows(ClassCastException.class, () -> dft.getIndexableFieldGenerator().apply(List.of(10.0, 20.0, 30.0)));
     }
 
     public void testIPType() {
         DerivedFieldType dft = createDerivedFieldType("ip");
-        assertTrue(dft.typeFieldMapper instanceof IpFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply("127.0.0.1") instanceof InetAddressPoint);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply("blah"));
+        assertTrue(dft.getFieldMapper() instanceof IpFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply("127.0.0.1") instanceof InetAddressPoint);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply("blah"));
     }
 
     public void testKeywordType() {
         DerivedFieldType dft = createDerivedFieldType("keyword");
-        assertTrue(dft.typeFieldMapper instanceof KeywordFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply("test_keyword") instanceof KeywordField);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply(10));
+        assertTrue(dft.getFieldMapper() instanceof KeywordFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply("test_keyword") instanceof KeywordField);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply(10));
     }
 
     public void testLongType() {
         DerivedFieldType dft = createDerivedFieldType("long");
-        assertTrue(dft.typeFieldMapper instanceof NumberFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(10) instanceof LongField);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply(10.0));
+        assertTrue(dft.getFieldMapper() instanceof NumberFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(10) instanceof LongField);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply(10.0));
     }
 
     public void testDoubleType() {
         DerivedFieldType dft = createDerivedFieldType("double");
-        assertTrue(dft.typeFieldMapper instanceof NumberFieldMapper);
-        assertTrue(dft.indexableFieldGenerator.apply(10.0) instanceof DoubleField);
-        expectThrows(Exception.class, () -> dft.indexableFieldGenerator.apply(""));
+        assertTrue(dft.getFieldMapper() instanceof NumberFieldMapper);
+        assertTrue(dft.getIndexableFieldGenerator().apply(10.0) instanceof DoubleField);
+        expectThrows(Exception.class, () -> dft.getIndexableFieldGenerator().apply(""));
     }
 
     public void testUnsupportedType() {
diff --git a/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java b/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
index 5a11ebebb312e..8c7685918cb3c 100644
--- a/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
+++ b/server/src/test/java/org/opensearch/index/query/DerivedFieldQueryTests.java
@@ -16,6 +16,7 @@
 import org.apache.lucene.index.IndexReader;
 import org.apache.lucene.index.IndexWriter;
 import org.apache.lucene.index.IndexWriterConfig;
+import org.apache.lucene.index.IndexableField;
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.TermQuery;
@@ -34,6 +35,7 @@
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Function;
 
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
@@ -76,18 +78,19 @@ public void execute() {
 
         // Create ValueFetcher from mocked DerivedFieldScript.Factory
         DerivedFieldScript.LeafFactory leafFactory = factory.newFactory((new Script("")).getParams(), searchLookup);
-        DerivedFieldValueFetcher valueFetcher = new DerivedFieldValueFetcher(
-            leafFactory,
-            null,
-            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType("keyword", "ip_from_raw_request")
+        Function<Object, IndexableField> indexableFieldFunction = DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(
+            "keyword",
+            "ip_from_raw_request"
         );
+        DerivedFieldValueFetcher valueFetcher = new DerivedFieldValueFetcher(leafFactory, null);
 
         // Create DerivedFieldQuery
         DerivedFieldQuery derivedFieldQuery = new DerivedFieldQuery(
             new TermQuery(new Term("ip_from_raw_request", "247.37.0.0")),
             valueFetcher,
             searchLookup,
-            Lucene.STANDARD_ANALYZER
+            Lucene.STANDARD_ANALYZER,
+            indexableFieldFunction
         );
 
         // Index and Search
diff --git a/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java b/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java
index 6a7bf10835ddd..3909fa2b7f6dd 100644
--- a/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java
+++ b/server/src/test/java/org/opensearch/index/query/QueryShardContextTests.java
@@ -67,6 +67,7 @@
 import org.opensearch.index.mapper.ContentPath;
 import org.opensearch.index.mapper.DerivedField;
 import org.opensearch.index.mapper.DerivedFieldMapper;
+import org.opensearch.index.mapper.DerivedFieldResolver;
 import org.opensearch.index.mapper.DocumentMapper;
 import org.opensearch.index.mapper.IndexFieldMapper;
 import org.opensearch.index.mapper.MappedFieldType;
@@ -130,12 +131,13 @@ public void testFailIfFieldMappingNotFound() {
     public void testDerivedFieldMapping() {
         QueryShardContext context = createQueryShardContext(IndexMetadata.INDEX_UUID_NA_VALUE, null);
         assertNull(context.failIfFieldMappingNotFound("test_derived", null));
-        context.setDerivedFieldTypes(null);
         assertNull(context.failIfFieldMappingNotFound("test_derived", null));
         DocumentMapper documentMapper = mock(DocumentMapper.class);
         Mapper.BuilderContext builderContext = new Mapper.BuilderContext(Settings.EMPTY, new ContentPath(0));
-        DerivedFieldMapper derivedFieldMapper = new DerivedFieldMapper.Builder(new DerivedField("test_derived", "keyword", new Script("")))
-            .build(builderContext);
+        DerivedFieldMapper derivedFieldMapper = new DerivedFieldMapper.Builder(
+            new DerivedField("test_derived", "keyword", new Script("")),
+            context.getIndexAnalyzers()
+        ).build(builderContext);
         MappingLookup mappingLookup = new MappingLookup(
             Collections.singletonList(derivedFieldMapper),
             Collections.emptyList(),
@@ -144,7 +146,9 @@ public void testDerivedFieldMapping() {
             new StandardAnalyzer()
         );
         when(documentMapper.mappers()).thenReturn(mappingLookup);
-        context.setDerivedFieldTypes(Map.of("test_derived", derivedFieldMapper.fieldType()));
+        context.setDerivedFieldResolver(
+            new DerivedFieldResolver(null, Map.of("test_derived", derivedFieldMapper.fieldType()), Collections.emptyList())
+        );
         context.setAllowUnmappedFields(false);
         assertEquals(derivedFieldMapper.fieldType(), context.failIfFieldMappingNotFound("test_derived", null));
     }
diff --git a/server/src/test/java/org/opensearch/search/SearchServiceTests.java b/server/src/test/java/org/opensearch/search/SearchServiceTests.java
index 7207df7d4d13d..5d91b8bf8a749 100644
--- a/server/src/test/java/org/opensearch/search/SearchServiceTests.java
+++ b/server/src/test/java/org/opensearch/search/SearchServiceTests.java
@@ -582,11 +582,12 @@ public void testDerivedFieldsSearch() throws IOException {
             try (SearchContext context = service.createContext(reader, request, null, randomBoolean())) {
                 assertNotNull(context);
                 for (int i = 0; i < 5; i++) {
-                    DerivedFieldType derivedFieldType = (DerivedFieldType) context.getQueryShardContext().getDerivedFieldType("field" + i);
+                    DerivedFieldType derivedFieldType = (DerivedFieldType) context.getQueryShardContext()
+                        .resolveDerivedFieldType("field" + i);
                     assertEquals("field" + i, derivedFieldType.name());
                     assertEquals("date", derivedFieldType.getType());
                 }
-                assertNull(context.getQueryShardContext().getDerivedFieldType("field" + 5));
+                assertNull(context.getQueryShardContext().resolveDerivedFieldType("field" + 5));
             }
         }
     }
diff --git a/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java b/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java
index 92127da9654aa..0bfbb7fcde27e 100644
--- a/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java
+++ b/server/src/test/java/org/opensearch/search/fetch/subphase/highlight/DerivedFieldFetchAndHighlightTests.java
@@ -28,6 +28,7 @@
 import org.opensearch.index.IndexSettings;
 import org.opensearch.index.mapper.ContentPath;
 import org.opensearch.index.mapper.DerivedField;
+import org.opensearch.index.mapper.DerivedFieldResolver;
 import org.opensearch.index.mapper.DerivedFieldSupportedTypes;
 import org.opensearch.index.mapper.DerivedFieldType;
 import org.opensearch.index.mapper.Mapper;
@@ -219,12 +220,16 @@ public void testDerivedFieldFromSearchMapping() throws IOException {
                 mockShardContext.lookup().source().setSegmentAndDocument(context, docId);
 
                 // This mock behavior is similar to adding derived fields in search request
-                mockShardContext.setDerivedFieldTypes(
-                    Map.of(
-                        DERIVED_FIELD_1,
-                        createDerivedFieldType(DERIVED_FIELD_1, "keyword", DERIVED_FIELD_SCRIPT_1),
-                        DERIVED_FIELD_2,
-                        createDerivedFieldType(DERIVED_FIELD_2, "keyword", DERIVED_FIELD_SCRIPT_2)
+                mockShardContext.setDerivedFieldResolver(
+                    new DerivedFieldResolver(
+                        mockShardContext,
+                        Map.of(
+                            DERIVED_FIELD_1,
+                            createDerivedFieldType(DERIVED_FIELD_1, "keyword", DERIVED_FIELD_SCRIPT_1),
+                            DERIVED_FIELD_2,
+                            createDerivedFieldType(DERIVED_FIELD_2, "keyword", DERIVED_FIELD_SCRIPT_2)
+                        ),
+                        null
                     )
                 );
 
@@ -359,8 +364,9 @@ private DerivedFieldType createDerivedFieldType(String name, String type, String
         when(context.path()).thenReturn(new ContentPath());
         return new DerivedFieldType(
             new DerivedField(name, type, new Script(ScriptType.INLINE, "mockscript", script, emptyMap())),
-            DerivedFieldSupportedTypes.getFieldMapperFromType(type, name, context),
-            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, name)
+            DerivedFieldSupportedTypes.getFieldMapperFromType(type, name, context, null),
+            DerivedFieldSupportedTypes.getIndexableFieldGeneratorType(type, name),
+            null
         );
     }
 }