Java BSONTimestamp类代码示例

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
/**
 * Creates the query to execute on the collection.
 *
 * @return the query
 */
private Bson createQuery() {
    // timestamps are used as offsets, saved as a concatenation of seconds and order
	Integer timestamp = 0;
    Integer order = 0;
	if(!start.equals("0")){    	
 	final String[] splitted = start.split("_");
 	timestamp = Integer.valueOf(splitted[0]);
     order = Integer.valueOf(splitted[1]);
	}
	
    Bson query = Filters.and(
            Filters.exists("fromMigrate", false),
            Filters.gt("ts", new BSONTimestamp(timestamp, order)),
            Filters.or(
                    Filters.eq("op", "i"),
                    Filters.eq("op", "u"),
                    Filters.eq("op", "d")
            ),
            Filters.eq("ns", db)
    );

    return query;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
@Override
public Void call() throws Exception {
    
    final Date now = new Date();
    final Document query = new Document("ns", ns)
        .append("ts", new Document("$gt", new BSONTimestamp((int) (now.getTime() / 1000), 0)));
    
    final MongoCursor<Document> cursor = oplog.find(query)
        .cursorType(CursorType.TailableAwait).iterator();
    
    while (cursor.hasNext()) {
        final Document doc = cursor.next();
        for (final OplogListener listener : listeners) {
            listener.onOplog(doc);
        }
    }

    return null;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
protected static int mongoToKettleType( Object fieldValue ) {
  if ( fieldValue == null ) {
    return ValueMetaInterface.TYPE_STRING;
  }

  if ( fieldValue instanceof Symbol || fieldValue instanceof String || fieldValue instanceof Code
        || fieldValue instanceof ObjectId || fieldValue instanceof MinKey || fieldValue instanceof MaxKey ) {
    return ValueMetaInterface.TYPE_STRING;
  } else if ( fieldValue instanceof Date ) {
    return ValueMetaInterface.TYPE_DATE;
  } else if ( fieldValue instanceof Number ) {
    // try to parse as an Integer
    try {
      Integer.parseInt( fieldValue.toString() );
      return ValueMetaInterface.TYPE_INTEGER;
    } catch ( NumberFormatException e ) {
      return ValueMetaInterface.TYPE_NUMBER;
    }
  } else if ( fieldValue instanceof Binary ) {
    return ValueMetaInterface.TYPE_BINARY;
  } else if ( fieldValue instanceof BSONTimestamp ) {
    return ValueMetaInterface.TYPE_INTEGER;
  }

  return ValueMetaInterface.TYPE_STRING;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
private DBCursor createCursor() {
  DBCollection oplog = _mongo.getDB("local").getCollection("oplog.rs");
  BSONTimestamp startingTimestamp = getStartingTimestamp();

  DBCursor cursor;
  if (startingTimestamp == null) {
    log.info("Tailing the oplog from the beginning...");
    cursor = oplog.find();
  } else {
    log.info("Tailing the oplog from " + startingTimestamp);
    BasicDBObject query = new BasicDBObject("ts", new BasicDBObject("$gt", startingTimestamp));
    cursor = oplog.find(query);
    cursor.addOption(Bytes.QUERYOPTION_OPLOGREPLAY);
  }

  cursor.addOption(Bytes.QUERYOPTION_NOTIMEOUT);
  cursor.addOption(Bytes.QUERYOPTION_TAILABLE);
  cursor.addOption(Bytes.QUERYOPTION_AWAITDATA);

  return cursor;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
private BSONTimestamp getStartingTimestamp() {
  Get get = new Get(_tailerID);

  Result res;
  try {
    res = _stateTable.get(get);
  } catch (IOException e) {
    log.error("Failed to get a starting timestamp for tailer ID: " + _tailerID);
    return null;
  }

  if (res.isEmpty()) {
    if(ConfigUtil.getSkipBacklog(_conf)) return new BSONTimestamp((int) (System.currentTimeMillis() / 1000L), 0);
    return null;
  } else {
    byte[] raw_optime = res.getValue(STATE_TABLE_COL_FAMILY, STATE_TABLE_COL_QUALIFIER_OPTIME);
    byte[] raw_inc = res.getValue(STATE_TABLE_COL_FAMILY, STATE_TABLE_COL_QUALIFIER_INC);

    _optime = Integer.parseInt(new String(raw_optime));
    _inc = Integer.parseInt(new String(raw_inc));
    _optimeSet = true;
    return new BSONTimestamp(_optime, _inc);
  }
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
/**
 * convert bson types to java primitives. BasicBSONList, Binary,
 * BSONTimestamp, Code, CodeWScope, MinKey, MaxKey, Symbol, ObjectId
 */
private Object convert(Object o) {
	if (o instanceof BSONTimestamp) {
		return ((BSONTimestamp) o).getTime();
	} else if (o instanceof Symbol || o instanceof Code || o instanceof CodeWScope || o instanceof MinKey
			|| o instanceof MaxKey || o instanceof ObjectId) {
		return o.toString();
	} else if (o instanceof BasicBSONList) {
		List<Object> l = new ArrayList<Object>();
		for (Object item : ((BasicBSONList) o)) {
			l.add(convert(item));
		}

		return l;
	} else {
		return o;
	}
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
protected void checkValue(Object value) {
	if (value instanceof MObject)
		return;

	if (value == null)
		return;
	if (value instanceof Number)
		return;
	if (value instanceof String)
		return;
	if (value instanceof Boolean)
		return;
	if (value instanceof Character)
		return;
	if (value instanceof ObjectId)
		return;
	if (value instanceof Date)
		return;
	if (value instanceof Pattern)
		return;
	if (value instanceof UUID)
		return;
	if (value instanceof MaxKey || value instanceof MinKey)
		return;
	if (value instanceof byte[])
		return;
	if (value instanceof BSONTimestamp || value instanceof Symbol
		|| value instanceof Code || value instanceof CodeWScope)
		return;

	throw new IllegalArgumentException(getClass().getSimpleName()
		+ " can't store a " + value.getClass().getName());
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
@Override
public void writeTimestamp(final BSONTimestamp value) {
    checkPreconditions("writeTimestamp", State.VALUE);

    buffer.write(BSONType.TIMESTAMP.getValue());
    writeCurrentName();
    buffer.writeInt(value.getInc());
    buffer.writeInt(value.getTime());

    setState(getNextState());
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
/**
 * Returns an <code>ObjectSerializer</code> that mostly conforms to the strict JSON format defined in
 * <a href="http://www.mongodb.org/display/DOCS/Mongo+Extended+JSON", but with a few differences to keep
 * compatibility with previous versions of the driver.  Clients should generally prefer
 * <code>getStrict</code> in preference to this method.
 *
 * @return object serializer
 * @see #getStrict()
 */
public static ObjectSerializer getLegacy() {

    ClassMapBasedObjectSerializer serializer = addCommonSerializers();

    serializer.addObjectSerializer(Date.class, new LegacyDateSerializer(serializer));
    serializer.addObjectSerializer(BSONTimestamp.class, new LegacyBSONTimestampSerializer(serializer));
    serializer.addObjectSerializer(Binary.class, new LegacyBinarySerializer());
    serializer.addObjectSerializer(byte[].class, new LegacyBinarySerializer());
    return serializer;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
/**
 * Returns an <code>ObjectSerializer</code> that conforms to the strict JSON format defined in
 * <a href="http://www.mongodb.org/display/DOCS/Mongo+Extended+JSON".
 *
 * @return object serializer
 */
public static ObjectSerializer getStrict() {

    ClassMapBasedObjectSerializer serializer = addCommonSerializers();

    serializer.addObjectSerializer(Date.class, new DateSerializer(serializer));
    serializer.addObjectSerializer(BSONTimestamp.class, new BSONTimestampSerializer(serializer));
    serializer.addObjectSerializer(Binary.class, new BinarySerializer(serializer));
    serializer.addObjectSerializer(byte[].class, new ByteArraySerializer(serializer));

    return serializer;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
@Override
public void serialize(Object obj, StringBuilder buf) {
    BSONTimestamp t = (BSONTimestamp) obj;
    BasicDBObject temp = new BasicDBObject();
    temp.put("$ts", Integer.valueOf(t.getTime()));
    temp.put("$inc", Integer.valueOf(t.getInc()));
    serializer.serialize(temp, buf);
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
@Override
public Long convertFromMongoDbType(BSONTimestamp data) {
  int inc = data.getInc();
  if (inc < 0 || inc >= 1000) {
    throw new RuntimeException(
        "Overflow occurs while converting BSONTimestamp into long: " + data);
  }
  return (long) data.getTime() * 1000 + inc;
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
@Override
public BSONTimestamp convertToMongoDbType(String data) {
  Matcher matcher = TIMESTAMP_PATTERN.matcher(data);
  if (!matcher.matches()) {
    throw new RuntimeException("Invalid BSONTimestamp " + data);
  }
  int time = Integer.parseInt(matcher.group(1));
  int inc = Integer.parseInt(matcher.group(2));
  return new BSONTimestamp(time, inc);
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
private void updateOptime(BasicDBObject doc) {
  BSONTimestamp ts = (BSONTimestamp) doc.get("ts");
  int optime = ts.getTime(), inc = ts.getInc();

  // only checkpoint every 60 seconds
  if (!_optimeSet || (optime - _optime) >= 60) {
    _optime = optime;
    _inc = inc;
    _optimeSet = true;

    log.info("optime: " + _optime);
    saveOptime();
  }
}
 

import org.bson.types.BSONTimestamp; //导入依赖的package包/类
public void gotTimestamp( String name , int time , int inc ){
    _put( name , new BSONTimestamp( time , inc ) );
}