Extract id list list.

@param index              the index
@param type               the type
@param filterQueryBuilder the filter query builder
@return the list
547197
public List<String> extractIdList(String index, String type,
            QueryBuilder filterQueryBuilder) {
        return extractIdList(
                searchAllWithTargetCount(index, type, filterQueryBuilder));
    }
1134826
public List<? extends Element> getMemberList(Character index) {
        SortedSet<Element> set = indexmap.get(index);
        if (set == null)
            return null;
        List<Element> out = new ArrayList<>();
        out.addAll(set);
        return out;
    }
214403
public TypeResults extractTypes(Multimap<Predicate, CQIE> ruleIndex, List<Predicate> predicatesInBottomUp, DBMetadata metadata)
            throws IncompatibleTermException {
        ImmutableMap<CQIE, ImmutableList<Optional<TermType>>> termTypeMap = extractTermTypeMap(ruleIndex.values());

        return new TypeResults(termTypeMap,
                extractCastTypeMap(ruleIndex, predicatesInBottomUp, termTypeMap, metadata));
    }
111560
public com.google.appengine.v1.ServiceOrBuilder getServicesOrBuilder(
      int index) {
    return services_.get(index);
  }
373075
private function getIdsQuery(
        $depth = 0,
        $filter = [],
        $sortBy = [],
        CollectionInterface $collection = null,
        $select = 'collection.id'
    ) {
        $queryBuilder = $this->createQueryBuilder('collection')
            ->select($select)
            ->where('collection.depth <= :depth');

        $collectionDepth = null !== $collection ? $collection->getDepth() : 0;
        $queryBuilder->setParameter('depth', $collectionDepth + $depth);

        if (null !== $collection) {
            $queryBuilder->andWhere('collection.lft BETWEEN :lft AND :rgt AND collection.id != :id');
            $queryBuilder->setParameter('lft', $collection->getLft());
            $queryBuilder->setParameter('rgt', $collection->getRgt());
            $queryBuilder->setParameter('id', $collection->getId());
        }

        if (array_key_exists('search', $filter) && null !== $filter['search'] ||
            array_key_exists('locale', $filter) ||
            count($sortBy) > 0
        ) {
            $queryBuilder->leftJoin('collection.meta', 'collectionMeta');
            $queryBuilder->leftJoin('collection.defaultMeta', 'defaultMeta');
        }

        if (array_key_exists('search', $filter) && null !== $filter['search']) {
            $queryBuilder->andWhere('collectionMeta.title LIKE :search OR defaultMeta.locale != :locale');
            $queryBuilder->setParameter('search', '%' . $filter['search'] . '%');
        }

        if (array_key_exists('locale', $filter)) {
            $queryBuilder->andWhere('collectionMeta.locale = :locale OR defaultMeta.locale != :locale');
            $queryBuilder->setParameter('locale', $filter['locale']);
        }

        if (array_key_exists('systemCollections', $filter) && !$filter['systemCollections']) {
            $queryBuilder->leftJoin('collection.type', 'collectionType');
            $queryBuilder->andWhere('collectionType.key != :type');
            $queryBuilder->setParameter('type', SystemCollectionManagerInterface::COLLECTION_TYPE);
        }

        if (count($sortBy) > 0) {
            foreach ($sortBy as $column => $order) {
                $queryBuilder->addOrderBy(
                    'collectionMeta.' . $column,
                    ('asc' === strtolower($order) ? 'ASC' : 'DESC')
                );
            }
        }

        $queryBuilder->addOrderBy('collection.id', 'ASC');

        if (array_key_exists('limit', $filter)) {
            $queryBuilder->setMaxResults($filter['limit']);
        }
        if (array_key_exists('offset', $filter)) {
            $queryBuilder->setFirstResult($filter['offset']);
        }

        return $queryBuilder->getQuery();
    }
251048
public List<Long> selectPostIds(EnumSet<Post.Type> types) throws SQLException {

      if(types == null || types.isEmpty()) {
         return selectPostIds();
      }

      List<Long> ids = Lists.newArrayListWithExpectedSize(4096);
      Connection conn = null;
      Statement stmt = null;
      ResultSet rs = null;

      String typesIn = inJoiner.join(types.stream().map(t -> String.format("'%s'", t.toString())).collect(Collectors.toSet()));

      try {
         conn = connectionSupplier.getConnection();
         stmt = conn.createStatement();
         rs = stmt.executeQuery(String.format(selectAllPostIdsTypeSQL, typesIn));
         while(rs.next()) {
            ids.add(rs.getLong(1));
         }
      } finally {
         SQLUtil.closeQuietly(conn, stmt, rs);
      }
      return ids;
   }
