@Override public int hashCode() { return entrySet().hashCode(); }
@Override public Set<Entry<String, BsonValue>> entrySet() { return getUnwrapped().entrySet(); }
protected Context(final Context parentContext, final BsonContextType contextType, final BsonDocument document) { super(parentContext, contextType); documentIterator = new BsonDocumentMarkableIterator<Map.Entry<String, BsonValue>>(document.entrySet().iterator()); }
@Override public Set<Entry<String, BsonValue>> entrySet() { return toBsonDocument().entrySet(); }
@Override public Set<Entry<String, BsonValue>> entrySet() { return toBsonDocument().entrySet(); }
private static TagSet getTagSetFromDocument(final BsonDocument tagsDocuments) { List<Tag> tagList = new ArrayList<Tag>(); for (final Map.Entry<String, BsonValue> curEntry : tagsDocuments.entrySet()) { tagList.add(new Tag(curEntry.getKey(), curEntry.getValue().asString().getValue())); } return new TagSet(tagList); }
@Override public <TDocument> BsonDocument toBsonDocument(final Class<TDocument> documentClass, final CodecRegistry codecRegistry) { BsonDocument filterDocument = filter.toBsonDocument(documentClass, codecRegistry); if (filterDocument.size() == 1) { Map.Entry<String, BsonValue> entry = filterDocument.entrySet().iterator().next(); return createFilter(entry.getKey(), entry.getValue()); } else { BsonArray values = new BsonArray(); for (Map.Entry<String, BsonValue> docs : filterDocument.entrySet()) { values.add(new BsonDocument(docs.getKey(), docs.getValue())); } return createFilter("$and", values); } }
private void pipeDocument(final BsonDocument value) { writeStartDocument(); for (Map.Entry<String, BsonValue> cur : value.entrySet()) { writeName(cur.getKey()); pipeValue(cur.getValue()); } writeEndDocument(); }
private void promoteRenderableToDollarForm(final BsonDocument document, final Map.Entry<String, BsonValue> clause) { BsonArray clauses = new BsonArray(); for (Map.Entry<String, BsonValue> queryElement : document.entrySet()) { clauses.add(new BsonDocument(queryElement.getKey(), queryElement.getValue())); } clauses.add(new BsonDocument(clause.getKey(), clause.getValue())); document.clear(); document.put("$and", clauses); }
@Override public void encode(final BsonWriter writer, final BsonDocument value, final EncoderContext encoderContext) { writer.writeStartDocument(); beforeFields(writer, encoderContext, value); for (Map.Entry<String, BsonValue> entry : value.entrySet()) { if (skipField(encoderContext, entry.getKey())) { continue; } writer.writeName(entry.getKey()); writeValue(writer, encoderContext, entry.getValue()); } writer.writeEndDocument(); }
@Override public <TDocument> BsonDocument toBsonDocument(final Class<TDocument> documentClass, final CodecRegistry codecRegistry) { BsonDocument andRenderable = new BsonDocument(); for (Bson filter : filters) { BsonDocument renderedRenderable = filter.toBsonDocument(documentClass, codecRegistry); for (Map.Entry<String, BsonValue> element : renderedRenderable.entrySet()) { addClause(andRenderable, element); } } if (andRenderable.isEmpty()) { andRenderable.append("$and", new BsonArray()); } return andRenderable; }
@Test(expected = ConnectException.class) public void shouldDetectHeterogenousDocumentInArray() throws Exception { final MongoDataConverter converter = new MongoDataConverter(ArrayEncoding.ARRAY); final BsonDocument val = BsonDocument.parse(HETEROGENOUS_DOCUMENT_IN_ARRAY); for (Entry<String, BsonValue> entry : val.entrySet()) { converter.addFieldSchema(entry, builder); } }
@Test(expected = ConnectException.class) public void shouldDetectHeterogenousArray() throws Exception { final MongoDataConverter converter = new MongoDataConverter(ArrayEncoding.ARRAY); final BsonDocument val = BsonDocument.parse(HETEROGENOUS_ARRAY); for (Entry<String, BsonValue> entry : val.entrySet()) { converter.addFieldSchema(entry, builder); } }
@Test public void shouldCreateStructWithNestedObject() { for (Entry<String, BsonValue> entry : val.entrySet()) { converter.addFieldSchema(entry, builder); } Schema finalSchema = builder.build(); Struct struct = new Struct(finalSchema); for (Entry<String, BsonValue> entry : val.entrySet()) { converter.convertRecord(entry, finalSchema, struct); } final GenericData.Record avro = (GenericData.Record)avroData.fromConnectData(finalSchema, struct); assertThat(avro.toString()).isEqualTo( "{\"_id\": 1, " + "\"s1\": {\"s1f1\": \"field1s1\", \"s1f2\": \"field2s1\"}, " + "\"s2\": {\"s2f1\": \"field1s2\", \"s2f2\": {\"in1\": 1}}}"); }
@Test public void shouldCreateStructForEmptyArrayEncodingDocument() throws Exception { final BsonDocument val = BsonDocument.parse(EMPTY_ARRAY); final MongoDataConverter documentConverter = new MongoDataConverter(ArrayEncoding.DOCUMENT); for (Entry<String, BsonValue> entry : val.entrySet()) { documentConverter.addFieldSchema(entry, builder); } final Schema documentSchema = builder.build(); final Struct struct = new Struct(documentSchema); for (Entry<String, BsonValue> entry : val.entrySet()) { documentConverter.convertRecord(entry, documentSchema, struct); } assertThat(struct.toString()).isEqualTo( "Struct{" + "_id=1," + "f=Struct{}}" ); }
@Test public void shouldCreateStructForHeterogenousArray() throws Exception { final MongoDataConverter converter = new MongoDataConverter(ArrayEncoding.DOCUMENT); final BsonDocument val = BsonDocument.parse(HETEROGENOUS_ARRAY); for (Entry<String, BsonValue> entry : val.entrySet()) { converter.addFieldSchema(entry, builder); } final Schema finalSchema = builder.build(); final Struct struct = new Struct(finalSchema); for (Entry<String, BsonValue> entry : val.entrySet()) { converter.convertRecord(entry, finalSchema, struct); } assertThat(struct.toString()).isEqualTo( "Struct{" + "_id=1," + "a2=Struct{_0=11,_1=abc}}" ); }
@Test public void shouldCreateSchemaForEmptyArrayEncodingArray() throws Exception { final BsonDocument val = BsonDocument.parse(EMPTY_ARRAY); final MongoDataConverter arrayConverter = new MongoDataConverter(ArrayEncoding.ARRAY); for (Entry<String, BsonValue> entry : val.entrySet()) { arrayConverter.addFieldSchema(entry, builder); } final Schema arraySchema = builder.build(); assertThat(arraySchema) .isEqualTo( SchemaBuilder.struct().name("array") .field("_id", Schema.OPTIONAL_INT32_SCHEMA) .field("f", SchemaBuilder.array(Schema.OPTIONAL_STRING_SCHEMA).optional().build()) .build()); }
@Test public void shouldCreateSchemaForEmptyArrayEncodingDocument() throws Exception { final BsonDocument val = BsonDocument.parse(EMPTY_ARRAY); final MongoDataConverter documentConverter = new MongoDataConverter(ArrayEncoding.DOCUMENT); for (Entry<String, BsonValue> entry : val.entrySet()) { documentConverter.addFieldSchema(entry, builder); } final Schema documentSchema = builder.build(); assertThat(documentSchema) .isEqualTo( SchemaBuilder.struct().name("array") .field("_id", Schema.OPTIONAL_INT32_SCHEMA) .field("f", SchemaBuilder.struct().name("array.f").optional().build()) .build()); }
@Test public void shouldCreateSchemaForHomogenousArray() throws Exception { final MongoDataConverter converter = new MongoDataConverter(ArrayEncoding.ARRAY); final BsonDocument val = BsonDocument.parse(HOMOGENOUS_ARRAYS); for (Entry<String, BsonValue> entry : val.entrySet()) { converter.addFieldSchema(entry, builder); } final Schema finalSchema = builder.build(); assertThat(finalSchema) .isEqualTo( SchemaBuilder.struct().name("array") .field("_id", Schema.OPTIONAL_INT32_SCHEMA) .field("a1", SchemaBuilder.array(SchemaBuilder.struct().name("array.a1").optional() .field("a", Schema.OPTIONAL_INT32_SCHEMA) .field("b", Schema.OPTIONAL_STRING_SCHEMA) .build() ).optional().build()) .field("a2", SchemaBuilder.array(Schema.OPTIONAL_STRING_SCHEMA).optional().build()) .field("empty", SchemaBuilder.array(Schema.OPTIONAL_STRING_SCHEMA).optional().build()) .build()); }