コード例 #1
1
  // FIXME convert to hbird archiver interface and move this to the archiver.
  private static DBObject buildMongoQuery(Map<String, String> aoData) {
    // Get datatables values
    long startTime = Long.parseLong(aoData.get("startTime"));
    long endTime = Long.parseLong(aoData.get("endTime"));
    String search = aoData.get("sSearch");

    // Build mongo query
    // @formatter:off
    DBObject mongoQuery = new BasicDBObject();
    mongoQuery.put(
        "receivedTime", BasicDBObjectBuilder.start("$gte", startTime).add("$lte", endTime).get());

    if (search != null && (!search.isEmpty())) {
      LOG.trace("Adding search query " + search);
      Pattern match = Pattern.compile(search, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);
      // Note, normally you would pass the Pattern object to the Java Mongo driver but when using
      // distributed routing
      // over JMS you can only send objectified primitives. This means we have to create the search
      // string ourselves.
      DBObject matchString = new BasicDBObject("$regex", match.toString()).append("$options", "im");
      mongoQuery.put("name", matchString);
    }

    // @formatter:on

    return mongoQuery;
  }
コード例 #2
0
ファイル: FongoTest.java プロジェクト: jumarko/fongo
  @Test
  public void testAnotherUpsert() {
    DBCollection collection = newCollection();
    BasicDBObjectBuilder queryBuilder =
        BasicDBObjectBuilder.start()
            .push("_id")
            .append("f", "ca")
            .push("1")
            .append("l", 2)
            .pop()
            .push("t")
            .append("t", 11)
            .pop()
            .pop();
    DBObject query = queryBuilder.get();

    DBObject update =
        BasicDBObjectBuilder.start()
            .push("$inc")
            .append("n.!", 1)
            .append("n.a.b:false", 1)
            .pop()
            .get();
    collection.update(query, update, true, false);

    DBObject expected =
        queryBuilder.push("n").append("!", 1).push("a").append("b:false", 1).pop().pop().get();
    assertEquals(expected, collection.findOne());
  }
コード例 #3
0
  /**
   * Creates a GridFS instance for the specified bucket in the given database. Set the preferred
   * WriteConcern on the give DB with DB.setWriteConcern
   *
   * @see com.mongodb.WriteConcern
   * @param db database to work with
   * @param bucket bucket to use in the given database
   * @throws MongoException
   */
  public GridFS(DB db, String bucket) {
    _db = db;
    _bucketName = bucket;

    _filesCollection = _db.getCollection(_bucketName + ".files");
    _chunkCollection = _db.getCollection(_bucketName + ".chunks");

    // ensure standard indexes as long as collections are small
    try {
      if (_filesCollection.count() < 1000) {
        _filesCollection.ensureIndex(
            BasicDBObjectBuilder.start().add("filename", 1).add("uploadDate", 1).get());
      }
      if (_chunkCollection.count() < 1000) {
        _chunkCollection.ensureIndex(
            BasicDBObjectBuilder.start().add("files_id", 1).add("n", 1).get(),
            BasicDBObjectBuilder.start().add("unique", true).get());
      }
    } catch (MongoException e) {
      LOGGER.info(
          String.format(
              "Unable to ensure indices on GridFS collections in database %s", db.getName()));
    }
    _filesCollection.setObjectClass(GridFSDBFile.class);
  }
コード例 #4
0
 public void ensureCaps() {
   for (MappedClass mc : mapr.getMappedClasses())
     if (mc.getEntityAnnotation() != null && mc.getEntityAnnotation().cap().value() > 0) {
       CappedAt cap = mc.getEntityAnnotation().cap();
       String collName = mapr.getCollectionName(mc.getClazz());
       BasicDBObjectBuilder dbCapOpts = BasicDBObjectBuilder.start("capped", true);
       if (cap.value() > 0) dbCapOpts.add("size", cap.value());
       if (cap.count() > 0) dbCapOpts.add("max", cap.count());
       DB db = getDB();
       if (db.getCollectionNames().contains(collName)) {
         DBObject dbResult = db.command(BasicDBObjectBuilder.start("collstats", collName).get());
         if (dbResult.containsField("capped")) {
           // TODO: check the cap options.
           log.warning("DBCollection already exists is cap'd already; doing nothing. " + dbResult);
         } else {
           log.warning(
               "DBCollection already exists with same name("
                   + collName
                   + ") and is not cap'd; not creating cap'd version!");
         }
       } else {
         getDB().createCollection(collName, dbCapOpts.get());
         log.debug("Created cap'd DBCollection (" + collName + ") with opts " + dbCapOpts);
       }
     }
 }