769872
public SearchRequestBuilder getSearchRequestBuilderWithMatchAll(
            boolean isSetExplain, String[] indices, String[] types) {
        return getSearchRequestBuilderWithMatchAll(isSetExplain, indices, types,
                null, null);
    }
896858
public static <T extends Entity<?>> List<?> extractIds(Collection<T> entities) {
    List<Object> idList = CollectUtils.newArrayList();
    for (Iterator<T> iter = entities.iterator(); iter.hasNext();) {
      Entity<?> element = iter.next();
      try {
        idList.add(PropertyUtils.getProperty(element, "id"));
      } catch (Exception e) {
        logger.error("getProperty error", e);
        continue;
      }
    }
    return idList;
  }
1340312
public alluxio.grpc.MasterInfoField getFilter(int index) {
    return filter_converter_.convert(filter_.get(index));
  }
105718
public SearchResponse searchAll(boolean isSetExplain, String[] indices,
            String[] types, QueryBuilder filterQueryBuilder) {
        return searchAll(isSetExplain, indices, types,
                filterQueryBuilder, null);
    }
253879
public <S> List<S> queryList(Class<S> type, String sql, Object[] params) {
        Connection conn = getConn();
        try {
            return conn.createQuery(sql)
                    .withParams(params)
                    .setColumnMappings(computeModelColumnMappings(type))
                    .throwOnMappingFailure(false)
                    .executeAndFetch(type);
        } finally {
            this.closeConn(conn);
            this.clean(null);
        }
    }
1099899
public SearchRequestBuilder getSearchRequestBuilder(QueryBuilder
            queryBuilder, String... indices) {
        return getSearchRequestBuilder(indices, null, queryBuilder);
    }
1139832
public IndexResponse sendData(Map<String, ?> source, String index,
            String type, String id) {
        return indexQuery(buildIndexRequest(source, index, type, id));
    }
296822
public TypedQuery<T> select(Filter filter, OrderBy orderBy) {
        CriteriaQuery<T> query = cb.createQuery(getEntityClass());
        Root<T> from = query.from(getEntityClass());

        CriteriaMapper criteriaMapper = new CriteriaMapper(from, cb);

        if (orderBy != null) {
            query.orderBy(criteriaMapper.create(orderBy));
        }
        if (filter != null) {
            query.where(criteriaMapper.create(filter));
        }

        return getEntityManager().createQuery(query);
    }
1086627
private <T extends Index> List<T> listIndexType(String type, Class<T> modelType) {
        List<T> indexesOfType = new ArrayList<T>();
        Gson g = new Gson();
        for (JsonElement index : indexes) {
            if (index.isJsonObject()) {
                JsonObject indexDefinition = index.getAsJsonObject();
                JsonElement indexType = indexDefinition.get("type");
                if (indexType != null && indexType.isJsonPrimitive()) {
                    JsonPrimitive indexTypePrimitive = indexType.getAsJsonPrimitive();
                    if (type == null || (indexTypePrimitive.isString() && indexTypePrimitive
                            .getAsString().equals(type))) {
                        indexesOfType.add(g.fromJson(indexDefinition, modelType));
                    }
                }
            }
        }
        return indexesOfType;
    }
1204021
protected void appendFilterQuery(SolrQuery solrQuery, List<FilterQuery> filterQueries,
			@Nullable Class<?> domainType) {

		if (CollectionUtils.isEmpty(filterQueries)) {
			return;
		}

		List<String> filterQueryStrings = getFilterQueryStrings(filterQueries, domainType);

		if (!filterQueryStrings.isEmpty()) {
			solrQuery.setFilterQueries(convertStringListToArray(filterQueryStrings));
		}
	}
255092
public static Type getTypeArgument(Type type, int index) {
		final Type[] typeArguments = getTypeArguments(type);
		if (null != typeArguments && typeArguments.length > index) {
			return typeArguments[index];
		}
		return null;
	}