public void addCardInfoToNeo4j() { DBCursor cursor = cardCollection.find(); DBObject sortObject = new BasicDBObject(); sortObject.put("name", 1); // cursor = cursor.sort(sortObject); cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT); int count = 0; while (cursor.hasNext()) { DBObject cardObject = cursor.next(); String cardName = cardObject.get("name").toString().toUpperCase(); if (cardNodes.get(cardName) == null) { Node newCardNode = graphDb.createNode(); newCardNode.setProperty("name", cardName); for (String property : cardObject.keySet()) { if (!property.equalsIgnoreCase("name")) { newCardNode.setProperty(property, cardObject.get(property).toString()); } } cardNodes.put(cardName, newCardNode); } else { Node node = cardNodes.get(cardName); for (String property : cardObject.keySet()) { if (!property.equalsIgnoreCase("name")) { node.setProperty(property, cardObject.get(property).toString()); } } } count++; System.out.println("Processed " + count + " card"); } }
@Override public List<Favorite> getFavorites(String email) throws UserNotFound { if (email == null) { throw new IllegalArgumentException("Email cannot be null"); } DBCollection col = db.getCollection(MongoDBConstants.COLLECTION_USERS); // Search user by email DBObject userDb = col.findOne(new BasicDBObject(MongoDBConstants.USER_PROP_EMAIL, email)); if (userDb == null) { throw new UserNotFound("Unable to find user with email '" + email + "'"); } DBObject favoritesDb = (DBObject) userDb.get(MongoDBConstants.USER_PROP_FAVORITES); if (favoritesDb == null) { favoritesDb = new BasicDBObject(); userDb.put(MongoDBConstants.USER_PROP_FAVORITES, favoritesDb); col.save(userDb); } List<Favorite> returnValue = new ArrayList<Favorite>(favoritesDb.keySet().size()); for (String stationId : favoritesDb.keySet()) { Favorite favorite = new Favorite(); favorite.setStationId(stationId); DBObject favoriteItemsDb = (DBObject) favoritesDb.get(stationId); favorite.setLastMessageId( (Long) favoriteItemsDb.get(MongoDBConstants.USER_PROP_FAVORITE_LASTMESSAGEID)); returnValue.add(favorite); } return returnValue; }
private DBObject modifyNullsToUnsets(DBObject nativeEntry) { DBObject unsets = new BasicDBObject(); DBObject sets = new BasicDBObject(); for (String key : nativeEntry.keySet()) { Object o = nativeEntry.get(key); if (o == null) { unsets.put(key, 1); } else if ("_id".equals(key)) { } else if (o instanceof Object[]) { sets.put(key, o); for (Object o2 : (Object[]) o) { if (o2 instanceof DBObject) { removeNullEntries((DBObject) o2); } } } else if (o instanceof List) { sets.put(key, o); for (Object o2 : (List) o) { if (o2 instanceof DBObject) { removeNullEntries((DBObject) o2); } } } else if (o instanceof DBObject) { sets.put(key, removeNullEntries((DBObject) o)); } else { sets.put(key, o); } } DBObject newEntry = new BasicDBObject(); newEntry.put("$set", sets); if (!unsets.keySet().isEmpty()) { newEntry.put("$unset", unsets); } return newEntry; }
@Test public void testBasicQuery() { BasicDBObject query = new BasicDBObject(); query.put(EmployeeProperties.EMPLOYEE_ID, "28241"); BasicDBObject fields = new BasicDBObject(); fields.put(EmployeeProperties.ID, 0); fields.put(EmployeeProperties.LAST_NAME, 1); fields.put(EmployeeProperties.EMPLOYEE_ID, 1); DBCollection collection = mongoOps.getCollection(EmployeeProperties.COLLECTION); log.info( "MongoDB Query Explain Plan: " + collection .find(query, fields) .hint(new BasicDBObject(EmployeeProperties.EMPLOYEE_ID, 1)) .explain()); DBCursor cursor = collection.find(query, fields).hint(new BasicDBObject(EmployeeProperties.EMPLOYEE_ID, 1)); log.info(cursor.count() + ""); assertNotNull("cursor was null.", cursor); assertEquals("cursor count was not 1.", 1, cursor.count()); log.info("Query (" + query.toString() + ")"); while (cursor.hasNext()) { DBObject dbo = cursor.next(); log.info(dbo.toString()); assertEquals("Keyset size not equal to 2.", 2, dbo.keySet().size()); } log.info(cursor.explain().toString()); }
public MongoResultSet(MongoData mongo, String schema) throws SQLException { this._cursor = mongo.getCursor(); this._schema = schema; this._table = mongo.getTable(); this.isSum = mongo.getCount() > 0; this._sum = mongo.getCount(); this.isGroupBy = mongo.getType(); if (this.isGroupBy) { dblist = mongo.getGrouyBys(); this.isSum = true; } if (this._cursor != null) { select = (String[]) _cursor.getKeysWanted().keySet().toArray(new String[0]); if (this._cursor.hasNext()) { _cur = _cursor.next(); if (_cur != null) { if (select.length == 0) { SetFields(_cur.keySet()); } _row = 1; } } if (select.length == 0) { select = new String[] {"_id"}; SetFieldType(true); } else { SetFieldType(false); } } else { SetFields(mongo.getFields().keySet()); // new String[]{"COUNT(*)"}; SetFieldType(mongo.getFields()); } }
protected void showDocument(DBObject doc, String level) { PrintStream pout = System.out; for (String key : doc.keySet()) { pout.print(level); pout.print(key); pout.print(" = "); Object value = doc.get(key); if (value instanceof DBObject) { DBObject child = (DBObject) value; pout.println(); showDocument(child, level + " "); } else { if (value instanceof String) { pout.print("\""); } pout.print(value); if (value instanceof String) { pout.print("\""); } pout.println(); } } }
private void toMongoFormat(final DBObject indexObj) { Set<String> indexKeys = indexObj.keySet(); for (String indexKey : indexKeys) { Double indexValue = (Double) indexObj.get(indexKey); indexObj.put(indexKey, indexValue.intValue()); } }
static String addRemovePrefix(String prefix, String object, boolean add) { if (prefix == null) { throw new IllegalArgumentException("prefix"); } if (object == null) { throw new NullPointerException("object"); } if (object.length() == 0) { return ""; } DBObject bsonObject = (DBObject) JSON.parse(object); BasicBSONObject newObject = new BasicBSONObject(); for (String key : bsonObject.keySet()) { if (add) { newObject.put(prefix + key, bsonObject.get(key)); } else { if (key.startsWith(prefix)) { newObject.put(key.substring(prefix.length()), bsonObject.get(key)); } else { newObject.put(key, bsonObject.get(key)); } } } return newObject.toString(); }
public SortSpecificationComparator(DBObject orderBy) { this.orderBy = orderBy; this.orderByKeySet = orderBy.keySet(); if (this.orderByKeySet.isEmpty()) { throw new FongoException("The $sort pattern is empty when it should be a set of fields."); } }
/** Does a deep copy of an object to allow for subsequent modification */ public static DBObject copyDBObject(DBObject dbObject) { DBObject orig = dbObject; BasicDBObjectBuilder dbObjectBuilder = BasicDBObjectBuilder.start(); for (String field : orig.keySet()) { Object value = orig.get(field); dbObjectBuilder.add(field, value); } return dbObjectBuilder.get(); }
private Map<String, Object> convert(DBObject doc) { Map<String, Object> m = new HashMap<String, Object>(); for (String key : doc.keySet()) { m.put(key, convert(doc.get(key))); } return m; }
/** @return @throws BasicException */ @Override public boolean next() throws BasicException { if (m_dbCursor != null) { if (m_dbCursor.hasNext()) { m_currentObject = m_dbCursor.next(); return true; } else return false; } else return !m_dbObject.keySet().isEmpty(); }
/** * Only build the filter for this keys. * * @param ref query for filter. * @param keys must match to build the filter. */ public Filter buildFilter(DBObject ref, Collection<String> keys) { AndFilter andFilter = new AndFilter(); for (String key : ref.keySet()) { if (keys.contains(key)) { Object expression = ref.get(key); andFilter.addFilter(buildExpressionFilter(key, expression)); } } return andFilter; }
@Override public Object createObject(byte[] data, int offset) { DBObject dbo = new LazyBsonByte(data, offset, this); Iterator it = dbo.keySet().iterator(); if (it.hasNext() && it.next().equals("$ref") && dbo.containsField("$id")) { return new DBRef(db, dbo); } return dbo; }
@Override public OpaqueValue getValue(DBObject dbObject) { DBObject histogram = (DBObject) dbObject.get(HISTOGRAM_NAME); Object[] keys = histogram.keySet().toArray(); Integer l = 0; if (keys.length != 0) l = Integer.parseInt(histogram.get((String) keys[0]).toString()); return (OpaqueValue) new OpaqueValue<Number>(0l, l); }
public Filter buildFilter(DBObject ref) { AndFilter andFilter = new AndFilter(); if (ref != null) { for (String key : ref.keySet()) { Object expression = ref.get(key); andFilter.addFilter(buildExpressionFilter(key, expression)); } } return andFilter; }
private boolean filterMatch(DBObject filter, DBObject object) { for (String key : filter.keySet()) { if (!object.containsField(key)) { return false; } if (!filter.get(key).equals(object.get(key))) { return false; } } return true; }
private int getNumberOfEmbeddedAssociations(DBObject entity) { int numberOfReferences = 0; for (String fieldName : entity.keySet()) { Object field = entity.get(fieldName); if (isAssociation(field)) { numberOfReferences++; } } return numberOfReferences; }
public Map<String, Object> message() { Map<String, Object> map = new HashMap<>(); Object property = dbObject.get(MESSAGE); if (property == null || property instanceof DBObject) { DBObject messageObject = (DBObject) property; if (messageObject != null) { for (String key : messageObject.keySet()) { map.put(key, messageObject.get(key)); } } } return map; }
private int compareDBObjects(DBObject db0, DBObject db1) { Iterator<String> i0 = db0.keySet().iterator(); Iterator<String> i1 = db1.keySet().iterator(); while (i0.hasNext() || i1.hasNext()) { String key0 = i0.hasNext() ? i0.next() : null; String key1 = i1.hasNext() ? i1.next() : null; int keyComparison = Util.compareToNullable(key0, key1); if (keyComparison != 0) { return keyComparison; } Object value0 = key0 == null ? null : db0.get(key0); Object value1 = key1 == null ? null : db1.get(key1); int valueComparison = compareObjects(value0, value1); if (valueComparison != 0) { return valueComparison; } } return 0; }
@Test public void serialNumberNotStored() throws Exception { // writer.writeId("D01"); writer.writeOid(RootOidDefault.deString(SPEC_NAME + ":" + "D01", new OidMarshaller())); writer.flush(); final DBCollection instances = testDb.getCollection(SPEC_NAME); assertEquals(1, instances.getCount()); final DBObject object = instances.findOne(); assertEquals(SPEC_NAME + ":" + "D01", object.get("_oid")); assertEquals("D01", object.get("_id")); assertEquals(2, object.keySet().size()); }
/*------------------------------------------------------------ */ @Override protected synchronized NoSqlSession loadSession(String clusterId) { DBObject o = _sessions.findOne(new BasicDBObject(__ID, clusterId)); __log.debug("MongoSessionManager:loaded " + o); if (o == null) { return null; } Boolean valid = (Boolean) o.get(__VALID); if (valid == null || !valid) { return null; } try { Object version = o.get(getContextKey(__VERSION)); Long created = (Long) o.get(__CREATED); Long accessed = (Long) o.get(__ACCESSED); NoSqlSession session = new NoSqlSession(this, created, accessed, clusterId, version); // get the attributes for the context DBObject attrs = (DBObject) getNestedValue(o, getContextKey()); __log.debug("MongoSessionManager:attrs: " + attrs); if (attrs != null) { for (String name : attrs.keySet()) { if (__METADATA.equals(name)) { continue; } String attr = decodeName(name); Object value = decodeValue(attrs.get(name)); session.doPutOrRemove(attr, value); session.bindValue(attr, value); } } session.didActivate(); return session; } catch (Exception e) { LOG.warn(e); } return null; }
/** * Reads the given {@link DBObject} into a {@link Map}. will recursively resolve nested {@link * Map}s as well. * * @param type the {@link Map} {@link TypeInformation} to be used to unmarshall this {@link * DBObject}. * @param dbObject must not be {@literal null} * @param path must not be {@literal null} * @return */ @SuppressWarnings("unchecked") protected Map<Object, Object> readMap( TypeInformation<?> type, DBObject dbObject, ObjectPath path) { Assert.notNull(dbObject, "DBObject must not be null!"); Assert.notNull(path, "Object path must not be null!"); Class<?> mapType = typeMapper.readType(dbObject, type).getType(); TypeInformation<?> keyType = type.getComponentType(); Class<?> rawKeyType = keyType == null ? null : keyType.getType(); TypeInformation<?> valueType = type.getMapValueType(); Class<?> rawValueType = valueType == null ? null : valueType.getType(); Map<Object, Object> map = CollectionFactory.createMap(mapType, rawKeyType, dbObject.keySet().size()); Map<String, Object> sourceMap = dbObject.toMap(); for (Entry<String, Object> entry : sourceMap.entrySet()) { if (typeMapper.isTypeKey(entry.getKey())) { continue; } Object key = potentiallyUnescapeMapKey(entry.getKey()); if (rawKeyType != null) { key = conversionService.convert(key, rawKeyType); } Object value = entry.getValue(); if (value instanceof DBObject) { map.put(key, read(valueType, (DBObject) value, path)); } else if (value instanceof DBRef) { map.put( key, DBRef.class.equals(rawValueType) ? value : read(valueType, readRef((DBRef) value))); } else { Class<?> valueClass = valueType == null ? null : valueType.getType(); map.put(key, getPotentiallyConvertedSimpleRead(value, valueClass)); } } return map; }
private ResourceState createACE( String createdResourceURI, SecurityContext securityContext, AutoRuleConfig autoRuleConfig) { DBObject dbObject = new BasicDBObject(); dbObject.put(ACE_REALM, securityContext.getRealm()); dbObject.put(ACE_USER_ID, securityContext.getSubject()); dbObject.put(ACE_RESOURCE_PATH, createdResourceURI); dbObject.put(ACE_ACTIONS, autoRuleConfig.getAutoAddedOwnerPermissions().toArray()); dbObject.put(ACE_PERMITTED, true); this.aclCollection.insert(dbObject); log.debug("Created ACE: " + dbObject); ResourceState createdState = new DefaultResourceState(); for (String key : dbObject.keySet()) { createdState.putProperty(key, dbObject.get(key)); } return createdState; }
@Override @Deprecated public DBObject getFieldsObject() { DBObject projection = getOptions().getProjection(); if (projection == null || projection.keySet().size() == 0) { return null; } final MappedClass mc = ds.getMapper().getMappedClass(clazz); Entity entityAnnotation = mc.getEntityAnnotation(); final BasicDBObject fieldsFilter = copy(projection); if (includeFields && entityAnnotation != null && !entityAnnotation.noClassnameStored()) { fieldsFilter.put(Mapper.CLASS_NAME_FIELDNAME, 1); } return fieldsFilter; }
private static DBObject normalize(DBObject obj) { BasicDBObjectBuilder builder = BasicDBObjectBuilder.start(); Iterator<String> iterator = obj.keySet().iterator(); builder.push("$set"); while (iterator.hasNext()) { String key = iterator.next(); if (Constants.ID_PROPERTY.equals(key)) continue; Object value = obj.get(key); if (value == null) continue; builder.add(key, value); } return builder.get(); }
/** * Removes the type information from the entire conversion result. * * @param object * @param recursively whether to apply the removal recursively * @return */ private Object removeTypeInfo(Object object, boolean recursively) { if (!(object instanceof DBObject)) { return object; } DBObject dbObject = (DBObject) object; String keyToRemove = null; for (String key : dbObject.keySet()) { if (recursively) { Object value = dbObject.get(key); if (value instanceof BasicDBList) { for (Object element : (BasicDBList) value) { removeTypeInfo(element, recursively); } } else { removeTypeInfo(value, recursively); } } if (typeMapper.isTypeKey(key)) { keyToRemove = key; if (!recursively) { break; } } } if (keyToRemove != null) { dbObject.removeField(keyToRemove); } return dbObject; }
// -------------------------------------------------------------------------------- private void drawTreeRoot(Tree _tree, DBObject data) { // reset tree _tree.removeAll(); if (data != null) { TreeItem root = new TreeItem(_tree, SWT.NONE); root.setText(data.get("_id") + ""); root.setImage(documentImage); root.setData("fieldName", ""); root.setData("value", data.get("_id")); fieldNameTreeItemMap.put("", root); boolean expand = (data.keySet().size() < 35); drawItem("", root, data.toMap(), expand); } nameText.setText(""); typeCombo.select(0); typeCombo.setEnabled(false); valueText.setText(""); updateButton.setEnabled(false); }
private DBObject removeNullEntries(DBObject nativeEntry) { for (String key : new HashSet<String>(nativeEntry.keySet())) { Object o = nativeEntry.get(key); if (o == null) { nativeEntry.removeField(key); } else if (o instanceof Object[]) { for (Object o2 : (Object[]) o) { if (o2 instanceof DBObject) { removeNullEntries((DBObject) o2); } } } else if (o instanceof List) { for (Object o2 : (List) o) { if (o2 instanceof DBObject) { removeNullEntries((DBObject) o2); } } } else if (o instanceof DBObject) { removeNullEntries((DBObject) o); } } return nativeEntry; }
com.mongodb.MapReduceCommand build(JacksonDBCollection<?, ?> collection) { DBObject query = null; if (this.query != null) { query = collection.serializeQuery(this.query); } com.mongodb.MapReduceCommand command = new com.mongodb.MapReduceCommand( collection.getDbCollection(), map, reduce, this.collection, outputType.getDriverType(), query); if (finalize != null) { command.setFinalize(finalize); } if (readPreference != null) { command.setReadPreference(readPreference); } if (outputDB != null) { command.setOutputDB(outputDB); } if (sort != null) { command.setSort(sort); } command.setLimit(limit); if (scope != null) { command.setScope(scope); } command.setVerbose(verbose); if (extra != null) { for (String key : extra.keySet()) { command.addExtraOption(key, extra.get(key)); } } return command; }