コード例 #5
0
  protected <T, V> WriteResult delete(DBCollection dbColl, V id, WriteConcern wc) {
    WriteResult wr;
    if (wc == null) wr = dbColl.remove(BasicDBObjectBuilder.start().add(Mapper.ID_KEY, id).get());
    else wr = dbColl.remove(BasicDBObjectBuilder.start().add(Mapper.ID_KEY, id).get(), wc);

    throwOnError(wc, wr);

    return wr;
  }
コード例 #6
0
 /**
  * {"pid":Xxx},{"$set":{"ack":false}}
  *
  * @param context
  * @param protocol
  * @return
  */
 private boolean writeAndReturn(JIDContext context, Protocol protocol) {
   this.persistent.peek(
       MongoUtils.asMap(
           BasicDBObjectBuilder.start(
                   Dictionary.FIELD_PID, protocol.cast(Message.class).getReceived().id())
               .get()),
       MongoUtils.asMap(
           BasicDBObjectBuilder.start(
                   "$set", BasicDBObjectBuilder.start(Dictionary.FIELD_ACK, false).get())
               .get()));
   return false;
 }
コード例 #7
0
 /** @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response) */
 protected void doPost(HttpServletRequest request, HttpServletResponse response)
     throws ServletException, IOException {
   String createTableName = request.getParameter("createTableName");
   String createTableX = request.getParameter("createTableX");
   try {
     boolean createTable = true;
     for (String name : Util.getMongoDb().getCollectionNames()) {
       if (name.equals(createTableName)) {
         createTable = false;
       }
     }
     if (createTable) {
       System.out.println("creating table");
       DBObject options = BasicDBObjectBuilder.start().get();
       DBCollection table = Util.getMongoDb().createCollection(createTableName, options);
       BasicDBObject document = new BasicDBObject();
       if (createTableX.isEmpty()) {
         createTableX = "Date";
       }
       document.put("_id", createTableX);
       document.put("value", "Value");
       table.insert(document);
       boolean createTableCollections = true;
       for (String name : Util.getMongoDb().getCollectionNames()) {
         if (name.equals("TableCollections")) {
           createTableCollections = false;
         }
       }
       if (createTableCollections) {
         DBObject options2 = BasicDBObjectBuilder.start().get();
         DBCollection tableResourceCollection =
             Util.getMongoDb().createCollection("TableCollections", options2);
         BasicDBObject documentResourceCollection = new BasicDBObject();
         documentResourceCollection.put("_id", createTableName);
         documentResourceCollection.put("value", createTableX);
         tableResourceCollection.insert(documentResourceCollection);
       } else {
         DBCollection tableResourceCollection =
             Util.getMongoDb().getCollection("TableCollections");
         BasicDBObject documentResourceCollection = new BasicDBObject();
         documentResourceCollection.put("_id", createTableName);
         documentResourceCollection.put("value", createTableX);
         tableResourceCollection.insert(documentResourceCollection);
       }
     } else {
       request.setAttribute("message", "Table Already Exists");
     }
   } catch (Exception e) {
     request.setAttribute("message", e.getMessage());
   }
   request.setAttribute("tableNames", Util.getCollections());
   request.getRequestDispatcher("createTable.jsp").forward(request, response);
 }
コード例 #8
0
  public void introduceType(SpaceTypeDescriptor typeDescriptor) {

    DBCollection m = getConnection().getCollection(METADATA_COLLECTION_NAME);

    BasicDBObjectBuilder builder =
        BasicDBObjectBuilder.start().add(Constants.ID_PROPERTY, typeDescriptor.getTypeName());
    try {
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      ObjectOutputStream out = new ObjectOutputStream(bos);
      IOUtils.writeObject(
          out, SpaceTypeDescriptorVersionedSerializationUtils.toSerializableForm(typeDescriptor));

      builder.add(TYPE_DESCRIPTOR_FIELD_NAME, bos.toByteArray());

      WriteResult wr = m.save(builder.get());

      if (logger.isTraceEnabled()) logger.trace(wr);

      indexBuilder.ensureIndexes(typeDescriptor);

    } catch (IOException e) {
      logger.error(e);

      throw new SpaceMongoException(
          "error occurs while serialize and save type descriptor: " + typeDescriptor, e);
    }
  }
