private SearchCondition handleEqualsToRange(EqualsCondition equalsCondition) { int nrOfKeys = keyInfo.getKeyFields().size(); if(nrOfKeys > 1) { //composite keys always use range search return new RangeCondition(equalsCondition.getKey(), true, equalsCondition.getKey(), true); } else { return equalsCondition; } }
@Override public int hashCode() { return toString().hashCode(); }
@Override public Key next() { return hasNext() ? keyIterator.next() : null; }
@Override public SearchCondition mergeCondition(KeyNameMapper nameMapper, String sourceField, String mergeField, SearchCondition condition) { if(condition instanceof EqualsCondition) { CompositeKey compositeKey; if(key instanceof CompositeKey) { compositeKey = (CompositeKey) key; } else { compositeKey = new CompositeKey(); compositeKey.addKey(nameMapper, sourceField, key); } return new EqualsCondition(compositeKey.addKey(nameMapper, mergeField, ((EqualsCondition) condition).getKey())); } else if(condition instanceof RangeCondition) { RangeCondition rangeCondition = (RangeCondition) condition; Key startKey = null, endKey = null; if(rangeCondition.getStart() != null) { startKey = new CompositeKey() .addKey(nameMapper, sourceField, key) .addKey(nameMapper, mergeField, rangeCondition.getStart()); } if(rangeCondition.getEnd() != null) { endKey = new CompositeKey() .addKey(nameMapper, sourceField, key) .addKey(nameMapper, mergeField, rangeCondition.getEnd()); } return new RangeCondition(startKey, rangeCondition.isStartIncluded(), endKey, rangeCondition.isEndIncluded()); } return null; }
private static RangeCondition mergeRangeConditions(List<RangeCondition> rangeConditions) { Key lowestKey = null; boolean startInclusive = false; boolean endInclusive = false; Key highestKey = null; for(SearchCondition condition : rangeConditions) { RangeCondition rangeCondition = (RangeCondition) condition; Key rangeStartKey = rangeCondition.getStart(); Key rangeEndKey = rangeCondition.getEnd(); if(rangeStartKey != null && (lowestKey == null || rangeStartKey.compareTo(lowestKey) < 0)) { lowestKey = rangeStartKey; startInclusive = rangeCondition.isStartIncluded(); } if(rangeEndKey != null && (highestKey == null || rangeEndKey.compareTo(highestKey) > 0)) { highestKey = rangeEndKey; endInclusive = rangeCondition.isEndIncluded(); } } return new RangeCondition(lowestKey, startInclusive, highestKey, endInclusive); }
private static SearchCondition createCondition(QueryField queryField) { Key searchKey = valueToKey(queryField.getSearchKey()); switch(queryField.getOperator()) { case LARGER_THAN: return new RangeCondition(searchKey, false, null, false); case LARGER_THAN_OR_EQUALS: return new RangeCondition(searchKey, true, null, false); case SMALLER_THAN: return new RangeCondition(null, false, searchKey, false); case SMALLER_THAN_OR_EQUALS: return new RangeCondition(null, false, searchKey, true); case NOT_EQUALS: return new NotEqualsCondition(searchKey); case EQUALS: default: return new EqualsCondition(searchKey); } }
private RangeCondition validateRangeCondition(SearchCondition condition) throws JasDBStorageException { if(condition instanceof RangeCondition) { KeyFactory factory = keyInfo.getKeyFactory(); RangeCondition rangeCondition = (RangeCondition) condition; rangeCondition.setStart(validateKey(factory, rangeCondition.getStart())); rangeCondition.setEnd(validateKey(factory, rangeCondition.getEnd())); return rangeCondition; } else { throw new JasDBStorageException("Invalid Range condition input: " + condition); } }
protected static EqualsCondition validateCondition(KeyInfo keyInfo, SearchCondition condition) throws JasDBStorageException { if(condition instanceof EqualsCondition) { EqualsCondition equalsCondition = (EqualsCondition) condition; KeyFactory keyFactory = keyInfo.getKeyFactory(); if(!keyFactory.supportsKey(equalsCondition.getKey())) { Key supportedKey = keyFactory.convertKey(equalsCondition.getKey()); return new EqualsCondition(supportedKey); } else { return equalsCondition; } } else { throw new JasDBStorageException("Invalid Equals condition input: " + condition); } }
@Override public SearchCondition mergeCondition(KeyNameMapper nameMapper, String sourceField, String mergeField, SearchCondition condition) { if(condition instanceof NotEqualsCondition) { CompositeKey compositeKey; Key key = getKey(); if(key instanceof CompositeKey) { compositeKey = (CompositeKey) key; } else { compositeKey = new CompositeKey(); compositeKey.addKey(nameMapper, sourceField, key); } return new NotEqualsCondition(compositeKey.addKey(nameMapper, mergeField, ((EqualsCondition) condition).getKey())); } return null; }
@Override public List<IndexField> getIndexValueFields() { List<IndexField> valueFields = new ArrayList<>(); for(KeyFactory vKeyFactory : multiValueKeyLoader.getKeyFactories()) { valueFields.add(new SimpleIndexField(vKeyFactory.getFieldName(), vKeyFactory.getKeyType())); } return valueFields; }
@Override public IndexSearchResultIteratorCollection search(SearchCondition condition, SearchLimit limit) throws JasDBStorageException { IndexIterator indexIterator = new FullIndexIterator(rootBlock, lockManager, blockPersister); EqualsCondition equalsCondition = EqualsSearchOperation.validateCondition(keyInfo, condition); Key undesiredKey = equalsCondition.getKey(); List<Key> results = new LinkedList<>(); for(Key key : indexIterator) { if(key.compare(undesiredKey, CompareMethod.EQUALS).getCompare() != 0) { results.add(key); } if(limit.isMaxReached(results.size())) { break; } } return new IndexSearchResultIteratorImpl(results, keyInfo.getKeyNameMapper()); } }
@Override public RecordResult readRecord(UUIDKey documentId) throws JasDBStorageException { IndexSearchResultIterator resultIterator = index.searchIndex(new EqualsCondition(documentId), Index.NO_SEARCH_LIMIT); if(!resultIterator.isEmpty()) { Key key = resultIterator.next(); DataKey dataKey = (DataKey) key.getKey(keyInfo.getKeyNameMapper(), "data"); return new BtreeRecordResult(dataKey); } else { return new BtreeRecordResult(); } }
private static void generateEqualsCondition(StringBuilder builder, String field, EqualsCondition equalsCondition) { Key key = equalsCondition.getKey(); builder.append(field).append("="); handleValueAppend(builder, key); }
@Override public boolean keyQualifies(Key key) { return getKey().compareTo(key) != 0; }
@Override public IndexSearchResultIteratorCollection mergeIterators(IndexSearchResultIteratorCollection mergeInto, IndexSearchResultIteratorCollection... results) { List<Key> mergedKeys = new ArrayList<>(mergeInto.getKeys()); for(IndexSearchResultIteratorCollection collection : results) { mergeInto(mergedKeys, collection); } return new IndexSearchResultIteratorImpl(mergedKeys, mergeInto.getKeyNameMapper()); }
private static void generateRangeCondition(StringBuilder builder, String field, RangeCondition rangeCondition) { Key startKey = rangeCondition.getStart(); Key endKey = rangeCondition.getEnd(); if(startKey != null) { builder.append(field).append(rangeCondition.isStartIncluded() ? ">=" : ">"); handleValueAppend(builder, startKey); } if(startKey != null && endKey != null) { builder.append(","); } if(endKey != null) { builder.append(field).append(rangeCondition.isEndIncluded() ? "<=" : "<"); handleValueAppend(builder, endKey); } }
@Override public Index createIndex(String bagName, IndexField indexField, boolean unique, IndexField... valueFields) throws JasDBStorageException { KeyInfo keyInfo; if(unique) { keyInfo = new KeyInfoImpl(indexField, guaranteeIdKey(valueFields)); } else { keyInfo = new KeyInfoImpl(Lists.newArrayList(indexField, new SimpleIndexField(SimpleEntity.DOCUMENT_ID, new UUIDKeyType())), Lists.newArrayList(valueFields)); } return createInStore(bagName, keyInfo); }
@Override public IndexSearchResultIteratorCollection search(SearchCondition condition, SearchLimit limit) throws JasDBStorageException { EqualsCondition equalsCondition = validateCondition(keyInfo, condition); Key desiredKey = equalsCondition.getKey(); lockManager.startLockChain(); lockManager.acquireLock(LockIntentType.READ, rootBlock); try { LeaveBlock leaveBlock = rootBlock.findLeaveBlock(LockIntentType.READ, equalsCondition.getKey()); return doLeaveSearch(leaveBlock, desiredKey); } finally { lockManager.releaseLockChain(); } }
private static void generateNotEqualsCondition(StringBuilder builder, String field, NotEqualsCondition notEqualsCondition) { Key key = notEqualsCondition.getKey(); builder.append(field).append("!="); handleValueAppend(builder, key); }
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()); }