private AssignFieldPathUpdate readAssignFieldPathUpdate(DocumentType documentType, String fieldPath, TokenBuffer buffer) { AssignFieldPathUpdate fieldPathUpdate = new AssignFieldPathUpdate(documentType, fieldPath); FieldValue fv = SingleValueReader.readSingleValue( buffer, fieldPathUpdate.getFieldPath().getResultingDataType()); fieldPathUpdate.setNewValue(fv); return fieldPathUpdate; }
public static void applyUpdate(FieldPathUpdate update, Document doc) { if (update instanceof AddFieldPathUpdate) { update.applyTo(doc); } else if (update instanceof AssignFieldPathUpdate) { AssignFieldPathUpdate assign = (AssignFieldPathUpdate)update; boolean createMissingPath = assign.getCreateMissingPath(); boolean removeIfZero = assign.getRemoveIfZero(); assign.setCreateMissingPath(true); assign.setRemoveIfZero(false); assign.applyTo(doc); assign.setCreateMissingPath(createMissingPath); assign.setRemoveIfZero(removeIfZero); } else if (update instanceof RemoveFieldPathUpdate) { doc.iterateNested(update.getFieldPath(), 0, new MyHandler()); } }
public void write(AssignFieldPathUpdate update) { write((FieldPathUpdate)update); byte flags = 0; if (update.getRemoveIfZero()) { flags |= AssignFieldPathUpdate.REMOVE_IF_ZERO; } if (update.getCreateMissingPath()) { flags |= AssignFieldPathUpdate.CREATE_MISSING_PATH; } if (update.isArithmetic()) { flags |= AssignFieldPathUpdate.ARITHMETIC_EXPRESSION; putByte(null, flags); put(null, update.getExpression()); } else { putByte(null, flags); update.getFieldValue().serialize(this); } }
private AssignFieldPathUpdate readArithmeticFieldPathUpdate( DocumentType documentType, String fieldPath, TokenBuffer buffer, String fieldPathOperation) { AssignFieldPathUpdate fieldPathUpdate = new AssignFieldPathUpdate(documentType, fieldPath); String arithmeticSign = SingleValueReader.UPDATE_OPERATION_TO_ARITHMETIC_SIGN.get(fieldPathOperation); double value = Double.valueOf(buffer.currentText()); String expression = String.format("$value %s %s", arithmeticSign, value); fieldPathUpdate.setExpression(expression); return fieldPathUpdate; }
@Override public String toString() { return "Assign: " + super.toString() + " : " + (isArithmetic() ? getExpression() : getNewValue().toString()); }
public void read(AssignFieldPathUpdate update) { byte flags = getByte(null); update.setRemoveIfZero((flags & AssignFieldPathUpdate.REMOVE_IF_ZERO) != 0); update.setCreateMissingPath((flags & AssignFieldPathUpdate.CREATE_MISSING_PATH) != 0); if ((flags & AssignFieldPathUpdate.ARITHMETIC_EXPRESSION) != 0) { update.setExpression(getString(null)); } else { DataType dt = update.getFieldPath().getResultingDataType(); FieldValue fv = dt.createFieldValue(); fv.deserialize(this); update.setNewValue(fv); } }
public static FieldPathUpdate create(Type type, DocumentType docType, DocumentUpdateReader reader) { switch (type) { case ASSIGN: return new AssignFieldPathUpdate(docType, reader); case ADD: return new AddFieldPathUpdate(docType, reader); case REMOVE: return new RemoveFieldPathUpdate(docType, reader); } throw new IllegalArgumentException("Field path update type '" + type + "' not supported."); }
private void write(FieldPath fieldPath, Collection<FieldPathUpdate> fieldPathUpdates, JsonGenerator generator) throws IOException { generator.writeObjectFieldStart(fieldPath.toString()); for (FieldPathUpdate update : fieldPathUpdates) { if (writeArithmeticFieldPathUpdate(update, generator)) continue; generator.writeFieldName(update.getUpdateType().name().toLowerCase()); if (update instanceof AssignFieldPathUpdate) { AssignFieldPathUpdate assignUp = (AssignFieldPathUpdate) update; if (assignUp.getExpression() != null) { throw new RuntimeException("Unable to parse expression: " + assignUp.getExpression()); } else { assignUp.getNewValue().serialize(null, this); } } else if (update instanceof AddFieldPathUpdate) { ((AddFieldPathUpdate) update).getNewValues().serialize(null, this); } else if (update instanceof RemoveFieldPathUpdate) { generator.writeNumber(0); } else { throw new RuntimeException("Unsupported fieldpath operation: " + update.getClass().getName()); } } generator.writeEndObject(); }
private boolean writeArithmeticFieldPathUpdate(FieldPathUpdate fieldPathUpdate, JsonGenerator generator) throws IOException { if (! (fieldPathUpdate instanceof AssignFieldPathUpdate)) return false; String expression = ((AssignFieldPathUpdate) fieldPathUpdate).getExpression(); if (expression == null) return false; Matcher matcher = SingleValueReader.matchArithmeticOperation(expression); if (matcher.find()) { String updateOperation = SingleValueReader.ARITHMETIC_SIGN_TO_UPDATE_OPERATION.get(matcher.group(1)); double value = Double.valueOf(matcher.group(2)); generator.writeNumberField(updateOperation, value); return true; } return false; }
public void read(AssignFieldPathUpdate update) { byte flags = getByte(null); update.setRemoveIfZero((flags & AssignFieldPathUpdate.REMOVE_IF_ZERO) != 0); update.setCreateMissingPath((flags & AssignFieldPathUpdate.CREATE_MISSING_PATH) != 0); if ((flags & AssignFieldPathUpdate.ARITHMETIC_EXPRESSION) != 0) { update.setExpression(getString(null)); } else { DataType dt = update.getFieldPath().getResultingDataType(); FieldValue fv = dt.createFieldValue(); fv.deserialize(this); update.setNewValue(fv); } }
if (hasFieldPath()) { if ("assign".equals(currentName)) { update.addFieldPathUpdate(new AssignFieldPathUpdate(doctype, this)); skipToEnd("assign"); } else if ("add".equals(currentName)) {
public void read(AssignFieldPathUpdate update) { try { for (int i = 0; i < reader.getAttributeCount(); i++) { if (reader.getAttributeName(i).toString().equals("removeifzero")) { update.setRemoveIfZero(Boolean.parseBoolean(reader.getAttributeValue(i))); } else if (reader.getAttributeName(i).toString().equals("createmissingpath")) { update.setCreateMissingPath(Boolean.parseBoolean(reader.getAttributeValue(i))); } } DataType dt = update.getFieldPath().getResultingDataType(); if (dt instanceof NumericDataType) { update.setExpression(reader.getElementText()); } else { FieldValue fv = dt.createFieldValue(); fv.deserialize(resolveField(update), this); update.setNewValue(fv); } } catch (XMLStreamException e) { throw newException(e); } }
update.getOriginalWhereClause(), (Array)value)); } else if (update instanceof AssignFieldPathUpdate) { out.addFieldPathUpdate(new AssignFieldPathUpdate(update.getDocumentType(), new FieldPath(path).toString(), update.getOriginalWhereClause(), value)); } else if (update instanceof RemoveFieldPathUpdate) {