private void mergeKeys(Key mergeInto, Key mergeFrom, KeyNameMapper sourceNameMapper, KeyNameMapper targetNameMapper) { Set<String> sourceFields = sourceNameMapper.getFieldSet(); sourceFields.removeAll(targetNameMapper.getFieldSet()); if(!sourceFields.isEmpty()) { for(String sourceField : sourceFields) { targetNameMapper.addMappedField(sourceField); mergeInto.addKey(targetNameMapper, sourceField, mergeFrom); } } } }
@Override public Map<String, Key> getKeysByName(KeyNameMapper keyMapper) { Map<String, Key> mappedKeys = new HashMap<>(); for(int i=0; i<keys.length; i++) { mappedKeys.put(keyMapper.getFieldForIndex(i), keys[i]); } return mappedKeys; }
@Override public Key addKey(KeyNameMapper keyMapper, String name, Key key) { int index = keyMapper.getIndexForField(name); int size = keyMapper.size(); if(keys == null) { keys = new Key[size]; } else if(index < size) { keys = Arrays.copyOf(keys, size); } keys[index] = key; return this; }
public KeyInfoImpl(String headerDescriptor, String valueDescriptor) throws JasDBStorageException { KeyFactory[] keyFactories = KeyFactoryManager.parseHeader(headerDescriptor); if(keyFactories.length == 1) { this.keyFactory = keyFactories[0]; LOG.debug("Loaded key index for field: {} and factory: {}", keyFactory.getFieldName(), keyFactory); this.fields = new LinkedList<>(); this.valueFields = new LinkedList<>(); if(this.keyFactory instanceof CompositeKeyFactory) { MultiKeyloader multiKeyloader = ((CompositeKeyFactory)keyFactory).getMultiKeyloader(); this.fields.addAll(multiKeyloader.getFields()); this.keyNameMapper = multiKeyloader.getKeyNameMapper(); this.keyNameMapper.setValueMarker(multiKeyloader.getFields().size()); } else { this.fields.add(keyFactory.getFieldName()); this.keyNameMapper = new KeyNameMapperImpl(); this.keyNameMapper.setValueMarker(0); } KeyFactory[] valueFactories = KeyFactoryManager.parseHeader(valueDescriptor); for(int i=0; i<valueFactories.length; i++) { String fieldName = valueFactories[i].getFieldName(); keyNameMapper.addMappedField(fieldName); valueFields.add(fieldName); } this.multiValueKeyLoader = new MultiKeyLoaderImpl(keyNameMapper, valueFactories); this.wrapperKeyFactory = new WrappedValueKeyFactory(keyFactory, multiValueKeyLoader); } else { throw new JasDBStorageException("Unexpected key information in headers"); } }
private MultiKeyloader createMultiKeyLoader(List<IndexField> fields, KeyNameMapper mapper) throws JasDBStorageException { KeyFactory[] keyFactories = new KeyFactory[fields.size()]; for(int i=0; i<fields.size(); i++) { IndexField field = fields.get(i); keyFactories[i] = KeyFactoryManager.createKeyFactory(field.getField(), field.getKeyType()); mapper.addMappedField(field.getField()); } return new MultiKeyLoaderImpl(mapper, keyFactories); }
@Override public Key setKeys(KeyNameMapper keyMapper, Map<String, Key> keyFields) { this.valueMarker = keyMapper.getValueMarker(); return super.setKeys(keyMapper, keyFields); }
private IndexSearchResultIteratorCollection doLeaveSearch(LeaveBlock leaveBlock, Key desiredKey) { List<Key> results = new ArrayList<>(1); if(leaveBlock.contains(desiredKey)) { results.add(leaveBlock.getKey(desiredKey)); } return new IndexSearchResultIteratorImpl(results, keyInfo.getKeyNameMapper().clone()); }
@Override public Key getKey(KeyNameMapper keyMapper, String name) { return getKey(keyMapper.getIndexForField(name)); }
public KeyInfoImpl(List<IndexField> keyFields, List<IndexField> valueFields) throws JasDBStorageException { if(keyFields.size() == 1) { IndexField indexField = keyFields.get(0); this.keyFactory = KeyFactoryManager.createKeyFactory(indexField.getField(), indexField.getKeyType()); this.fields = Lists.newArrayList(keyFactory.getFieldName()); this.keyNameMapper = new KeyNameMapperImpl(); this.keyNameMapper.setValueMarker(0); } else if(keyFields.size() > 1) { MultiKeyloader keyloader = createMultiKeyLoader(keyFields, new KeyNameMapperImpl()); this.keyNameMapper = keyloader.getKeyNameMapper(); this.keyNameMapper.setValueMarker(keyFields.size()); this.keyFactory = new CompositeKeyFactory(keyloader); this.fields = keyloader.getFields(); } else { throw new JasDBStorageException("Unable to create key information, no keys specified"); } this.multiValueKeyLoader = createMultiKeyLoader(valueFields, this.keyNameMapper); this.valueFields = multiValueKeyLoader.getFields(); this.wrapperKeyFactory = new WrappedValueKeyFactory(keyFactory, multiValueKeyLoader); }
private IndexSearchResultIteratorCollection doSort(IndexSearchResultIteratorCollection results, List<SortParameter> params) throws JasDBStorageException { Set<String> requiredKeys = new HashSet<>(); for(SortParameter sortParam : params) { String paramField = sortParam.getField(); if(!results.getKeyNameMapper().isMapped(paramField)) { LOG.debug("Sorting field: {} not present in index results following keys present: {}", paramField, results.getKeyNameMapper()); requiredKeys.add(paramField); } } ensureSortingParams(results, requiredKeys); for(SortParameter sortParam : params) { String field = sortParam.getField(); if(results.getKeyNameMapper().isMapped(field)) { List<Key> sortedKeys = doMergeSort(results.getKeys(), sortParam.getField(), sortParam.getOrder(), results.getKeyNameMapper()); results = new IndexSearchResultIteratorImpl(sortedKeys, results.getKeyNameMapper()); } } return results; }
private IndexSearchResultIterator ensureSortingParams(IndexSearchResultIterator results, Set<String> requiredFields) throws JasDBStorageException { if(!requiredFields.isEmpty()) { KeyNameMapper keyNameMapper = results.getKeyNameMapper(); for(Key key : results) { UUIDKey documentKey = KeyUtil.getDocumentKey(results.getKeyNameMapper(), key); RecordResult recordResult = recordWriter.readRecord(documentKey); Entity entity = SimpleEntity.fromStream(recordResult.getStream()); for(String requiredField : requiredFields) { Property property = entity.getProperty(requiredField); if(property != null) { Key propertyKey = PropertyKeyMapper.mapToKey(property); keyNameMapper.addMappedField(requiredField); key.addKey(keyNameMapper, requiredField, propertyKey); } } } results.reset(); } return results; }
@Override public Key addKey(KeyNameMapper keyMapper, String name, Key key) { this.valueMarker = keyMapper.getValueMarker(); return super.addKey(keyMapper, name, key); }
return new IndexSearchResultIteratorImpl(results, keyInfo.getKeyNameMapper().clone()); } finally { lockManager.releaseLockChain();
@Override public Key setKeys(KeyNameMapper keyMapper, Map<String, Key> keyFields) { this.keys = new Key[keyMapper.size()]; for(Map.Entry<String, Key> keyEntry : keyFields.entrySet()) { keys[keyMapper.getIndexForField(keyEntry.getKey())] = keyEntry.getValue(); } return this; }