Java SearchException类代码示例

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
protected String convertQueryComponentToQueryFragment(QueryComponent queryComponent) {
    if (!queryComponent.isFieldedQuery()) {
        return queryComponent.getQuery();
    }

    String field = this.getEncodedFieldName(queryComponent.getField());
    if (field == null) {
        throw new SearchException("Unable to build query string - there is no field named '%s' on %s", queryComponent.getField(), type.getSimpleName());
    }
    String operation = IsSymbols.get(queryComponent.getIs());
    if (queryComponent.isCollectionQuery()) {
        List<String> values = convertValuesToString(field, queryComponent.getCollectionValue());
        String stringValue = StringUtils.join(values, " OR ");
        return String.format("%s:(%s)", field, stringValue);
    } else {
        String value = convertValueToString(field, queryComponent.getValue());
        return String.format("%s%s%s", field, operation, value);
    }
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
/**
 * Given a type, infer the {@link IndexType} that is used to store and query a field.
 *
 * @param type
 * @return
 */
protected IndexType inferIndexType(Type type) {
    // we go a direct get first
    IndexType indexType = indexTypeMappingCache.get(type);
    if (indexType == null) {
        if (TypeIntrospector.isACollection(type)) {
            type = TypeIntrospector.getCollectionType(type);
        }
        Class<?> classType = TypeIntrospector.asClass(type);
        // if not present, we find the first match in the cache
        for (Map.Entry<Class<?>, IndexType> entry : indexTypeMappingCache.entrySet()) {
            if (entry.getKey().isAssignableFrom(classType)) {
                indexType = entry.getValue();
                // put the matching type back into the cache to speed up subsequent inference
                indexTypeMappingCache.put(classType, indexType);
                break;
            }
        }
    }
    if (indexType == null) {
        throw new SearchException("Unable to infer an %s for the type %s - you should add a mapping using the %s", IndexTypeLookup.class.getSimpleName(), type,
                IndexTypeLookup.class.getSimpleName());
    }
    return indexType;
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
protected Document buildDocument(K id, Map<String, Object> fields) {
    String stringId = convert(id, String.class);
    Builder documentBuilder = Document.newBuilder();
    documentBuilder.setId(stringId);
    for (Map.Entry<String, Object> fieldData : fields.entrySet()) {
        Object value = fieldData.getValue();
        String fieldName = fieldData.getKey();
        for (Object object : getCollectionValues(value)) {
            try {
                Field field = buildField(metadata, fieldName, object);
                documentBuilder.addField(field);
            } catch (Exception e) {
                throw new SearchException(e, "Failed to add field '%s' with value '%s' to document with id '%s': %s", fieldName, value.toString(), id, e.getMessage());
            }
        }
    }

    return documentBuilder.build();
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
public SearchMetadata(Class<T> type, IndexTypeLookup indexTypeLookup) {
    this.indexTypeLookup = indexTypeLookup;
    this.type = type;
    findMethodAccessors(type);
    findFieldAccessors(type);
    if (idAccessor == null) {
        throw new SearchException("No id found for %s - make sure @%s is on one field or method", type.getSimpleName(), SearchId.class.getSimpleName());
    }
    this.keyType = idAccessor.getType();
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
public IndexType getIndexType(String field) {
    Accessor<T, ?> accessor = accessors.get(field);
    if (accessor == null) {
        throw new SearchException("There is no field or getter marked with @%s for %s.%s - make sure it is indexed and accessible", SearchIndex.class.getSimpleName(), type.getSimpleName(), field);
    }
    return accessor.getIndexType();
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
/**
 * Ensure the field name matches the requirements of the search interface
 *
 * @param fieldName
 * @return
 */
protected String encodeFieldName(String fieldName) {
    // From the docs - They must start with a letter and can contain letters, digits, or underscore
    String encoded = fieldName.replaceAll("[^\\w-]", "-");
    encoded = encoded.replaceAll("-+", "-");
    encoded = encoded.replaceAll("[^a-zA-Z]*([a-zA-Z]+)([\\w-]*)", "$1$2");
    if (!FieldNamePattern.matcher(encoded).matches()) {
        throw new SearchException(
                "The field name '%s' cannot be used - it could not be encoded into an acceptable representation for the text search api. Make sure it has at least one letter. The encoded result was '%s'",
                fieldName, encoded);
    }
    return encoded;
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public MethodAccessor(Class<T> type, Method method, String name, String encodedName, IndexType indexType) {
    try {
        this.type = type;
        this.method = method;
        this.method.setAccessible(true);
        this.methodType = (Class<V>) this.method.getReturnType();
        this.name = name;
        this.encodedName = encodedName;
        this.methodName = method.getName();
        this.indexType = indexType;
    } catch (SecurityException e) {
        throw new SearchException(e, "Unable to access method '%s.%s': %s", type.getSimpleName(), methodName, e.getMessage());
    }
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public V get(T t) {
    try {
        return (V) method.invoke(t);
    } catch (IllegalArgumentException | IllegalAccessException | InvocationTargetException e) {
        throw new SearchException(e, "Failed to call method '%s.%s': %s", type.getSimpleName(), methodName, e.getMessage());
    }
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public FieldAccessor(Class<T> type, Field field, String name, String encodedName, IndexType indexType) {
    try {
        this.type = type;
        this.field = field;
        this.field.setAccessible(true);
        this.fieldType = (Class<V>) this.field.getType();
        this.name = name;
        this.encodedName = encodedName;
        this.fieldName = field.getName();
        this.indexType = indexType;
    } catch (SecurityException e) {
        throw new SearchException(e, "Unable to access field '%s.%s': %s", type.getSimpleName(), fieldName, e.getMessage());
    }
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public V get(T t) {
    try {
        return (V) field.get(t);
    } catch (IllegalArgumentException | IllegalAccessException e) {
        throw new SearchException(e, "Failed to access field '%s.%s': %s", type.getSimpleName(), fieldName, e.getMessage());
    }
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
private Results<ScoredDocument> results() {
    if (results == null) {
        try {
            results = searchAsync.get();
        } catch (InterruptedException | ExecutionException e) {
            throw new SearchException(e, "Failed to retrieve search results: %s", e.getMessage());
        }
    }
    return results;
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
private <V> String convertSingleValueToString(String field, Object value, SearchMetadata<T, ?> metadata, FieldMediator<V> fieldMediator) {
    try {
        V normalised = fieldMediator.normalise(transformerManager, value);
        return fieldMediator.stringify(normalised);
    } catch (Exception e) {
        throw new SearchException("Cannot query the field %s %s - cannot convert the query value %s %s to a %s. You can register extra conversions using the %s", metadata.getFieldType(field)
                .getSimpleName(), field, value.getClass().getSimpleName(), value, fieldMediator.getTargetType().getSimpleName(), TransformerManager.class.getSimpleName());
    }
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public <T> FieldMediator<T> get(IndexType indexType) {
    FieldMediator<T> result = (FieldMediator<T>) fieldMediators.get(indexType);
    if (result == null) {
        throw new SearchException("No %s present for %s '%s'", FieldMediator.class.getSimpleName(), IndexType.class.getSimpleName(), indexType);
    }
    return result;
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@Override
public com.threewks.gaetools.search.Result<E, K> createSearchResult(SearchImpl<E, K> searchRequest) {
    Search<E, Key<E>> delegate = searchRequest.getSearchRequest();
    final com.threewks.gaetools.search.Result<E, Key<E>> delegateResults = delegate.run();
    return new com.threewks.gaetools.search.Result<E, K>() {
        @Override
        public List<E> getResults() throws SearchException {
            return loadInternal(delegateResults.getResultIds());
        }

        @Override
        public List<K> getResultIds() throws SearchException {
            return fromKeys.from(delegateResults.getResultIds());
        }

        @Override
        public long getMatchingRecordCount() {
            return delegateResults.getMatchingRecordCount();
        }

        @Override
        public long getReturnedRecordCount() {
            return delegateResults.getReturnedRecordCount();
        }

        @Override
        public String cursor() {
            return delegateResults.cursor();
        }

    };
}
 

import com.threewks.gaetools.search.SearchException; //导入依赖的package包/类
@Test
public void shouldThrowSearchExceptionWhenCannotGetFieldValue() throws NoSuchFieldException {
    thrown.expect(SearchException.class);
    thrown.expectMessage("Failed to access field 'FieldAccessorTest.field': ");

    Field field = FieldPojo.class.getDeclaredField("field");

    FieldAccessor<FieldAccessorTest, String> fieldAccessor = new FieldAccessor<>(FieldAccessorTest.class, field, "encoded-name", "notAField", IndexType.Text);
    fieldAccessor.get(this);
}