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();
  }
Beispiel #9
0
    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();
 }
Beispiel #11
0
  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();
 }
Beispiel #13
0
 /**
  * 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;
 }
Beispiel #14
0
    @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);
  }
Beispiel #16
0
 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;
  }
Beispiel #19
0
  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;
  }
Beispiel #20
0
  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;
  }
Beispiel #24
0
  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;
  }
Beispiel #25
0
  @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;
  }
Beispiel #28
0
  // --------------------------------------------------------------------------------
  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;
 }
Beispiel #30
0
 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;
 }