Gets search request builder with match all.

@param isSetExplain the is set explain
@param indices      the indices
@param types        the types
@return the search request builder with match all
769872
public SearchRequestBuilder getSearchRequestBuilderWithMatchAll(
            boolean isSetExplain, String[] indices, String[] types) {
        return getSearchRequestBuilderWithMatchAll(isSetExplain, indices, types,
                null, null);
    }
349171
public BulkRequestBuilder buildBulkIndexRequestBuilder(
            List<IndexRequestBuilder> indexRequestBuilderList) {
        BulkRequestBuilder bulkRequestBuilder = jmESClient.prepareBulk();
        for (IndexRequestBuilder indexRequestBuilder : indexRequestBuilderList)
            bulkRequestBuilder.add(indexRequestBuilder);
        return bulkRequestBuilder;
    }
115432
public <T> ESDatas<T> searchAll(String index,  Class<T> type) throws ElasticSearchException{

		return searchAll(  index,    DEFAULT_FETCHSIZE , type) ;

	}
472607
public static <T extends MethodDescription> ElementMatcher.Junction<T> isGetter(TypeDescription type) {
        return isGetter(is(type));
    }
418145
Object getIndexedType(int index)
    {
        Object ae = indexedElementMap.get(index);
        if (ae == null)
        {
            throw new VerifyError("constant pool at "+index+" not proper type");
        }
        return ae;
    }
1063767
private static IndexedTypeSet toRootEntities(ExtendedSearchIntegrator extendedIntegrator, Class<?>... selection) {
		Set<Class<?>> entities = new HashSet<Class<?>>();
		//first build the "entities" set containing all indexed subtypes of "selection".
		for ( Class<?> entityType : selection ) {
			IndexedTypeSet targetedClasses = extendedIntegrator.getIndexedTypesPolymorphic( IndexedTypeSets.fromClass( entityType ) );
			if ( targetedClasses.isEmpty() ) {
				String msg = entityType.getName() + " is not an indexed entity or a subclass of an indexed entity";
				throw new IllegalArgumentException( msg );
			}
			entities.addAll( targetedClasses.toPojosSet() );
		}
		Set<Class<?>> cleaned = new HashSet<Class<?>>();
		Set<Class<?>> toRemove = new HashSet<Class<?>>();
		//now remove all repeated types to avoid duplicate loading by polymorphic query loading
		for ( Class<?> type : entities ) {
			boolean typeIsOk = true;
			for ( Class<?> existing : cleaned ) {
				if ( existing.isAssignableFrom( type ) ) {
					typeIsOk = false;
					break;
				}
				if ( type.isAssignableFrom( existing ) ) {
					toRemove.add( existing );
				}
			}
			if ( typeIsOk ) {
				cleaned.add( type );
			}
		}
		cleaned.removeAll( toRemove );
		log.debugf( "Targets for indexing job: %s", cleaned );
		return IndexedTypeSets.fromClasses( cleaned.toArray( new Class[cleaned.size()] ) );
	}
317708
public final SearchIndexBuilder extendSearchIndex(SearchIndexBuilder sib) {
        if (asJob().isBuildable() && asJob().hasPermission(Item.BUILD)) {
            sib.add("build", "build");
        }
        return sib;
    }
1355313
public SearchResponse searchAllWithTargetCount(String[] indices,
            String[] types, QueryBuilder filterQueryBuilder) {
        return searchAllWithTargetCount(indices, types, filterQueryBuilder,
                null);
    }
1345551
public function searchIn($index, $type = null)
	{
		// Reset the current state, in case the same instance is re-used.
		$this->indices = [];
		$this->types = [];

		$this->searchInIndices((array) $index);

		if ($type !== null) {
			$this->searchInTypes((array) $type);
		}
	}
989590
public static List<Match> searchPlain(Collection<? extends BioPAXElement> eles, Pattern pattern)
	{
		List<Match> list = new LinkedList<Match>();

		Map<BioPAXElement, List<Match>> map = search(eles, pattern);
		for (List<Match> matches : map.values())
		{
			list.addAll(matches);
		}
		return list;
	}
893894
public SearchResponse searchAllWithTargetCount(String[] indices,
            String[] types, AggregationBuilder[] aggregationBuilders) {
        return searchAllWithTargetCount(indices, types, null,
                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;
    }
971586
public BType getBuilder(int index) {
    ensureBuilders();
    SingleFieldBuilder<MType, BType, IType> builder = builders.get(index);
    if (builder == null) {
      MType message = messages.get(index);
      builder = new SingleFieldBuilder<MType, BType, IType>(
          message, this, isClean);
      builders.set(index, builder);
    }
    return builder.getBuilder();
  }
296380
public <T> ESDatas<T> searchAllParallel(String index,  int fetchSize ,Class<T> type,int thread) throws ElasticSearchException{
		return searchAllParallel(index,  fetchSize,(ScrollHandler<T>)null,type,thread);
	}
743113
public static String getElasticSearchBulkHeader(SimpleDataEvent event, String index, String type) {
    StringBuilder builder = new StringBuilder();
    builder.append("{\"index\":{\"_index\":\"");
    builder.append(index);
    builder.append("\",\"_type\":\"");
    builder.append(type);
    builder.append("\",\"_id\":\"");
    builder.append(event.getId());
    builder.append("\"}}");
    return builder.toString();
  }
29594
private QueryBuilderKraken parseExplain()
  {
    Token token = scanToken();
    
    if (token != Token.SELECT) {
      throw error("Explain requires SELECT at {0}", token);
    }
    
    return parseSelect(new QueryBuilderExplain(_tableManager, _sql));
  }
1312216
public SearchResponse searchAll(String index, String type,
            AggregationBuilder[] aggregationBuilders) {
        return searchAll(index, type, null, aggregationBuilders);
    }