private void refreshFieldsByName() { this.fieldsByName.clear(); for (IndexFieldDefinition field : fields) { fieldsByName.put(field.getName(), field); } }
@Override public int hashCode() { int result = name != null ? name.hashCode() : 0; result = 31 * result + (fields != null ? fields.hashCode() : 0); result = 31 * result + (identifierIndexFieldDefinition != null ? identifierIndexFieldDefinition.hashCode() : 0); return result; }
@Override public void readFields(DataInput in) throws IOException { super.readFields(in); fixedPrefixLength = in.readInt(); } }
final IndexFieldDefinition fieldDef = definition.getFields().get(definedFieldsIndex); final Query.EqualsCondition eqCond = query.getCondition(fieldDef.getName()); if (eqCond != null) { final RowKey key = fieldDef.asRowKey(); key.setTermination(Termination.MUST); fromKeyStructBuilder.add(key); if (!rangeCond.getName().equals(fieldDef.getName())) { throw new MalformedQueryException("Query defines range condition on field " + rangeCond.getName() + " but has no equals condition on field " + fieldDef.getName() + " which comes earlier in the index definition."); checkQueryValueType(fieldDef, fromValue); fromKeyComponents.add(fromValue); fromKeyStructBuilder.add(fieldDef.asRowKeyWithoutTermination()); checkQueryValueType(fieldDef, toValue); toKeyComponents.add(toValue); toKeyStructBuilder.add(fieldDef.asRowKeyWithoutTermination()); for (; definedFieldsIndex < definition.getFields().size(); definedFieldsIndex++) { IndexFieldDefinition fieldDef = definition.getFields().get(definedFieldsIndex); if (query.getCondition(fieldDef.getName()) != null) { message.append(fieldDef.getName()); } else if (rangeCond != null && rangeCond.getName().equals(fieldDef.getName())) { message.append(fieldDef.getName());
private void checkQueryValueType(IndexFieldDefinition fieldDef, Object value) { if (value != null) { final RowKey rowKey = fieldDef.asRowKey(); if (!rowKey.getDeserializedClass().isAssignableFrom(value.getClass())) { throw new MalformedQueryException("query for field " + fieldDef.getName() + " contains" + " a value of an incorrect type. Expected: " + rowKey.getDeserializedClass() + ", found: " + value.getClass().getName()); } } }
public ObjectNode toJson() { JsonNodeFactory factory = JsonNodeFactory.instance; ObjectNode object = factory.objectNode(); ObjectNode fieldsJson = object.putObject("fields"); for (IndexFieldDefinition field : fields) { fieldsJson.put(field.getName(), field.toJson()); } object.put("identifierOrder", this.identifierIndexFieldDefinition.getOrder().toString()); return object; }
public StructRowKey asStructRowKey() { final StructBuilder structBuilder = new StructBuilder(); // add all fields for (IndexFieldDefinition field : fields) { structBuilder.add(field.asRowKey()); } // add identifier structBuilder.add(this.identifierIndexFieldDefinition.asRowKey()); return structBuilder.toRowKey(); }
@Override public void write(DataOutput out) throws IOException { super.write(out); out.writeInt(fixedPrefixLength); }
@Override public ObjectNode toJson() { ObjectNode object = super.toJson(); object.put("length", length); return object; }
public void setIdentifierOrder(Order identifierOrder) { Preconditions.checkNotNull(identifierOrder, "Null argument: identifierOrder"); this.identifierIndexFieldDefinition = new VariableLengthByteIndexFieldDefinition("identifier"); this.identifierIndexFieldDefinition.setOrder(identifierOrder); }
/** * Check if the index definition would support storing the given field with the given value. * * @param fieldName name of the field to be stored in the index * @param fieldValue value to be stored under this name * @throws MalformedIndexEntryException if the given field is not supported */ public void checkFieldSupport(String fieldName, Object fieldValue) { final IndexFieldDefinition correspondingIndexFieldDefinition = fieldsByName.get(fieldName); if (correspondingIndexFieldDefinition == null) { throw new MalformedIndexEntryException("Index entry contains a field that is not part of " + "the index definition: " + fieldName); } else if (fieldValue != null) { final RowKey rowKey = correspondingIndexFieldDefinition.asRowKey(); if (!rowKey.getDeserializedClass().isAssignableFrom(fieldValue.getClass())) { throw new MalformedIndexEntryException("Index entry for field " + fieldName + " contains" + " a value of an incorrect type. Expected: " + rowKey.getDeserializedClass() + ", found: " + fieldValue.getClass().getName()); } } }
@Override public void write(DataOutput out) throws IOException { super.write(out); out.writeInt(length); }
@Override public ObjectNode toJson() { ObjectNode object = super.toJson(); object.put("fixedPrefixLength", fixedPrefixLength); return object; }
private IndexFieldDefinition add(IndexFieldDefinition fieldDef) { fields.add(fieldDef); fieldsByName.put(fieldDef.getName(), fieldDef); return fieldDef; }
@Override public void readFields(DataInput in) throws IOException { super.readFields(in); length = in.readInt(); } }
@Override public void write(DataOutput out) throws IOException { /* private final String name; private final List<IndexFieldDefinition> fields = new ArrayList<IndexFieldDefinition>(); private final Map<String, IndexFieldDefinition> fieldsByName = new HashMap<String, IndexFieldDefinition>(); private IndexFieldDefinition identifierIndexFieldDefinition; */ out.writeUTF(name); out.writeInt(fields.size()); for (IndexFieldDefinition field : fields) { out.writeUTF(field.getClass().getName()); field.write(out); } out.writeUTF(identifierIndexFieldDefinition.getClass().getName()); identifierIndexFieldDefinition.write(out); }
/** * Get the position of a given field in the index definition. * * @param fieldName name of the field to look for * @return position in the index, or -1 if the field is not part of the index */ public int getFieldPosition(String fieldName) { int pos = 0; for (IndexFieldDefinition field : fields) { if (field.getName().equals(fieldName)) { return pos; } pos++; } return -1; }
@Override public void readFields(DataInput in) throws IOException { name = in.readUTF(); final int fieldsSize = in.readInt(); fields = new ArrayList<IndexFieldDefinition>(fieldsSize); for (int i = 0; i < fieldsSize; i++) { final String indexFieldDefinitionClassName = in.readUTF(); final IndexFieldDefinition indexFieldDefinition = (IndexFieldDefinition) tryInstantiateClass(indexFieldDefinitionClassName); indexFieldDefinition.readFields(in); fields.add(indexFieldDefinition); } final String identifierIndexFieldDefinitionClassName = in.readUTF(); identifierIndexFieldDefinition = (IndexFieldDefinition) tryInstantiateClass(identifierIndexFieldDefinitionClassName); identifierIndexFieldDefinition.readFields(in); refreshFieldsByName(); }
/** * Get the values to be serialized into a byte array, in index definition order. Missing fields are inserted as * null values. * * @return the values to be serialized into a byte array */ Object[] getFieldValuesInSerializationOrder() { final List<Object> values = new ArrayList<Object>(definition.getFields().size() + 1); for (IndexFieldDefinition indexFieldDefinition : definition.getFields()) { final Object fieldValueOrNull = fields.get(indexFieldDefinition.getName()); values.add(fieldValueOrNull); } values.add(identifier); return values.toArray(); }
@Override public boolean filterRowKey(byte[] buffer, int offset, int length) { final StructRowKey structRowKey = indexDefinition.asStructRowKey(); structRowKey.iterateOver(buffer, offset); final StructIterator fieldsIterator = structRowKey.iterator(); final List<IndexFieldDefinition> fieldDefinitions = indexDefinition.getFields(); // for all defined field definitions for (IndexFieldDefinition field : fieldDefinitions) { // check if the field should be filtered if (indexFilter.getFields().contains(field.getName())) { final Object nextField = fieldsIterator.next(); if (indexFilter.filterField(field.getName(), nextField)) { return true; // this result is ignored } } else { try { fieldsIterator.skip(); } catch (IOException e) { throw new RuntimeException("failed to skip, index inconsistency?", e); } } } return false; // nothing was skipped }