import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
/**
 * Retrieve a {@link SearchScript} for later use.
 * @param compiledScript A previously compiled script.
 * @param lookup The object that ultimately allows access to search fields.
 * @param vars The variables to be used in the script.
 * @return An {@link SearchScript} with the currently specified variables.
 */
@Override
public SearchScript search(final CompiledScript compiledScript, final SearchLookup lookup, final Map<String, Object> vars) {
    return new SearchScript() {
        /**
         * Get the search script that will have access to search field values.
         * @param context The LeafReaderContext to be used.
         * @return A script that will have the search fields from the current context available for use.
         */
        @Override
        public LeafSearchScript getLeafSearchScript(final LeafReaderContext context) throws IOException {
            return new ScriptImpl((GenericElasticsearchScript) compiledScript.compiled(), vars, lookup.getLeafSearchLookup(context));
        }

        /**
         * Whether or not the score is needed.
         */
        @Override
        public boolean needsScores() {
            return ((GenericElasticsearchScript) compiledScript.compiled()).uses$_score();
        }
    };
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, final SearchLookup lookup, @Nullable final Map<String, Object> vars) {
    final NativeScriptFactory scriptFactory = (NativeScriptFactory) compiledScript.compiled();
    final AbstractSearchScript script = (AbstractSearchScript) scriptFactory.newScript(vars);
    return new SearchScript() {
        @Override
        public LeafSearchScript getLeafSearchScript(LeafReaderContext context) throws IOException {
            script.setLookup(lookup.getLeafSearchLookup(context));
            return script;
        }
        @Override
        public boolean needsScores() {
            return scriptFactory.needsScores();
        }
    };
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
protected <A extends Aggregator, B extends AggregationBuilder> A createAggregator(B aggregationBuilder,
                                                                                  IndexSearcher indexSearcher,
                                                                                  MappedFieldType... fieldTypes) throws IOException {
    IndexSettings indexSettings = createIndexSettings();
    SearchContext searchContext = createSearchContext(indexSearcher, indexSettings);
    CircuitBreakerService circuitBreakerService = new NoneCircuitBreakerService();
    when(searchContext.bigArrays()).thenReturn(new MockBigArrays(Settings.EMPTY, circuitBreakerService));
    // TODO: now just needed for top_hits, this will need to be revised for other agg unit tests:
    MapperService mapperService = mapperServiceMock();
    when(mapperService.hasNested()).thenReturn(false);
    when(searchContext.mapperService()).thenReturn(mapperService);
    IndexFieldDataService ifds = new IndexFieldDataService(indexSettings,
            new IndicesFieldDataCache(Settings.EMPTY, new IndexFieldDataCache.Listener() {
            }), circuitBreakerService, mapperService);
    when(searchContext.fieldData()).thenReturn(ifds);

    SearchLookup searchLookup = new SearchLookup(mapperService, ifds, new String[]{"type"});
    when(searchContext.lookup()).thenReturn(searchLookup);

    QueryShardContext queryShardContext = queryShardContextMock(fieldTypes, indexSettings, circuitBreakerService);
    when(searchContext.getQueryShardContext()).thenReturn(queryShardContext);

    @SuppressWarnings("unchecked")
    A aggregator = (A) aggregationBuilder.build(searchContext, null).create(null, true);
    return aggregator;
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, final SearchLookup lookup, @Nullable final Map<String, Object> vars) {
    final NativeScriptFactory scriptFactory = (NativeScriptFactory) compiledScript.compiled();
    return new SearchScript() {
        @Override
        public LeafSearchScript getLeafSearchScript(LeafReaderContext context) throws IOException {
            AbstractSearchScript script = (AbstractSearchScript) scriptFactory.newScript(vars);
            script.setLookup(lookup.getLeafSearchLookup(context));
            return script;
        }
        @Override
        public boolean needsScores() {
            return scriptFactory.needsScores();
        }
    };
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, final SearchLookup lookup, @Nullable final Map<String, Object> vars) {
    final VectorScoreScript.Factory scriptFactory = (VectorScoreScript.Factory) compiledScript.compiled();
    final VectorScoreScript script = (VectorScoreScript) scriptFactory.newScript(vars);
    return new SearchScript() {
        @Override
        public LeafSearchScript getLeafSearchScript(LeafReaderContext context) throws IOException {
            script.setBinaryEmbeddingReader(context.reader().getBinaryDocValues(script.field));
            return script;
        }
        @Override
        public boolean needsScores() {
            return scriptFactory.needsScores();
        }
    };
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@SuppressWarnings({"unchecked"})
@Override
public SearchScript search(final CompiledScript compiledScript, final SearchLookup lookup, @Nullable final Map<String, Object> vars) {
    return new SearchScript() {

        @Override
        public LeafSearchScript getLeafSearchScript(LeafReaderContext context) throws IOException {
            final LeafSearchLookup leafLookup = lookup.getLeafSearchLookup(context);
            boolean debug = true;
            if (vars != null && vars.containsKey("debug")) {
                debug = (Boolean)vars.get("debug");
            }
            return ((Factory) compiledScript.compiled()).newScript(leafLookup, debug);
        }

        @Override
        public boolean needsScores() {
            // TODO: can we reliably know if a vectorizer script does not make use of _score
            return false;
        }
    };
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
private static AbstractJavaScript newInstance(Object compiledScript, Map<String, Object> vars, SearchLookup lookup) {
	try {
		Class<?> scriptClass = (Class<?>) compiledScript;
		AbstractJavaScript script = (AbstractJavaScript) scriptClass.newInstance();

		if (vars != null) {
			for (Entry<String, Object> entry : vars.entrySet()) {
				script.setNextVar(entry.getKey(), entry.getValue());
			}
		}

		if (lookup != null) {
			script.setLookup(lookup);
		}

		return script;
	} catch (Exception e) {
		throw new ScriptException("Failed to instantiate script class: " + compiledScript, e);
	}
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
    super.setUp();
    IndexService index = createIndex("test", Settings.EMPTY, "type", "d", "type=double");
    service = new ExpressionScriptEngineService(Settings.EMPTY);
    lookup = new SearchLookup(index.mapperService(), index.fieldData(), null);
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
public void testNeedsScores() {
    IndexService index = createIndex("test", Settings.EMPTY, "type", "d", "type=double");

    PainlessScriptEngineService service = new PainlessScriptEngineService(Settings.EMPTY);
    SearchLookup lookup = new SearchLookup(index.mapperService(), index.fieldData(), null);

    Object compiled = service.compile(null, "1.2", Collections.emptyMap());
    SearchScript ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                                     lookup, Collections.<String, Object>emptyMap());
    assertFalse(ss.needsScores());

    compiled = service.compile(null, "doc['d'].value", Collections.emptyMap());
    ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                        lookup, Collections.<String, Object>emptyMap());
    assertFalse(ss.needsScores());

    compiled = service.compile(null, "1/_score", Collections.emptyMap());
    ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                        lookup, Collections.<String, Object>emptyMap());
    assertTrue(ss.needsScores());

    compiled = service.compile(null, "doc['d'].value * _score", Collections.emptyMap());
    ss = service.search(new CompiledScript(ScriptType.INLINE, "randomName", "painless", compiled),
                        lookup, Collections.<String, Object>emptyMap());
    assertTrue(ss.needsScores());
    service.close();
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
public SearchScript createSearchScript(Map<String, Object> vars, SearchLookup lookup) {
    Map<String, Object> context = new HashMap<>();
    if (params != null) {
        context.putAll(params);
    }
    if (vars != null) {
        context.putAll(vars);
    }
    return new MockSearchScript(lookup, context, script != null ? script : ctx -> source);
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup,
        @Nullable Map<String, Object> vars) {
    throw new UnsupportedOperationException();
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup, @Nullable Map<String, Object> vars) {
    MockCompiledScript compiled = (MockCompiledScript) compiledScript.compiled();
    return compiled.createSearchScript(vars, lookup);
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
public MockSearchScript(SearchLookup lookup, Map<String, Object> vars, Function<Map<String, Object>, Object> script) {
    this.lookup = lookup;
    this.vars = vars;
    this.script = script;
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
/**
 * Compiles (or retrieves from cache) and executes the provided search script
 */
public SearchScript search(SearchLookup lookup, Script script, ScriptContext scriptContext) {
    CompiledScript compiledScript = compile(script, scriptContext);
    return search(lookup, compiledScript, script.getParams());
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchLookup lookup() {
    return in.lookup();
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
public SearchLookup lookup() {
    return getQueryShardContext().lookup();
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup, @Nullable Map<String, Object> vars) {
    return null;
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup, Map<String, Object> vars) {
    throw new UnsupportedOperationException();
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup, Map<String, Object> vars) {
    final long inc;
    if (vars == null || vars.containsKey("inc") == false) {
        inc = 0;
    } else {
        inc = ((Number) vars.get("inc")).longValue();
    }
    return new SearchScript() {

        private Map<String, Object> vars = new HashMap<>(2);

        @Override
        public LeafSearchScript getLeafSearchScript(LeafReaderContext context) throws IOException {

            final LeafSearchLookup leafLookup = lookup.getLeafSearchLookup(context);

            return new LeafSearchScript() {
                @Override
                public void setNextVar(String name, Object value) {
                    vars.put(name, value);
                }

                @Override
                public Object run() {
                    throw new UnsupportedOperationException();
                }

                @Override
                public void setScorer(Scorer scorer) {
                }

                @Override
                public void setSource(Map<String, Object> source) {
                }

                @Override
                public void setDocument(int doc) {
                    if (leafLookup != null) {
                        leafLookup.setDocument(doc);
                    }
                }

                @Override
                public long runAsLong() {
                    return ((Number) vars.get("_value")).longValue() + inc;
                }

                @Override
                public double runAsDouble() {
                    return ((Number) vars.get("_value")).doubleValue() + inc;
                }
            };
        }

        @Override
        public boolean needsScores() {
            return false;
        }
    };
}
 

import org.elasticsearch.search.lookup.SearchLookup; //导入依赖的package包/类
@Override
public SearchScript search(CompiledScript compiledScript, SearchLookup lookup, Map<String, Object> vars) {
    throw new UnsupportedOperationException("search script not supported");
}