Java BasicDBObjectBuilder.start方法代码示例

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
private DBObject createBetweenFilter(Object value) {
    JSONObject dateRange = parseDateRange(value);

    org.joda.time.format.DateTimeFormatter parser = ISODateTimeFormat.dateTime();

    BasicDBObjectBuilder start = BasicDBObjectBuilder.start();

    if (dateRange.get("startDate") != null) {
        DateTime startDate = parser.parseDateTime((String) dateRange.get("startDate"));
        start.add(QueryOperators.GTE, startDate.toDate());
    }

    if (dateRange.get("endDate") != null) {
        DateTime endDate = parser.parseDateTime((String) dateRange.get("endDate"));
        start.add(QueryOperators.LTE, endDate.toDate());
    }

    return start.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
private static DBObject toDBObject(final PCJIndexDetails pcjIndexDetails) {
    requireNonNull(pcjIndexDetails);

    final BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();

    // Is Enabled
    builder.add(PCJ_ENABLED_KEY, pcjIndexDetails.isEnabled());

    // Add the PCJDetail objects.
    final List<DBObject> pcjDetailsList = new ArrayList<>();
    for(final PCJDetails pcjDetails : pcjIndexDetails.getPCJDetails().values()) {
        pcjDetailsList.add( toDBObject( pcjDetails ) );
    }
    builder.add(PCJ_PCJS_KEY, pcjDetailsList.toArray());

    return builder.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
/**
 * Serializes a {@link DocumentVisibility} to a MongoDB {@link DBObject}.
 * @param documentVisibility the {@link DocumentVisibility} to be
 * serialized.
 * @return The MongoDB {@link DBObject}.
 */
public static BasicDBObject toDBObject(final DocumentVisibility documentVisibility) {
    DocumentVisibility dv;
    if (documentVisibility == null) {
        dv = MongoDbRdfConstants.EMPTY_DV;
    } else {
        dv = documentVisibility;
    }
    Object[] dvArray = null;
    try {
        dvArray = DocumentVisibilityUtil.toMultidimensionalArray(dv);
    } catch (final DocumentVisibilityConversionException e) {
        log.error("Unable to convert document visibility");
    }

    final BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();
    builder.add(DOCUMENT_VISIBILITY_KEY, dvArray);
    return (BasicDBObject) builder.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
@Override
public DBObject serialize(final RyaStatement ryaStatement) {
    final BasicDBObjectBuilder builder = BasicDBObjectBuilder.start("_id", ryaStatement.getSubject().hashCode());
    final URI obj = ryaStatement.getObject().getDataType();


    if(obj.equals(GeoConstants.GEO_AS_WKT) || obj.equals(GeoConstants.GEO_AS_GML) ||
       obj.equals(GeoConstants.XMLSCHEMA_OGC_GML) || obj.equals(GeoConstants.XMLSCHEMA_OGC_WKT)) {
        try {
            final Statement statement = RyaToRdfConversions.convertStatement(ryaStatement);
            final Geometry geo = GeoParseUtils.getGeometry(statement, new GmlParser());
            if (geo.getNumPoints() > 1) {
                builder.add(GEO_KEY, geoStrategy.getCorrespondingPoints(geo));
            } else {
                builder.add(GEO_KEY, geoStrategy.getDBPoint(geo));
            }
        } catch (final ParseException e) {
            LOG.error("Could not create geometry for statement " + ryaStatement, e);
            return null;
        }
    } else {
        builder.add(TIME_KEY, temporalStrategy.getTimeValue(ryaStatement.getObject().getData()));
    }
    return builder.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
/** {@inheritDoc} */
@Override
public void initialize() {
    // Make sure the fields we want to query are indexed
    DBCollection assets = db.getCollection(ASSETS_COLLECTION);
    DBCollection attachments = db.getCollection(ATTACHMENTS_COLLECTION);

    // Add text index
    BasicDBObjectBuilder textIndex = BasicDBObjectBuilder.start();
    for (String indexField : searchIndexFields) {
        textIndex.add(indexField, "text");
    }
    assets.ensureIndex(textIndex.get());

    // Add Attachment(assetId) index
    attachments.ensureIndex(new BasicDBObject("assetId", 1));
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
@Override
public DBCursor getData(String driverId, String test, String testRun, String sheetName)
{
    // check params
    checkMandatoryString(test, "test");
    checkMandatoryString(testRun, "testRun");
    checkMandatoryString(sheetName, "sheetName");

    // create query
    BasicDBObjectBuilder queryObjBuilder = BasicDBObjectBuilder.start();
    if (null != driverId && !driverId.isEmpty())
    {
        queryObjBuilder.add(FIELD_DRIVER_ID, driverId);
    }
    queryObjBuilder.add(FIELD_TEST, test).add(FIELD_TEST_RUN, testRun).add(FIELD_SHEET_NAME, sheetName);
    DBObject queryObj = queryObjBuilder.get();

    
    // sort and return cursor
    DBCursor dbCursor = this.collectionExtraData.find(queryObj);
    
    return dbCursor;
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
@Override
public long countUsers(String domain, DataCreationState creationState)
{
    BasicDBObjectBuilder queryObjBuilder = BasicDBObjectBuilder.start();
    if (domain != null)
    {
        queryObjBuilder.add(FIELD_DOMAIN, domain);
    }
    if (creationState != null)
    {
        queryObjBuilder.add(FIELD_CREATION_STATE, creationState.toString());
    }
    DBObject queryObj = queryObjBuilder.get();
    
    return collection.count(queryObj);
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
@Override
public void addTo(final DBObject obj) {
    BasicDBObjectBuilder query;
    FilterOperator operator = getOperator();

    switch (operator) {
        case NEAR:
            if (maxDistanceMeters != null) {
                geometryAsDBObject.put("$maxDistance", maxDistanceMeters);
            }
            query = BasicDBObjectBuilder.start(NEAR.val(), geometryAsDBObject);
            break;
        case GEO_WITHIN:
        case INTERSECTS:
            query = BasicDBObjectBuilder.start(operator.val(), geometryAsDBObject);
            if (crs != null) {
                ((DBObject) geometryAsDBObject.get("$geometry")).put("crs", new NamedCoordinateReferenceSystemConverter().encode(crs));
            }
            break;
        default:
            throw new UnsupportedOperationException(String.format("Operator %s not supported for geo-query", operator.val()));
    }

    obj.put(getField(), query.get());
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
private BasicDBObject parseFieldsString(final String fields) {
    BasicDBObjectBuilder ret = BasicDBObjectBuilder.start();
    final String[] parts = fields.split(",");
    for (String s : parts) {
        s = s.trim();
        int dir = 1;
        if (s.startsWith("-")) {
            dir = -1;
            s = s.substring(1).trim();
        }
        ret = ret.add(s, dir);
    }
    return (BasicDBObject) ret.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
public DBObject getTimeValue(final String timeData) {
    final Matcher match = TemporalInstantRfc3339.PATTERN.matcher(timeData);
    final BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();
    if(match.find()) {
        final TemporalInterval date = TemporalInstantRfc3339.parseInterval(timeData);
        builder.add(INTERVAL_START, date.getHasBeginning().getAsDateTime().toDate());
        builder.add(INTERVAL_END, date.getHasEnd().getAsDateTime().toDate());
    } else {
        builder.add(INSTANT, TemporalInstantRfc3339.FORMATTER.parseDateTime(timeData).toDate());
    }
    return builder.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
@Override
public Collection<Event> search(final Optional<RyaURI> subject, final Optional<Collection<IndexingExpr>> geoFilters, final Optional<Collection<IndexingExpr>> temporalFilters) throws EventStorageException {
    requireNonNull(subject);

    try {
        final Collection<IndexingExpr> geos = (geoFilters.isPresent() ? geoFilters.get() : new ArrayList<>());
        final Collection<IndexingExpr> tempos = (temporalFilters.isPresent() ? temporalFilters.get() : new ArrayList<>());
        final DBObject filterObj = queryAdapter.getFilterQuery(geos, tempos);

        final BasicDBObjectBuilder builder = BasicDBObjectBuilder
        .start(filterObj.toMap());
        if(subject.isPresent()) {
            builder.append(EventDocumentConverter.SUBJECT, subject.get().getData());
        }
        final MongoCursor<Document> results = mongo.getDatabase(ryaInstanceName)
            .getCollection(COLLECTION_NAME)
            .find( BsonDocument.parse(builder.get().toString()) )
            .iterator();

        final List<Event> events = new ArrayList<>();
        while(results.hasNext()) {
            events.add(EVENT_CONVERTER.fromDocument(results.next()));
        }
        return events;
    } catch(final MongoException | DocumentConverterException | GeoTemporalIndexException e) {
        throw new EventStorageException("Could not get the Event.", e);
    }
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
@Override
public boolean apply(JID invoker, JID group, Fields fields) {
	DBObject entity = super.entities(fields, BasicDBObjectBuilder.start());
	try {
		// {"jid":to.bare,"informations.jid":from.bare},{"$set":{"infomrations.$.information":..entity..}}
		this.config.collection().update(BasicDBObjectBuilder.start().add(Dictionary.FIELD_JID, group.asStringWithBare()).add(Dictionary.FIELD_INFORMATIONS + "." + Dictionary.FIELD_JID, invoker.asStringWithBare()).get(), BasicDBObjectBuilder.start("$set", BasicDBObjectBuilder.start(Dictionary.FIELD_INFORMATIONS + ".$." + Dictionary.FIELD_INFORMATION, entity).get()).get(), true, false, WriteConcern.SAFE);
	} catch (MongoException e) {
		// {"jid":to.bare},{"$addToSet"{"informations":{"jid":from.bare,"activate":当前时间,"information":...entity...}}}
		this.config.collection().update(BasicDBObjectBuilder.start().add(Dictionary.FIELD_JID, group.asStringWithBare()).get(), BasicDBObjectBuilder.start().add("$addToSet", BasicDBObjectBuilder.start(Dictionary.FIELD_INFORMATIONS, BasicDBObjectBuilder.start().add(Dictionary.FIELD_JID, invoker.asStringWithBare()).add(Dictionary.FIELD_ACTIVATE, System.currentTimeMillis()).add(Dictionary.FIELD_INFORMATION, entity).get()).get()).get());
	}
	return true;
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
public Room push(Fields fields) {
	BasicDBObjectBuilder update = BasicDBObjectBuilder.start();
	for (Field<?> field : fields) {
		RoomConfigParser parser = MongoRoomBuilder.this.parsers.get(field.getName());
		if (parser != null) {
			update.add(Dictionary.FIELD_CONFIGS + "." + parser.field(), parser.parse(field));
		}
	}
	if (!update.isEmpty()) {
		MongoRoomBuilder.this.config.collection().update(this.build(), BasicDBObjectBuilder.start("$set", update.get()).get());
	}
	return this;
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
/**
 * For FindXxx</p>{"jid",Xxx,"resource":Xxx(如果使用资源)}
 * 
 * @param jid
 * @param usingResource
 * @return
 */
private DBObject buildQueryWithSmartResource(JID jid, boolean usingResource) {
	// JID,Resource
	BasicDBObjectBuilder query = BasicDBObjectBuilder.start(Dictionary.FIELD_JID, jid.asStringWithBare());
	if (usingResource && !jid.isBare()) {
		query.add(Dictionary.FIELD_RESOURCE, jid.resource());
	}
	return query.get();
}
 

import com.mongodb.BasicDBObjectBuilder; //导入方法依赖的package包/类
/**
 * {"host":host,"date":Xxx}
 * 
 * @param host
 * @param date
 * @return
 */
private DBObject build(String host, boolean date) {
	BasicDBObjectBuilder builder = BasicDBObjectBuilder.start(Dictionary.FIELD_HOST, host);
	if (date) {
		builder.add(this.date, System.currentTimeMillis());
	}
	return builder.get();
}