Java AggregationOutput类代码示例

import com.mongodb.AggregationOutput; //导入依赖的package包/类
/**
 * 
 * @return number of total discovered links
 */
public Double getNumberOfDiscoveredLinks() {
	Double numberOfTriples = 0.0;
	try {
		DBCollection collection = DBSuperClass2.getDBInstance().getCollection(LinksetDB.COLLECTION_NAME);

		BasicDBObject groupFields = new BasicDBObject("_id", null);

		groupFields.append("sum", new BasicDBObject("$sum", "$links"));

		DBObject group = new BasicDBObject("$group", groupFields);

		// run aggregation
		List<DBObject> pipeline = Arrays.asList(group);
		AggregationOutput output = collection.aggregate(pipeline);

		for (DBObject result : output.results()) {
			numberOfTriples = Double.valueOf(result.get("sum").toString());
		}

	} catch (Exception e) {
		e.printStackTrace();
	}
	return numberOfTriples;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments,
    Class<?>[] argumentsTypes, Object ret) throws Throwable {
    AbstractSpan activeSpan = ContextManager.activeSpan();
    CommandResult cresult = null;
    if (ret instanceof WriteResult) {
        WriteResult wresult = (WriteResult)ret;
        cresult = wresult.getCachedLastError();
    } else if (ret instanceof AggregationOutput) {
        AggregationOutput aresult = (AggregationOutput)ret;
        cresult = aresult.getCommandResult();
    }
    if (null != cresult && !cresult.ok()) {
        activeSpan.log(cresult.getException());
    }
    ContextManager.stopSpan();
    return ret;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
private static Iterator<DBObject> setUpPipelineSample( String query, int numDocsToSample, DBCollection collection )
  throws KettleException {

  query = query + ", {$limit : " + numDocsToSample + "}"; //$NON-NLS-1$ //$NON-NLS-2$
  List<DBObject> samplePipe = jsonPipelineToDBObjectList( query );

  DBObject first = samplePipe.get( 0 );
  DBObject[] remainder = new DBObject[ samplePipe.size() - 1 ];
  for ( int i = 1; i < samplePipe.size(); i++ ) {
    remainder[ i - 1 ] = samplePipe.get( i );
  }

  AggregationOutput result = collection.aggregate( first, remainder );

  return result.results().iterator();
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Test public void testPipelineQueryIsLimited() throws KettleException, MongoDbException {
  setupPerform();

  AggregationOutput aggOutput = mock( AggregationOutput.class );
  Iterable<DBObject> results = mock( Iterable.class );
  when( aggOutput.results() ).thenReturn( results );
  when( results.iterator() ).thenReturn( mock( Iterator.class ) );

  String query = "{$sort : 1}";
  DBObject firstOp = (DBObject) JSON.parse( query );
  DBObject[] remainder = { new BasicDBObject( "$limit", NUM_DOCS_TO_SAMPLE ) };
  when( collection.aggregate( firstOp, remainder ) )
      .thenReturn( aggOutput );

  discoverFields.discoverFields( new MongoProperties.Builder(), "mydb", "mycollection", query, "", true,
      NUM_DOCS_TO_SAMPLE, inputMeta );

  verify( collection ).aggregate( firstOp, remainder );
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override
protected List<UPSSubscription> getSubscriptions(String uri) {
    List<UPSSubscription> subscriptions = new ArrayList<>();

    List<String> listenerPaths = generatePaths(uri);

    DBObject match = new BasicDBObject("$match", new BasicDBObject("subscriptions.resource-path", new BasicDBObject("$in", listenerPaths)));
    DBObject unwind = new BasicDBObject("$unwind", "$subscriptions");

    // first perform a match to get the object which contains a subscription we want [uses the index]
    // then unwind to get the individual subscriptions
    // then match again to get only the subscriptions we want.
    // NOTE: the first step is not redundant, we need to first narrow down using an index (for performance) before unwinding and ultimately getting only the results we want.
    AggregationOutput aggregate = collection.aggregate(match, unwind, match);
    for (DBObject dbObject : aggregate.results()) {
        UPSSubscription subscription = UPSSubscription.create((DBObject) dbObject.get("subscriptions"));
        if (subscription != null) {
            subscriptions.add(subscription);
        }
    }

    return subscriptions;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override
public Map<String, Id> fetchAllArticleNumbers() {
    Map<String, Id> articleNumbers = new LinkedHashMap<String, Id>();

    Id attributeId = Attributes.getAttributeId(Product.class, "article_number");

    // build the $projection operation
    DBObject fields = new BasicDBObject("attributes.attr_id", 1);
    fields.put("attributes.val.val", 1);
    DBObject project = new BasicDBObject("$project", fields);

    DBObject unwind = new BasicDBObject("$unwind", "$attributes");

    // create our pipeline operations, first with the $match
    DBObject match = new BasicDBObject("$match", new BasicDBObject("attributes.attr_id", attributeId));

    // build the $projection operation
    DBObject project2 = new BasicDBObject("$project", new BasicDBObject("an", "$attributes.val.val"));

    List<DBObject> pipeline = Arrays.asList(project, unwind, match, project2);

    AggregationOutput output = db(Product.class).getCollection(COLLECTION_NAME).aggregate(pipeline);

    for (DBObject result : output.results()) {
        if (result.get("an") != null) {
            articleNumbers.put(String.valueOf(((BasicDBList) result.get("an")).get(0)).trim(),
                Id.valueOf(result.get("_id")));
        }
    }

    return articleNumbers;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override
public Map<Id, String> fetchIdArticleNumberMap() {
    Map<Id, String> articleNumbers = new LinkedHashMap<Id, String>();

    Id attributeId = Attributes.getAttributeId(Product.class, "article_number");

    // build the $projection operation
    DBObject fields = new BasicDBObject("attributes.attr_id", 1);
    fields.put("attributes.val.val", 1);
    DBObject project = new BasicDBObject("$project", fields);

    DBObject unwind = new BasicDBObject("$unwind", "$attributes");

    // create our pipeline operations, first with the $match
    DBObject match = new BasicDBObject("$match", new BasicDBObject("attributes.attr_id", attributeId));

    // build the $projection operation
    DBObject project2 = new BasicDBObject("$project", new BasicDBObject("an", "$attributes.val.val"));

    List<DBObject> pipeline = Arrays.asList(project, unwind, match, project2);

    AggregationOutput output = db(Product.class).getCollection(COLLECTION_NAME).aggregate(pipeline);

    for (DBObject result : output.results()) {
        if (result.get("an") != null) {
            articleNumbers.put(Id.valueOf(result.get("_id")),
                String.valueOf(((BasicDBList) result.get("an")).get(0)).trim());
        }
    }

    return articleNumbers;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override
public List<String> getSuggestions(Id attributeId, String collectionName, String lang, String query) {
    DBObject val = new BasicDBObject("$elemMatch",
        new BasicDBObject("val", new BasicDBObject("$regex", "^" + query + ".*")));

    DBObject elemMathContent = new BasicDBObject("attr_id", attributeId);
    elemMathContent.put("val", val);

    DBObject elemMatch = new BasicDBObject("$elemMatch", elemMathContent);

    List<DBObject> alls = new ArrayList<>();
    alls.add(elemMatch);

    DBObject match = new BasicDBObject("$match", new BasicDBObject("attributes", new BasicDBObject("$all", alls)));

    DBObject matchAdditionalContent = new BasicDBObject("attributes.attr_id", attributeId);
    if (lang != null && !lang.isEmpty()) {
        matchAdditionalContent.put("attributes.val.l", lang);
    }
    matchAdditionalContent.put("attributes.val.val", new BasicDBObject("$regex", "^" + query + ".*"));

    DBObject matchAdditional = new BasicDBObject("$match", matchAdditionalContent);
    AggregationOutput output = ((DB) connections.getFirstConnection("mongodb")).getCollection(collectionName)
        .aggregate(match, new BasicDBObject("$unwind", "$attributes"),
            new BasicDBObject("$unwind", "$attributes.val"), matchAdditional,
            new BasicDBObject("$group", new BasicDBObject("_id", "$attributes.val.val")),
            new BasicDBObject("$sort", new BasicDBObject("_id", 1)));

    List<String> suggestions = new ArrayList<>();

    for (DBObject result : output.results()) {
        suggestions.add((String) result.get("_id"));
    }

    return suggestions;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
public Iterator<BasicDBObject> aggregate(String description, List<DBObject> pipeline) {
  if (log.isDebugEnabled()) {
    log.debug("--"+dbCollection.getName()+"-> "+description+" q="+toString(pipeline));
  }
  AggregationOutput aggregationOutput = dbCollection.aggregate(pipeline);
  return new LoggingIterator(this, aggregationOutput.results().iterator());
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
/**
 * 
 * @return number of total triples read
 */
public Double getNumberOfTriples() {
	Double numberOfTriples = 0.0;
	try {
		DBCollection collection = DBSuperClass2.getDBInstance().getCollection(DistributionDB.COLLECTION_NAME);

		BasicDBObject select = new BasicDBObject("$match",
				new BasicDBObject(DistributionDB.SUCCESSFULLY_DOWNLOADED, true));

		BasicDBObject groupFields = new BasicDBObject("_id", null);

		groupFields.append("sum", new BasicDBObject("$sum", "$triples"));

		DBObject group = new BasicDBObject("$group", groupFields);

		// run aggregation
		List<DBObject> pipeline = Arrays.asList(select, group);
		AggregationOutput output = collection.aggregate(pipeline);

		for (DBObject result : output.results()) {
			numberOfTriples = Double.valueOf(result.get("sum").toString());
		}

	} catch (Exception e) {
		e.printStackTrace();
	}
	return numberOfTriples;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
private void serializeLoadTimes(JsonGenerator jgen) throws IOException,
		JsonProcessingException {
	jgen.writeArrayFieldStart("LoadTimes");
	/**
	 * db.hubs.aggregate([ {$project: { "loadtimes" : 1}}, {$unwind :
	 * "$loadtimes"}, {$project: { "truckType" : "$loadtimes.truckType",
	 * "loadTime" : "$loadtimes.loadTime"}}])
	 */

	AggregationOutput agg = getDB().getCollection("hubs").aggregate(
			new BasicDBObject().append("$project",
					new BasicDBObject().append("loadtimes", 1)),
			new BasicDBObject().append("$unwind", "$loadtimes"),
			new BasicDBObject().append(
					"$project",
					new BasicDBObject().append("truckType",
							"$loadtimes.truckType").append("loadTime",
							"$loadtimes.loadTime")));

	for (DBObject obj : agg.results()) {
		jgen.writeStartObject();
		jgen.writeStringField("hub", obj.get("_id").toString());
		jgen.writeStringField("truckType", obj.get("truckType").toString());
		jgen.writeNumberField("loadTime",
				((Number) obj.get("loadTime")).intValue());
		jgen.writeEndObject();
	}
	jgen.writeEndArray();
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
private void serializeRoutes(JsonGenerator jgen) throws IOException,
		JsonProcessingException {
	jgen.writeArrayFieldStart("Routes");
	/**
	 * db.hubs.aggregate([ {$project: { "routes" : 1}}, {$unwind :
	 * "$routes"}, {$project: { "spoke" : "$routes.spoke", "distance" :
	 * "$routes.distance"}}])
	 */

	AggregationOutput agg = getDB().getCollection("hubs").aggregate(
			new BasicDBObject().append("$project",
					new BasicDBObject().append("routes", 1)),
			new BasicDBObject().append("$unwind", "$routes"),
			new BasicDBObject().append("$project",
					new BasicDBObject().append("spoke", "$routes.spoke")
							.append("distance", "$routes.distance")));

	for (DBObject obj : agg.results()) {
		jgen.writeStartObject();
		jgen.writeStringField("spoke", obj.get("spoke").toString());
		jgen.writeStringField("hub", obj.get("_id").toString());
		jgen.writeNumberField("distance",
				((Number) obj.get("distance")).intValue());
		jgen.writeEndObject();
	}
	jgen.writeEndArray();
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override
public Iterable<DBObject> results(){
    if(options == null){
        AggregationOutput output = coll.aggregate(pipeline);
        return output.results();
    }else{
        final Iterator<DBObject> it = coll.aggregate(pipeline, options);
        return new Iterable<DBObject>() {
            @Override
            public Iterator<DBObject> iterator() {
                return it;
            }
        };
    }
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
/**
 * Convert aggregation output to BasicDBList.
 *
 * @param aggregationOutput aggregation output
 * @return BasicDBList
 */
public static BasicDBList getAsBasicDBList(AggregationOutput aggregationOutput) {
    Validate.notNull(aggregationOutput, "aggregation output cannot be null");
    BasicDBList result = new BasicDBList();
    result.addAll(Lists.newArrayList(aggregationOutput.results()));
    return result;
}
 

import com.mongodb.AggregationOutput; //导入依赖的package包/类
@Override
<T> List<T> queryForList(QueryStatement queryStatement, Class<T> type) {
    DBCollection dbCollection = getDbCollection(queryStatement.getCollectionName());
    BasicDBList query = (BasicDBList) JSON_TO_DB_OBJECT_MARSHALLER.marshall(queryStatement.getPreparedQuery(),
            queryStatement.getParameters());
    AggregationOutput aggregationOutput = performAggregationQuery(dbCollection, query);
    BasicDBList source = getAsBasicDBList(aggregationOutput);
    List<T> result = convertList(type, source, queryStatement.getConverterClass(),
            queryStatement.getConverterMethod());
    return result != null ? result : Lists.<T>newArrayList();
}