Gets search request builder.

@param isSetExplain the is set explain
@param indices      the indices
@param types        the types
@return the search request builder
177910
public SearchRequestBuilder getSearchRequestBuilder(boolean isSetExplain,
            String[] indices, String[] types) {
        return getSearchRequestBuilder(isSetExplain, indices, types, null);
    }
1173719
def search(self, type, **args):
        """"""
        if type not in VALID_SEARCH_TYPES:
            raise GraphAPIError(
                "Valid types are: %s" % ", ".join(VALID_SEARCH_TYPES)
            )

        args["type"] = type
        return self.request(self.version + "/search/", args)
1279426
public SearchResponse searchAll(String[] indices, String[] types,
            AggregationBuilder[] aggregationBuilders) {
        return searchAll(indices, types, null, aggregationBuilders);
    }
759633
protected function __mfind($index, $type, $ids) {
        try {
            $docs = $this->client->mget([
                'index' => $index,
                'type' => $type,
                'body' => [
                    "ids" => $ids
                ]
            ]);
            $result = ['ids' => $ids, 'found' => [], 'missed' => [], 'docs' => []];
            $missed = [] + $ids;
            foreach ($docs['docs'] as $doc) {
                if ($doc['found']) {
                    $result['docs'][] = $doc;
                    $result['found'][] = $doc['_id'];
                    unset($missed[array_search($doc['_id'], $missed)]);
                }
            }
            $result['missed'] = $missed;
            return $this->_makeMultiGetResult($result);
        } catch (\Exception $e) {
            trigger_error($e->getMessage(), E_USER_WARNING);
            return null;
        }
    }
349171
public BulkRequestBuilder buildBulkIndexRequestBuilder(
            List<IndexRequestBuilder> indexRequestBuilderList) {
        BulkRequestBuilder bulkRequestBuilder = jmESClient.prepareBulk();
        for (IndexRequestBuilder indexRequestBuilder : indexRequestBuilderList)
            bulkRequestBuilder.add(indexRequestBuilder);
        return bulkRequestBuilder;
    }
409961
public function getSearchNodeBuilder($keywords, $type = null, $limit = null, $locale = null)
    {
        // Because of the searchable trait we have to reset global scopes
        $builder = PublishedNode::withoutGlobalScopes()
            ->published()
            ->typeMailing()
            ->translatedIn($locale)
            ->groupBy('nodes.id');

        if ($type)
        {
            $builder->withType($type);
        }

        if ($limit)
        {
            $builder->limit($limit);
        }

        $builder->search($keywords, 20, true);

        return $builder;
    }
893894
public SearchResponse searchAllWithTargetCount(String[] indices,
            String[] types, AggregationBuilder[] aggregationBuilders) {
        return searchAllWithTargetCount(indices, types, null,
                aggregationBuilders);
    }
599621
public static SemproxySearchResult semproxySearch(String accessToken, SemproxySearch semproxySearch) {
        return semproxySearch(accessToken, JsonUtil.toJSONString(semproxySearch));
    }
1335512
HttpUrl lenientSearch(List<String> indices, @Nullable String type) {
    HttpUrl.Builder builder = http.baseUrl.newBuilder().addPathSegment(join(indices));
    if (type != null) builder.addPathSegment(type);
    return builder.addPathSegment("_search")
                  // keep these in alphabetical order as it simplifies amazon signatures!
                  .addQueryParameter("allow_no_indices", "true")
                  .addQueryParameter("expand_wildcards", "open")
                  .addQueryParameter("ignore_unavailable", "true").build();
  }
385875
public <T> ESDatas<T> searchAllParallel(String index,  final int fetchSize ,ScrollHandler<T> scrollHandler,final Class<T> type,int max) throws ElasticSearchException{
		if(!this.client.isV1()) {
			SliceScroll sliceScroll = new SliceScroll() {
				@Override
				public String buildSliceDsl(int sliceId, int max) {
					StringBuilder builder = new StringBuilder();
					String sliceDsl = builder.append("{\"slice\": {\"id\": ").append(sliceId).append(",\"max\": ")
							.append(max).append("},\"size\":").append(fetchSize).append(",\"query\": {\"match_all\": {}},\"sort\": [\"_doc\"]}").toString();
					return sliceDsl;
//				return buildSliceDsl(i,max, params, dslTemplate);
				}
			};

			return _slice(index + "/_search", scrollHandler, type, max, "1m", sliceScroll);
		}
		else{
			StringBuilder builder = new StringBuilder();
			String queryAll = builder.append("{ \"size\":").append(fetchSize).append(",\"query\": {\"match_all\": {}},\"sort\": [\"_doc\"]}").toString();
			builder.setLength(0);
			return this.scrollParallel(builder.append(index).append("/_search").toString(),queryAll,"10m",type,scrollHandler);
		}

	}