コード例 #9
0
ファイル: VoronoiGraph.java プロジェクト: horridus/ruins
  @Override
  public DBObject toJSON() {
    BasicDBObjectBuilder builder = BasicDBObjectBuilder.start();

    BasicDBList jsonList = new BasicDBList();

    Iterator<VoronoiSite> sitesIt = this.sites.iterator();
    while (sitesIt.hasNext()) {
      jsonList.add(sitesIt.next().toJSON());
    }
    builder.add("sites", jsonList);

    jsonList = new BasicDBList();
    Iterator<VoronoiCorner> cornersIt = this.corners.iterator();
    while (cornersIt.hasNext()) {
      jsonList.add(cornersIt.next().toJSON());
    }
    builder.add("corners", jsonList);

    jsonList = new BasicDBList();
    Iterator<VoronoiEdge> edgesIt = this.edges.iterator();
    while (edgesIt.hasNext()) {
      jsonList.add(edgesIt.next().toJSON());
    }
    builder.add("edges", jsonList);

    return builder.get();
  }
コード例 #10
0
 /** 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();
 }
コード例 #11
0
 public boolean trace(String id) {
   return MongoUtils.asBoolean(
       this.config
           .collection()
           .findAndModify(
               BasicDBObjectBuilder.start().add(Dictionary.FIELD_PID, id).get(), this.failed),
       Dictionary.FIELD_ACTIVATE,
       false);
 }
コード例 #12
0
 @Override
 public DBCursor findEvents(DBCollection collection, MongoCriteria criteria) {
   DBObject filter = criteria == null ? null : criteria.asMongoObject();
   DBObject sort =
       BasicDBObjectBuilder.start()
           .add(CommitEntry.TIME_STAMP_PROPERTY, ORDER_ASC)
           .add(CommitEntry.SEQUENCE_NUMBER_PROPERTY, ORDER_ASC)
           .get();
   return collection.find(filter).sort(sort);
 }
コード例 #13
0
  public static DBObject toDBObject(Person p) {

    BasicDBObjectBuilder builder =
        BasicDBObjectBuilder.start()
            .append("name", p.getName())
            .append("surname", p.getSurname())
            .append("phone", p.getPhone());
    if (p.getId() != null) builder = builder.append("_id", new ObjectId(p.getId()));
    return builder.get();
  }
コード例 #14
0
ファイル: FongoTest.java プロジェクト: jumarko/fongo
  @Test
  public void testUpsertWithEmbeddedQuery() {
    DBCollection collection = newCollection();

    DBObject update = BasicDBObjectBuilder.start().push("$set").append("a", 1).pop().get();

    collection.update(new BasicDBObject("_id", 1).append("e.i", 1), update, true, false);

    DBObject expected =
        BasicDBObjectBuilder.start()
            .append("_id", 1)
            .push("e")
            .append("i", 1)
            .pop()
            .append("a", 1)
            .get();

    assertEquals(expected, collection.findOne(new BasicDBObject("_id", 1)));
  }
コード例 #15
0
 @Override
 public DBCursor findLastSnapshot(DBCollection collection, String aggregateIdentifier) {
   DBObject mongoEntry =
       BasicDBObjectBuilder.start()
           .add(CommitEntry.AGGREGATE_IDENTIFIER_PROPERTY, aggregateIdentifier)
           .get();
   return collection
       .find(mongoEntry)
       .sort(new BasicDBObject(CommitEntry.SEQUENCE_NUMBER_PROPERTY, ORDER_DESC))
       .limit(1);
 }
コード例 #16
0
  public int delete(final String username) {
    LOG.debug("Deleting user(s) with username \"{}\"", username);
    final DBObject query = BasicDBObjectBuilder.start(UserImpl.USERNAME, username).get();
    final int result = destroy(query, UserImpl.COLLECTION_NAME);

    if (result > 1) {
      LOG.warn("Removed {} users matching username \"{}\".", result, username);
    }

    return result;
  }
コード例 #17
0
 /**
  * Update status of feature.
  *
  * @param uid feature id
  * @param enable enabler
  */
 private void updateStatus(String uid, boolean enable) {
   if (uid == null || uid.isEmpty()) {
     throw new IllegalArgumentException("Feature identifier cannot be null nor empty");
   }
   if (!exist(uid)) {
     throw new FeatureNotFoundException(uid);
   }
   DBObject target = BUILDER.getFeatUid(uid);
   Object enabledd = BUILDER.getEnable(enable);
   collection.update(target, BasicDBObjectBuilder.start(MONGO_SET, enabledd).get());
 }
