public String getMultiValueField() { if (multiValueDefinitionIndex >= 0) return indexDefinitions.get(multiValueDefinitionIndex).getFields().get(0); return null; }
/** * Checks if existing index consists of exactly the same fields. If not, error thrown to indicate * probable programmer error. * * @param fields new signature index fields */ public void checkFieldsCompatible(final String... fields) { final Set<String> indexFields = Sets.newHashSet(index.getDefinition().getFields()); final Joiner joiner = Joiner.on(","); check(indexFields.equals(Sets.newHashSet(fields)), "Existing index '%s' (class '%s') fields '%s' are different from '%s'.", index.getName(), index.getDefinition().getClassName(), joiner.join(indexFields), joiner.join(fields)); }
protected Query buildQuery(OIndexDefinition index, String query, ODocument metadata, Analyzer queryAnalyzer) throws ParseException { String[] fields; if (index.isAutomatic()) { fields = index.getFields().toArray(new String[index.getFields().size()]); } else { int length = index.getTypes().length; fields = new String[length]; for (int i = 0; i < length; i++) { fields[i] = "k" + i; } } Map<String, OType> types = new HashMap<>(); for (int i = 0; i < fields.length; i++) { String field = fields[i]; types.put(field, index.getTypes()[i]); } return getQuery(index, query, metadata, queryAnalyzer, fields, types); }
private Collection toIndexKey(OIndexDefinition definition, Object rightValue) { if (definition.getFields().size() == 1 && rightValue instanceof Collection) { rightValue = ((Collection) rightValue).iterator().next(); } if (rightValue instanceof List) { rightValue = definition.createValue((List<?>) rightValue); } else { rightValue = definition.createValue(rightValue); } if (!(rightValue instanceof Collection)) { rightValue = Collections.singleton(rightValue); } return (Collection) rightValue; }
private boolean canCheck(OIndex index) { OIndexDefinition indexDef = index.getDefinition(); String className = indexDef.getClassName(); if (className == null) { return false; //manual index, not supported yet } List<String> fields = indexDef.getFields(); List<String> fieldDefs = indexDef.getFieldsToIndex(); //check if there are fields defined on maps (by key/value). Not supported yet for (int i = 0; i < fieldDefs.size(); i++) { if (!fields.get(i).equals(fieldDefs.get(i))) { return false; } } return true; }
private Iterable fetchFromIndex(OIndex index, Map<String, Object> conditions) { OIndexDefinition definition = index.getDefinition(); List<String> definitionFields = definition.getFields(); Object key = null; if (definition instanceof OPropertyIndexDefinition) { key = convert(conditions.get(definitionFields.get(0)), definition.getTypes()[0]); } else if (definition instanceof OCompositeIndexDefinition) { key = new OCompositeKey(); break; Object keyValue = convert(conditions.get(keyName), definition.getTypes()[i]); ((OCompositeKey) key).addKey(conditions.get(keyName));
final long size = index.getKeySize(); if (indexDefinition != null) { row.field("CLASS", indexDefinition.getClassName()); row.field("COLLATE", indexDefinition.getCollate().getName()); final List<String> fields = indexDefinition.getFields(); final StringBuilder buffer = new StringBuilder(); for (int i = 0; i < fields.size(); ++i) { buffer.append(indexDefinition.getTypes()[i]); buffer.append(")");
try { final OIndexDefinition indexDefinition = idx.getDefinition(); if (indexDefinition == null || indexDefinition.getClassName() == null) return; Map<OMultiKey, Set<OIndex<?>>> map = classPropertyIndex.get(indexDefinition.getClassName().toLowerCase(locale)); final int paramCount = indexDefinition.getParamCount(); final List<String> fields = indexDefinition.getFields().subList(0, i); final OMultiKey multiKey = new OMultiKey(fields); classPropertyIndex.remove(indexDefinition.getClassName().toLowerCase(locale)); else classPropertyIndex.put(indexDefinition.getClassName().toLowerCase(locale), copyPropertyMap(map));
private static void processSingleIndexUpdate(final OIndex<?> index, final Set<String> dirtyFields, final ODocument iRecord) { final OIndexDefinition indexDefinition = index.getDefinition(); final List<String> indexFields = indexDefinition.getFields(); if (indexFields.isEmpty()) return; final String indexField = indexFields.get(0); if (!dirtyFields.contains(indexField)) return; final OMultiValueChangeTimeLine<?, ?> multiValueChangeTimeLine = iRecord.getCollectionTimeLine(indexField); if (multiValueChangeTimeLine != null) { final OIndexDefinitionMultiValue indexDefinitionMultiValue = (OIndexDefinitionMultiValue) indexDefinition; final Map<Object, Integer> keysToAdd = new HashMap<Object, Integer>(); final Map<Object, Integer> keysToRemove = new HashMap<Object, Integer>(); for (OMultiValueChangeEvent<?, ?> changeEvent : multiValueChangeTimeLine.getMultiValueChangeEvents()) { indexDefinitionMultiValue.processChangeEvent(changeEvent, keysToAdd, keysToRemove); } for (final Object keyToRemove : keysToRemove.keySet()) index.remove(keyToRemove, iRecord); for (final Object keyToAdd : keysToAdd.keySet()) index.put(keyToAdd, iRecord.placeholder()); } else { final Object origValue = indexDefinition.createValue(iRecord.getOriginalValue(indexField)); final Object newValue = indexDefinition.getDocumentValueToIndex(iRecord); processIndexUpdateFieldAssignment(index, iRecord, origValue, newValue); } }
Field.Index.NOT_ANALYZED_NO_NORMS)); int i = 0; if (index.isAutomatic()) { for (String f : index.getFields()) { if (!index.isAutomatic()) { commit();
public Set<OIndex<?>> getClassInvolvedIndexes(final String className, Collection<String> fields) { final OMultiKey multiKey = new OMultiKey(fields); final Map<OMultiKey, Set<OIndex<?>>> propertyIndex = getIndexOnProperty(className); if (propertyIndex == null || !propertyIndex.containsKey(multiKey)) return Collections.emptySet(); final Set<OIndex<?>> rawResult = propertyIndex.get(multiKey); final Set<OIndex<?>> transactionalResult = new HashSet<>(rawResult.size()); for (final OIndex<?> index : rawResult) { //ignore indexes that ignore null values on partial match if (fields.size() == index.getDefinition().getFields().size() || !index.getDefinition().isNullValuesIgnored()) { transactionalResult.add(preProcessBeforeReturn(getDatabase(), index)); } } return transactionalResult; }
public boolean isAutomatic() { return indexDefinition != null && indexDefinition.getClassName() != null; }
private static int determineKeySize(final OIndexDefinition indexDefinition) { if (indexDefinition == null || indexDefinition instanceof ORuntimeKeyIndexDefinition) { return 1; } else { return indexDefinition.getTypes().length; } }
public OCompositeKey createSingleValue(final List<?> params) { final OCompositeKey compositeKey = new OCompositeKey(); int currentParamIndex = 0; for (final OIndexDefinition indexDefinition : indexDefinitions) { if (currentParamIndex + 1 > params.size()) break; final int endIndex; if (currentParamIndex + indexDefinition.getParamCount() > params.size()) endIndex = params.size(); else endIndex = currentParamIndex + indexDefinition.getParamCount(); final List<?> indexParams = params.subList(currentParamIndex, endIndex); currentParamIndex += indexDefinition.getParamCount(); final Object keyValue; if (indexDefinition instanceof OIndexDefinitionMultiValue) keyValue = ((OIndexDefinitionMultiValue) indexDefinition).createSingleValue(indexParams.toArray()); else keyValue = indexDefinition.createValue(indexParams); if (keyValue == null && isNullValuesIgnored()) return null; compositeKey.addKey(keyValue); } return compositeKey; }
final OType[] keyTypes = indexDefinition != null ? indexDefinition.getTypes() : null; final boolean nullValuesSupport = indexDefinition != null && !indexDefinition.isNullValuesIgnored(); final byte serializerId;
continue; final String clsName = index.getDefinition() != null ? index.getDefinition().getClassName() : null; writer.writeAttribute(5, true, "stream", index.getDefinition().toStream());
/** * Add new indexDefinition in current composite. * * @param indexDefinition Index to add. */ public void addIndex(final OIndexDefinition indexDefinition) { indexDefinitions.add(indexDefinition); if (indexDefinition instanceof OIndexDefinitionMultiValue) { if (multiValueDefinitionIndex == -1) multiValueDefinitionIndex = indexDefinitions.size() - 1; else throw new OIndexException("Composite key cannot contain more than one collection item"); } collate.addCollate(indexDefinition.getCollate()); }
Object ignoreNullValues = metadata == null ? null : metadata.field("ignoreNullValues"); if (Boolean.TRUE.equals(ignoreNullValues)) { indexDefinition.setNullValuesIgnored(true); } else if (Boolean.FALSE.equals(ignoreNullValues)) { indexDefinition.setNullValuesIgnored(false); } else { indexDefinition.setNullValuesIgnored( database.getConfiguration().getValueAsBoolean(OGlobalConfiguration.INDEX_IGNORE_NULL_VALUES_DEFAULT)); final String clusterName = indexDefinition.getClassName() != null ? defaultClusterName : manualClusterName;
indexDefinition.fromStream(indDoc); collate.addCollate(indexDefinition.getCollate());
if (index.getDefinition().getParamCount() == 1) { final OType type = index.getDefinition().getTypes()[0]; keyValue = OType.convert(keyValue, type.getDefaultJavaType()); final Object secondKey = getIndexKey(index.getDefinition(), right, context); if (keyValue instanceof OCompositeKey && secondKey instanceof OCompositeKey && ((OCompositeKey) keyValue).getKeys().size() == index.getDefinition().getParamCount() && ((OCompositeKey) secondKey).getKeys().size() == index.getDefinition().getParamCount()) { res = index.get(keyValue); } else {