104115
def get_search(self, query, type_=None):
    
    search_url = _S_SEARCH.format(c_api=_C_API_BEGINNING,
                                  api=_API_VERSION,
                                  query=_format_query(query),
                                  at=self.access_token)
    if type_ is not None:
      search_url + _TYPE_SUFFIX.format(type_=type_)
    return _get_request(search_url)
838769
public SearchResponse searchAll(String[] indices, String[] types,
            QueryBuilder filterQueryBuilder,
            AggregationBuilder[] aggregationBuilders) {
        return searchAll(false, indices, types, filterQueryBuilder,
                aggregationBuilders);
    }
909860
public static List<String> findTypes(String root, String index) throws IOException, URISyntaxException {
        if (root == null) {
            return findTypes(index);
        }

        logger.debug("Looking for types in classpath under [{}/{}].", root, index);

        final List<String> typeNames = new ArrayList<>();
        String[] resources = ResourceList.getResources(root + "/" + index + "/"); // "es/index/"
        for (String resource : resources) {
            if (!resource.isEmpty() && !root.equals(resource)) {
                String withoutIndex = resource.substring(resource.indexOf("/") + 1);
                if (withoutIndex.equals(Defaults.IndexSettingsFileName) ||
                        withoutIndex.equals(Defaults.UpdateIndexSettingsFileName)) {
                    logger.trace(" - ignoring: [{}]", withoutIndex);
                } else {
                    String type = withoutIndex.substring(0, withoutIndex.indexOf(Defaults.JsonFileExtension));
                    logger.trace(" - found [{}].", type);
                    typeNames.add(type);
                }
            }
        }

        return typeNames;
    }
289867
private static Method searchCandidates(List<Method> candidateMethods, Method bridgeMethod) {
		if (candidateMethods.isEmpty()) {
			return null;
		}
		Map<TypeVariable, Type> typeParameterMap = GenericTypeResolver.getTypeVariableMap(bridgeMethod.getDeclaringClass());
		Method previousMethod = null;
		boolean sameSig = true;
		for (Method candidateMethod : candidateMethods) {
			if (isBridgeMethodFor(bridgeMethod, candidateMethod, typeParameterMap)) {
				return candidateMethod;
			}
			else if (previousMethod != null) {
				sameSig = sameSig &&
						Arrays.equals(candidateMethod.getGenericParameterTypes(), previousMethod.getGenericParameterTypes());
			}
			previousMethod = candidateMethod;
		}
		return (sameSig ? candidateMethods.get(0) : null);
	}
116701
@SuppressWarnings("WeakerAccess")
	protected List<IBaseResource> toResourceList(ISearchBuilder sb, List<Long> pidsSubList) {
		Set<Long> includedPids = new HashSet<>();
		if (mySearchEntity.getSearchType() == SearchTypeEnum.SEARCH) {
			includedPids.addAll(sb.loadIncludes(myContext, myEntityManager, pidsSubList, mySearchEntity.toRevIncludesList(), true, mySearchEntity.getLastUpdated(), myUuid));
			includedPids.addAll(sb.loadIncludes(myContext, myEntityManager, pidsSubList, mySearchEntity.toIncludesList(), false, mySearchEntity.getLastUpdated(), myUuid));
		}

		// Execute the query and make sure we return distinct results
		List<IBaseResource> resources = new ArrayList<>();
		sb.loadResourcesByPid(pidsSubList, resources, includedPids, false, myEntityManager, myContext, myDao);

		return resources;
	}
1059466
public SearchResponse searchAllWithTargetCount(String index, String type,
            QueryBuilder filterQueryBuilder) {
        return searchAllWithTargetCount(index, type, filterQueryBuilder, null);
    }
1097034
@Override
	public CloseableIterator<CaptureSearchResult> getPrefixIterator(
			String prefix) throws ResourceIndexNotAvailableException {
		try {
			return adaptIterator(getStringPrefixIterator(prefix));
		} catch (IOException e) {
			throw new ResourceIndexNotAvailableException(e.getMessage());
		}
	}