コード例 #18
0
/** @author kim 2014年5月8日 */
public class MongoTracerContext implements TracerContext {

  private final DBObject failed =
      BasicDBObjectBuilder.start(
              "$set", BasicDBObjectBuilder.start(Dictionary.FIELD_ACTIVATE, false).get())
          .get();

  private final MongoConfig config;

  public MongoTracerContext(MongoConfig config) {

    super();
    this.config = config;
  }

  @Override
  public boolean trace(Tracer tracer) {
    return MongoUtils.effect(
        this.config
            .collection()
            .save(
                BasicDBObjectBuilder.start(tracer.plus())
                    .add(Dictionary.FIELD_PID, tracer.id())
                    .add(Dictionary.FIELD_FROM, tracer.initiator())
                    .add(Dictionary.FIELD_ACTIVATE, true)
                    .add(Dictionary.FIELD_TO, tracer.target())
                    .add(Dictionary.FIELD_TIMESTAMP, System.currentTimeMillis())
                    .get(),
                WriteConcern.SAFE));
  }

  public boolean trace(String id) {
    return MongoUtils.asBoolean(
        this.config
            .collection()
            .findAndModify(
                BasicDBObjectBuilder.start().add(Dictionary.FIELD_PID, id).get(), this.failed),
        Dictionary.FIELD_ACTIVATE,
        false);
  }
}
  public Person_login getPerson(String email) {

    DBObject query = BasicDBObjectBuilder.start().append("email", email).get();

    DBObject data = this.col.findOne(query);
    if (data == null) {
      return null;
    } else {

      return PersonConverter.toPerson(data);
    }
  }
コード例 #20
0
 public DBObject asDBObject() {
   final BasicDBObjectBuilder entryBuilder = BasicDBObjectBuilder.start();
   return entryBuilder
       .add(SERIALIZED_PAYLOAD_PROPERTY, serializedPayload)
       .add(PAYLOAD_TYPE_PROPERTY, payloadType)
       .add(PAYLOAD_REVISION_PROPERTY, payloadRevision)
       .add(EVENT_TIMESTAMP_PROPERTY, timestamp)
       .add(EVENT_SEQUENCE_NUMBER_PROPERTY, sequenceNumber)
       .add(META_DATA_PROPERTY, serializedMetaData)
       .add(EVENT_IDENTIFIER_PROPERTY, eventIdentifier)
       .get();
 }
コード例 #21
0
 /** {@inheritDoc} */
 @Override
 public void disableGroup(String groupName) {
   if (groupName == null || groupName.isEmpty()) {
     throw new IllegalArgumentException("Groupname cannot be null nor empty");
   }
   if (!existGroup(groupName)) {
     throw new GroupNotFoundException(groupName);
   }
   for (DBObject dbObject : collection.find(BUILDER.getGroupName(groupName))) {
     Object enabledd = BUILDER.getEnable(false);
     collection.update(dbObject, BasicDBObjectBuilder.start(MONGO_SET, enabledd).get());
   }
 }
コード例 #22
0
 /**
  * This test is green when {@link MyEntity#a} is annotated with {@code @Property}, as in this case
  * the field is not serialized at all. However, the bson encoder would fail to encode the object
  * of type A (as shown by {@link #testFullBSONSerialization()}).
  */
 @Test
 @Ignore
 public void testDBObjectSerialization() {
   final MyEntity entity = new MyEntity(1l, new A(2));
   final DBObject dbObject = morphia.toDBObject(entity);
   assertEquals(BasicDBObjectBuilder.start("_id", 1l).add("a", 2l).get(), dbObject);
   // fails with a
   // org.mongodb.morphia.mapping.MappingException: No usable
   // constructor
   // for InheritanceTest$A
   final MyEntity actual = morphia.fromDBObject(MyEntity.class, dbObject);
   assertEquals(entity, actual);
 }
コード例 #23
0
ファイル: FongoTest.java プロジェクト: jumarko/fongo
  @Test
  public void testUpsertOnIdWithPush() {
    DBCollection collection = newCollection();

    DBObject update1 =
        BasicDBObjectBuilder.start()
            .push("$push")
            .push("c")
            .append("a", 1)
            .append("b", 2)
            .pop()
            .pop()
            .get();

    DBObject update2 =
        BasicDBObjectBuilder.start()
            .push("$push")
            .push("c")
            .append("a", 3)
            .append("b", 4)
            .pop()
            .pop()
            .get();

    collection.update(new BasicDBObject("_id", 1), update1, true, false);
    collection.update(new BasicDBObject("_id", 1), update2, true, false);

    DBObject expected =
        new BasicDBObject("_id", 1)
            .append(
                "c",
                Util.list(
                    new BasicDBObject("a", 1).append("b", 2),
                    new BasicDBObject("a", 3).append("b", 4)));

    assertEquals(expected, collection.findOne(new BasicDBObject("c.a", 3).append("c.b", 4)));
  }
コード例 #24
0
 @Override
 public boolean trace(Tracer tracer) {
   return MongoUtils.effect(
       this.config
           .collection()
           .save(
               BasicDBObjectBuilder.start(tracer.plus())
                   .add(Dictionary.FIELD_PID, tracer.id())
                   .add(Dictionary.FIELD_FROM, tracer.initiator())
                   .add(Dictionary.FIELD_ACTIVATE, true)
                   .add(Dictionary.FIELD_TO, tracer.target())
                   .add(Dictionary.FIELD_TIMESTAMP, System.currentTimeMillis())
                   .get(),
               WriteConcern.SAFE));
 }
コード例 #25
0
 /** {@inheritDoc} */
 @Override
 public void addToGroup(String uid, String groupName) {
   if (uid == null || uid.isEmpty()) {
     throw new IllegalArgumentException("Feature identifier cannot be null nor empty");
   }
   if (groupName == null || groupName.isEmpty()) {
     throw new IllegalArgumentException("Groupname cannot be null nor empty");
   }
   if (!exist(uid)) {
     throw new FeatureNotFoundException(uid);
   }
   DBObject target = BUILDER.getFeatUid(uid);
   DBObject nGroupName = BUILDER.getGroupName(groupName);
   collection.update(target, BasicDBObjectBuilder.start(MONGO_SET, nGroupName).get());
 }
コード例 #26
0
  @Override
  public Collection<User> loadAllForRole(Role role) {
    final String roleId = role.getId();
    final DBObject query = BasicDBObjectBuilder.start(UserImpl.ROLES, new ObjectId(roleId)).get();

    final List<DBObject> result = query(UserImpl.class, query);
    if (result == null || result.isEmpty()) {
      return Collections.emptySet();
    }
    final Set<User> users = Sets.newHashSetWithExpectedSize(result.size());
    for (DBObject dbObject : result) {
      //noinspection unchecked
      users.add(new UserImpl((ObjectId) dbObject.get("_id"), dbObject.toMap()));
    }
    return users;
  }
コード例 #27
0
  public void performBatch(List<BatchUnit> rows) {
    if (logger.isTraceEnabled()) {
      logger.trace("MongoClientWrapper.performBatch(" + rows + ")");
      logger.trace("Batch size to be performed is " + rows.size());
    }
    // List<Future<? extends Number>> pending = new ArrayList<Future<? extends Number>>();

    for (BatchUnit row : rows) {
      SpaceDocument spaceDoc = row.getSpaceDocument();
      SpaceTypeDescriptor typeDescriptor = types.get(row.getTypeName()).getTypeDescriptor();
      SpaceDocumentMapper<DBObject> mapper = getMapper(typeDescriptor);

      DBObject obj = mapper.toDBObject(spaceDoc);

      DBCollection col = getCollection(row.getTypeName());
      switch (row.getDataSyncOperationType()) {
        case WRITE:
        case UPDATE:
          col.save(obj);
          break;
        case PARTIAL_UPDATE:
          DBObject query =
              BasicDBObjectBuilder.start()
                  .add(Constants.ID_PROPERTY, obj.get(Constants.ID_PROPERTY))
                  .get();

          DBObject update = normalize(obj);
          col.update(query, update);
          break;
          // case REMOVE_BY_UID: // Not supported by this implementation
        case REMOVE:
          col.remove(obj);
          break;
        default:
          throw new IllegalStateException(
              "Unsupported data sync operation type: " + row.getDataSyncOperationType());
      }
    }

    /*long totalCount = waitFor(pending);

    if (logger.isTraceEnabled()) {
    	logger.trace("total accepted replies is: " + totalCount);
    }*/
  }
コード例 #28
0
    /**
     * Returns the current CommitEntry as a mongo DBObject.
     *
     * @return DBObject representing the CommitEntry
     */
    public DBObject asDBObject() {
      final BasicDBList events = new BasicDBList();
      BasicDBObjectBuilder commitBuilder =
          BasicDBObjectBuilder.start()
              .add(AGGREGATE_IDENTIFIER_PROPERTY, aggregateIdentifier)
              .add(SEQUENCE_NUMBER_PROPERTY, firstSequenceNumber)
              .add(LAST_SEQUENCE_NUMBER_PROPERTY, lastSequenceNumber)
              .add(FIRST_SEQUENCE_NUMBER_PROPERTY, firstSequenceNumber)
              .add(TIME_STAMP_PROPERTY, firstTimestamp)
              .add(FIRST_TIME_STAMP_PROPERTY, firstTimestamp)
              .add(LAST_TIME_STAMP_PROPERTY, lastTimestamp)
              .add(EVENTS_PROPERTY, events);

      for (EventEntry eventEntry : eventEntries) {
        events.add(eventEntry.asDBObject());
      }
      return commitBuilder.get();
    }
コード例 #29
0
  public Usage getMdnUsageDetail(String mdn) {
    Usage usage = null;
    MongoClient mongo = null;
    String database = "usage";
    try {
      Map<String, Object> dbMap = DataUtils.getConnection();
      DB db = (DB) dbMap.get("db");
      mongo = (MongoClient) dbMap.get("mongo");
      /*MongoClientURI uri  = new MongoClientURI("mongodb://*****:*****@ds051863.mongolab.com:51863/CloudFoundry_omfu0lp3_t4cigvf3");
      mongo = new MongoClient(uri);
      DB db = mongo.getDB(uri.getDatabase());*/
      /*if(!DataUtils.auth){
      	DataUtils.auth = db.authenticate("yoga", "test123".toCharArray());
      	System.out.println("db authenticated "+DataUtils.auth);
      }*/
      DBCollection col = db.getCollection("usage");
      DBObject query = BasicDBObjectBuilder.start().add("mdn", mdn).get();
      DBCursor cursor = col.find(query);
      ObjectMapper objectMapper = new ObjectMapper();
      if (cursor.hasNext()) {
        // System.out.println(cursor.next());
        DBObject obj = cursor.next();
        usage = objectMapper.readValue(obj.toString(), Usage.class);
      }
    } catch (UnknownHostException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (JsonParseException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (JsonMappingException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (IOException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      mongo.close();
    }

    return usage;
  }
コード例 #30
0
  @SuppressWarnings({"rawtypes"})
  public void ensureIndex(
      Class clazz,
      String name,
      IndexFieldDef[] defs,
      boolean unique,
      boolean dropDupsOnCreate,
      boolean background) {
    BasicDBObjectBuilder keys = BasicDBObjectBuilder.start();

    for (IndexFieldDef def : defs) {
      String fieldName = def.getField();
      IndexDirection dir = def.getDirection();
      keys.add(fieldName, dir.toIndexValue());
    }

    ensureIndex(
        clazz, name, (BasicDBObject) keys.get(), unique, dropDupsOnCreate, background, false);
  }