Java Code Examples for org.springframework.data.repository.query.QueryMethodEvaluationContextProvider

The following examples show how to use org.springframework.data.repository.query.QueryMethodEvaluationContextProvider. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
Source Project: sdn-rx   Source File: RepositoryQueryTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
void shouldSelectStringBasedNeo4jQueryForNamedQuery() {

	final String namedQueryName = "TestEntity.findAllByANamedQuery";
	when(namedQueries.hasQuery(namedQueryName)).thenReturn(true);
	when(namedQueries.getQuery(namedQueryName)).thenReturn("MATCH (n) RETURN n");

	final Neo4jQueryLookupStrategy lookupStrategy = new Neo4jQueryLookupStrategy(mock(Neo4jOperations.class),
		mock(
		Neo4jMappingContext.class), QueryMethodEvaluationContextProvider.DEFAULT);

	RepositoryQuery query = lookupStrategy
		.resolveQuery(queryMethod("findAllByANamedQuery"), TEST_REPOSITORY_METADATA,
			PROJECTION_FACTORY, namedQueries);
	assertThat(query).isInstanceOf(StringBasedNeo4jQuery.class);
}
 
Example 2
Source Project: sdn-rx   Source File: RepositoryQueryTest.java    License: Apache License 2.0 6 votes vote down vote up
@Test
void shouldBindParameters() {

	Neo4jQueryMethod method = RepositoryQueryTest
		.neo4jQueryMethod("annotatedQueryWithValidTemplate", String.class, String.class);

	StringBasedNeo4jQuery repositoryQuery = spy(StringBasedNeo4jQuery.create(mock(Neo4jOperations.class),
		mock(Neo4jMappingContext.class), QueryMethodEvaluationContextProvider.DEFAULT,
		method));

	// skip conversion
	doAnswer(invocation -> invocation.getArgument(0)).when(repositoryQuery).convertParameter(any());

	Map<String, Object> resolveParameters = repositoryQuery
		.bindParameters(new Neo4jParameterAccessor(
			(Neo4jParameters) method.getParameters(), new Object[] { "A String", "Another String" }));

	assertThat(resolveParameters)
		.containsEntry("0", "A String")
		.containsEntry("1", "Another String");
}
 
Example 3
Source Project: spring-data   Source File: ArangoRepositoryFactory.java    License: Apache License 2.0 6 votes vote down vote up
@Override
protected Optional<QueryLookupStrategy> getQueryLookupStrategy(
		final QueryLookupStrategy.Key key, final QueryMethodEvaluationContextProvider evaluationContextProvider) {

	QueryLookupStrategy strategy = null;
	switch (key) {
	case CREATE_IF_NOT_FOUND:
		strategy = new DefaultArangoQueryLookupStrategy(arangoOperations);
		break;
	case CREATE:
		break;
	case USE_DECLARED_QUERY:
		break;
	}
	return Optional.ofNullable(strategy);
}
 
Example 4
private QueryMethodEvaluationContextProvider delegateContextProvider(
		QueryMethodEvaluationContextProvider evaluationContextProvider) {
	return new QueryMethodEvaluationContextProvider() {
		@Override
		public <T extends Parameters<?, ?>> EvaluationContext getEvaluationContext(
				T parameters, Object[] parameterValues) {
			StandardEvaluationContext evaluationContext = (StandardEvaluationContext)
					evaluationContextProvider
					.getEvaluationContext(parameters, parameterValues);
			evaluationContext.setRootObject(
					DatastoreRepositoryFactory.this.applicationContext);
			evaluationContext.addPropertyAccessor(new BeanFactoryAccessor());
			evaluationContext.setBeanResolver(new BeanFactoryResolver(
					DatastoreRepositoryFactory.this.applicationContext));
			return evaluationContext;
		}
	};
}
 
Example 5
Source Project: spring-cloud-gcp   Source File: SpannerRepositoryFactory.java    License: Apache License 2.0 6 votes vote down vote up
private QueryMethodEvaluationContextProvider delegateContextProvider(
		QueryMethodEvaluationContextProvider evaluationContextProvider) {
	return new QueryMethodEvaluationContextProvider() {
		@Override
		public <T extends Parameters<?, ?>> EvaluationContext getEvaluationContext(
				T parameters, Object[] parameterValues) {
			StandardEvaluationContext evaluationContext = (StandardEvaluationContext) evaluationContextProvider
					.getEvaluationContext(parameters, parameterValues);
			evaluationContext
					.setRootObject(SpannerRepositoryFactory.this.applicationContext);
			evaluationContext.addPropertyAccessor(new BeanFactoryAccessor());
			evaluationContext.setBeanResolver(new BeanFactoryResolver(
					SpannerRepositoryFactory.this.applicationContext));
			return evaluationContext;
		}
	};
}
 
Example 6
@Before
public void initMocks() {
	this.spannerMappingContext = new SpannerMappingContext();
	this.spannerTemplate = mock(SpannerTemplate.class);
	this.queryMethod = mock(SpannerQueryMethod.class);
	this.evaluationContextProvider = mock(QueryMethodEvaluationContextProvider.class);
	this.spelExpressionParser = new SpelExpressionParser();
	this.spannerQueryLookupStrategy = getSpannerQueryLookupStrategy();

	when(this.queryMethod.getQueryAnnotation()).thenReturn(new Query() {
		@Override
		public Class<? extends Annotation> annotationType() {
			return Query.class;
		}

		@Override
		public String value() {
			return "";
		}

		@Override
		public boolean dmlStatement() {
			return false;
		}
	});
}
 
Example 7
/**
 * Creates a {@link QueryLookupStrategy} for the given {@link EbeanServer} and {@link Key}.
 *
 * @param ebeanServer               must not be {@literal null}.
 * @param key                       may be {@literal null}.
 * @param evaluationContextProvider must not be {@literal null}.
 * @return
 */
public static QueryLookupStrategy create(EbeanServer ebeanServer, Key key,
                                         QueryMethodEvaluationContextProvider evaluationContextProvider) {

    Assert.notNull(ebeanServer, "EbeanServer must not be null!");
    Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");

    switch (key != null ? key : Key.CREATE_IF_NOT_FOUND) {
        case CREATE:
            return new CreateQueryLookupStrategy(ebeanServer);
        case USE_DECLARED_QUERY:
            return new DeclaredQueryLookupStrategy(ebeanServer, evaluationContextProvider);
        case CREATE_IF_NOT_FOUND:
            return new CreateIfNotFoundQueryLookupStrategy(ebeanServer, new CreateQueryLookupStrategy(ebeanServer),
                    new DeclaredQueryLookupStrategy(ebeanServer, evaluationContextProvider));
        default:
            throw new IllegalArgumentException(String.format("Unsupported query lookup strategy %s!", key));
    }
}
 
Example 8
Source Project: spring-data-ebean   Source File: NativeEbeanUpdate.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Creates a new {@link NativeEbeanUpdate} encapsulating the query annotated on the given {@link EbeanQueryMethod}.
 *
 * @param method                    must not be {@literal null}.
 * @param ebeanServer               must not be {@literal null}.
 * @param queryString               must not be {@literal null} or empty.
 * @param evaluationContextProvider
 */
public NativeEbeanUpdate(EbeanQueryMethod method, EbeanServer ebeanServer, String queryString,
                         QueryMethodEvaluationContextProvider evaluationContextProvider, SpelExpressionParser parser) {

    super(method, ebeanServer, queryString, evaluationContextProvider, parser);

    Parameters<?, ?> parameters = method.getParameters();
    boolean hasPagingOrSortingParameter = parameters.hasPageableParameter() || parameters.hasSortParameter();
    boolean containsPageableOrSortInQueryExpression = queryString.contains("#pageable")
            || queryString.contains("#sort");

    if (hasPagingOrSortingParameter && !containsPageableOrSortInQueryExpression) {
        throw new InvalidEbeanQueryMethodException(
                "Cannot use native queries with dynamic sorting and/or pagination in method " + method);
    }
}
 
Example 9
public static QueryLookupStrategy create(SqlSessionTemplate sqlSessionTemplate,
		Key key, QueryMethodEvaluationContextProvider evaluationContextProvider) {

	Assert.notNull(sqlSessionTemplate, "SqlSessionTemplate must not be null!");
	Assert.notNull(evaluationContextProvider,
			"EvaluationContextProvider must not be null!");

	switch (key != null ? key : Key.CREATE_IF_NOT_FOUND) {
	case CREATE:
		return new CreateQueryLookupStrategy(sqlSessionTemplate);
	case USE_DECLARED_QUERY:
		return new DeclaredQueryLookupStrategy(sqlSessionTemplate,
				evaluationContextProvider);
	case CREATE_IF_NOT_FOUND:
		return new CreateIfNotFoundQueryLookupStrategy(sqlSessionTemplate,
				new CreateQueryLookupStrategy(sqlSessionTemplate),
				new DeclaredQueryLookupStrategy(sqlSessionTemplate,
						evaluationContextProvider));
	default:
		throw new IllegalArgumentException(
				String.format("Unsupported query lookup strategy %s!", key));
	}
}
 
Example 10
/**
 * <p>
 * Required constructor, capturing arguments for use in {@link #resolveQuery}.
 * </P>
 * <p>
 * Assertions copied from {@link KayValueRepositoryFactory.KeyValueQUeryLookupStrategy} which this class essentially
 * duplicates.
 * </P>
 *
 * @param key                       Not used
 * @param evaluationContextProvider For evaluation of query expressions
 * @param keyValueOperations        Bean to use for Key/Value operations on Hazelcast repos
 * @param queryCreator              Likely to be {@link HazelcastQueryCreator}
 * @param hazelcastInstance         Instance of Hazelcast
 */
public HazelcastQueryLookupStrategy(QueryLookupStrategy.Key key,
                                    QueryMethodEvaluationContextProvider evaluationContextProvider,
                                    KeyValueOperations keyValueOperations,
                                    Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
                                    HazelcastInstance hazelcastInstance) {

    Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
    Assert.notNull(keyValueOperations, "KeyValueOperations must not be null!");
    Assert.notNull(queryCreator, "Query creator type must not be null!");
    Assert.notNull(hazelcastInstance, "HazelcastInstance must not be null!");

    this.evaluationContextProvider = evaluationContextProvider;
    this.keyValueOperations = keyValueOperations;
    this.queryCreator = queryCreator;
    this.hazelcastInstance = hazelcastInstance;
}
 
Example 11
/**
 * @param key
 * @param evaluationContextProvider
 * @param keyValueOperations
 * @param queryCreator
 * @since 1.1
 */
public KeyValueQueryLookupStrategy(@Nullable Key key,
		QueryMethodEvaluationContextProvider evaluationContextProvider, KeyValueOperations keyValueOperations,
		Class<? extends AbstractQueryCreator<?, ?>> queryCreator,
		Class<? extends RepositoryQuery> repositoryQueryType) {

	Assert.notNull(evaluationContextProvider, "EvaluationContextProvider must not be null!");
	Assert.notNull(keyValueOperations, "KeyValueOperations must not be null!");
	Assert.notNull(queryCreator, "Query creator type must not be null!");
	Assert.notNull(repositoryQueryType, "RepositoryQueryType type must not be null!");

	this.evaluationContextProvider = evaluationContextProvider;
	this.keyValueOperations = keyValueOperations;
	this.queryCreator = queryCreator;
	this.repositoryQueryType = repositoryQueryType;
}
 
Example 12
@Override
@SuppressWarnings("unchecked")
public RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory,
		NamedQueries namedQueries) {

	QueryMethod queryMethod = new QueryMethod(method, metadata, factory);

	Constructor<? extends KeyValuePartTreeQuery> constructor = (Constructor<? extends KeyValuePartTreeQuery>) ClassUtils
			.getConstructorIfAvailable(this.repositoryQueryType, QueryMethod.class,
					QueryMethodEvaluationContextProvider.class, KeyValueOperations.class, Class.class);

	Assert.state(constructor != null,
			String.format(
					"Constructor %s(QueryMethod, EvaluationContextProvider, KeyValueOperations, Class) not available!",
					ClassUtils.getShortName(this.repositoryQueryType)));

	return BeanUtils.instantiateClass(constructor, queryMethod, evaluationContextProvider, this.keyValueOperations,
			this.queryCreator);
}
 
Example 13
@Test // DATAKV-137
public void cachedSpelExpressionShouldBeReusedWithNewContext() throws NoSuchMethodException, SecurityException {

	QueryMethod qm = new QueryMethod(Repo.class.getMethod("findByFirstname", String.class), metadataMock,
			projectionFactoryMock);

	KeyValuePartTreeQuery query = new CachingKeyValuePartTreeQuery(qm, QueryMethodEvaluationContextProvider.DEFAULT,
			kvOpsMock, SpelQueryCreator.class);

	Object[] args = new Object[] { "foo" };

	SpelCriteria first = (SpelCriteria) query.prepareQuery(args).getCriteria();
	SpelCriteria second = (SpelCriteria) query.prepareQuery(args).getCriteria();

	assertThat(first.getExpression()).isSameAs(second.getExpression());
	assertThat(first.getContext()).isNotSameAs(second.getContext());
}
 
Example 14
@Test // DATAKV-115
@SuppressWarnings({ "unchecked", "rawtypes" })
public void spelExpressionAndContextShouldNotBeReused() throws NoSuchMethodException, SecurityException {

	when(metadataMock.getDomainType()).thenReturn((Class) Person.class);
	when(metadataMock.getReturnedDomainClass(any(Method.class))).thenReturn((Class) Person.class);

	QueryMethod qm = new QueryMethod(Repo.class.getMethod("findByFirstname", String.class), metadataMock,
			projectionFactoryMock);

	KeyValuePartTreeQuery query = new KeyValuePartTreeQuery(qm, QueryMethodEvaluationContextProvider.DEFAULT, kvOpsMock,
			SpelQueryCreator.class);

	Object[] args = new Object[] { "foo" };

	Object first = query.prepareQuery(args).getCriteria();
	Object second = query.prepareQuery(args).getCriteria();

	assertThat(first).isNotSameAs(second);
}
 
Example 15
@Test // DATAKV-142
@SuppressWarnings({ "unchecked", "rawtypes" })
public void shouldApplyPageableParameterToCollectionQuery() throws SecurityException, NoSuchMethodException {

	when(metadataMock.getDomainType()).thenReturn((Class) Person.class);
	when(metadataMock.getReturnedDomainClass(any(Method.class))).thenReturn((Class) Person.class);

	QueryMethod qm = new QueryMethod(Repo.class.getMethod("findBy", Pageable.class), metadataMock,
			projectionFactoryMock);

	KeyValuePartTreeQuery partTreeQuery = new KeyValuePartTreeQuery(qm, QueryMethodEvaluationContextProvider.DEFAULT,
			kvOpsMock, SpelQueryCreator.class);

	KeyValueQuery<?> query = partTreeQuery.prepareQuery(new Object[] { PageRequest.of(2, 3) });

	assertThat(query.getOffset()).isEqualTo(6L);
	assertThat(query.getRows()).isEqualTo(3);
}
 
Example 16
@Test // DATAKV-142
@SuppressWarnings({ "unchecked", "rawtypes" })
public void shouldApplyDerivedMaxResultsToQueryWithParameters() throws SecurityException, NoSuchMethodException {

	when(metadataMock.getDomainType()).thenReturn((Class) Person.class);
	when(metadataMock.getReturnedDomainClass(any(Method.class))).thenReturn((Class) Person.class);

	QueryMethod qm = new QueryMethod(Repo.class.getMethod("findTop3ByFirstname", String.class), metadataMock,
			projectionFactoryMock);

	KeyValuePartTreeQuery partTreeQuery = new KeyValuePartTreeQuery(qm, QueryMethodEvaluationContextProvider.DEFAULT,
			kvOpsMock, SpelQueryCreator.class);

	KeyValueQuery<?> query = partTreeQuery.prepareQuery(new Object[] { "firstname" });

	assertThat(query.getCriteria()).isInstanceOf(SpelCriteria.class);
	assertThat(((SpelCriteria) query.getCriteria()).getExpression().getExpressionString())
			.isEqualTo("#it?.firstname?.equals([0])");
	assertThat(query.getRows()).isEqualTo(3);
}
 
Example 17
Source Project: sdn-rx   Source File: ReactiveStringBasedNeo4jQuery.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Create a {@link ReactiveStringBasedNeo4jQuery} for a query method that is annotated with {@link Query @Query}. The annotation
 * is expected to have a value.
 *
 * @param neo4jOperations reactive Neo4j operations
 * @param mappingContext a Neo4jMappingContext instance
 * @param evaluationContextProvider a QueryMethodEvaluationContextProvider instance
 * @param queryMethod the query method
 * @return A new instance of a String based Neo4j query.
 */
static ReactiveStringBasedNeo4jQuery create(ReactiveNeo4jOperations neo4jOperations, Neo4jMappingContext mappingContext,
	QueryMethodEvaluationContextProvider evaluationContextProvider,
	Neo4jQueryMethod queryMethod) {

	Query queryAnnotation = queryMethod.getQueryAnnotation()
		.orElseThrow(() -> new MappingException("Expected @Query annotation on the query method!"));

	String cypherTemplate = Optional.ofNullable(queryAnnotation.value())
		.filter(StringUtils::hasText)
		.orElseThrow(() -> new MappingException("Expected @Query annotation to have a value, but it did not."));

	return new ReactiveStringBasedNeo4jQuery(neo4jOperations, mappingContext, evaluationContextProvider, queryMethod,
		cypherTemplate, Neo4jQueryType.fromDefinition(queryAnnotation));
}
 
Example 18
Source Project: sdn-rx   Source File: ReactiveStringBasedNeo4jQuery.java    License: Apache License 2.0 5 votes vote down vote up
private ReactiveStringBasedNeo4jQuery(ReactiveNeo4jOperations neo4jOperations,
	Neo4jMappingContext mappingContext, QueryMethodEvaluationContextProvider evaluationContextProvider,
	Neo4jQueryMethod queryMethod, String cypherTemplate, Neo4jQueryType queryType) {

	super(neo4jOperations, mappingContext, queryMethod, queryType);

	SpelExtractor spelExtractor = SPEL_QUERY_CONTEXT.parse(cypherTemplate);
	this.spelEvaluator = new SpelEvaluator(evaluationContextProvider, queryMethod.getParameters(), spelExtractor);
	this.cypherQuery = spelExtractor.getQueryString();
}
 
Example 19
Source Project: sdn-rx   Source File: StringBasedNeo4jQuery.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Create a {@link StringBasedNeo4jQuery} for a query method that is annotated with {@link Query @Query}. The annotation
 * is expected to have a value.
 *
 * @param neo4jOperations the Neo4j operations
 * @param mappingContext a Neo4jMappingContext instance
 * @param evaluationContextProvider a QueryMethodEvaluationContextProvider instance
 * @param queryMethod the query method
 * @return A new instance of a String based Neo4j query.
 */
static StringBasedNeo4jQuery create(Neo4jOperations neo4jOperations, Neo4jMappingContext mappingContext,
	QueryMethodEvaluationContextProvider evaluationContextProvider,
	Neo4jQueryMethod queryMethod) {

	Query queryAnnotation = queryMethod.getQueryAnnotation()
		.orElseThrow(() -> new MappingException("Expected @Query annotation on the query method!"));

	String cypherTemplate = Optional.ofNullable(queryAnnotation.value())
		.filter(StringUtils::hasText)
		.orElseThrow(() -> new MappingException("Expected @Query annotation to have a value, but it did not."));

	return new StringBasedNeo4jQuery(neo4jOperations, mappingContext, evaluationContextProvider, queryMethod,
		cypherTemplate, Neo4jQueryType.fromDefinition(queryAnnotation));
}
 
Example 20
Source Project: sdn-rx   Source File: StringBasedNeo4jQuery.java    License: Apache License 2.0 5 votes vote down vote up
private StringBasedNeo4jQuery(Neo4jOperations neo4jOperations,
	Neo4jMappingContext mappingContext, QueryMethodEvaluationContextProvider evaluationContextProvider,
	Neo4jQueryMethod queryMethod, String cypherTemplate, Neo4jQueryType queryType) {

	super(neo4jOperations, mappingContext, queryMethod, queryType);

	SpelExtractor spelExtractor = SPEL_QUERY_CONTEXT.parse(cypherTemplate);
	this.spelEvaluator = new SpelEvaluator(evaluationContextProvider, queryMethod.getParameters(), spelExtractor);
	this.cypherQuery = spelExtractor.getQueryString();
}
 
Example 21
Source Project: sdn-rx   Source File: Neo4jQueryLookupStrategy.java    License: Apache License 2.0 5 votes vote down vote up
public Neo4jQueryLookupStrategy(Neo4jOperations neo4jOperations,
	Neo4jMappingContext mappingContext,
	QueryMethodEvaluationContextProvider evaluationContextProvider) {
	this.neo4jOperations = neo4jOperations;
	this.mappingContext = mappingContext;
	this.evaluationContextProvider = evaluationContextProvider;
}
 
Example 22
Source Project: sdn-rx   Source File: ReactiveNeo4jQueryLookupStrategy.java    License: Apache License 2.0 5 votes vote down vote up
public ReactiveNeo4jQueryLookupStrategy(ReactiveNeo4jOperations neo4jOperations,
	Neo4jMappingContext mappingContext,
	QueryMethodEvaluationContextProvider evaluationContextProvider) {
	this.neo4jOperations = neo4jOperations;
	this.mappingContext = mappingContext;
	this.evaluationContextProvider = evaluationContextProvider;
}
 
Example 23
Source Project: sdn-rx   Source File: ReactiveNeo4jRepositoryFactory.java    License: Apache License 2.0 5 votes vote down vote up
@Override
protected Optional<QueryLookupStrategy> getQueryLookupStrategy(Key key,
	QueryMethodEvaluationContextProvider evaluationContextProvider) {

	return Optional
		.of(new ReactiveNeo4jQueryLookupStrategy(neo4jOperations, mappingContext, evaluationContextProvider));
}
 
Example 24
Source Project: sdn-rx   Source File: RepositoryQueryTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
void shouldSelectPartTreeNeo4jQuery() {

	final Neo4jQueryLookupStrategy lookupStrategy = new Neo4jQueryLookupStrategy(mock(Neo4jOperations.class),
		mock(
		Neo4jMappingContext.class), QueryMethodEvaluationContextProvider.DEFAULT);

	RepositoryQuery query = lookupStrategy
		.resolveQuery(queryMethod("findById", Object.class), TEST_REPOSITORY_METADATA, PROJECTION_FACTORY,
			namedQueries);
	assertThat(query).isInstanceOf(PartTreeNeo4jQuery.class);
}
 
Example 25
Source Project: sdn-rx   Source File: RepositoryQueryTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
void shouldSelectStringBasedNeo4jQuery() {

	final Neo4jQueryLookupStrategy lookupStrategy = new Neo4jQueryLookupStrategy(mock(Neo4jOperations.class),
		mock(
		Neo4jMappingContext.class), QueryMethodEvaluationContextProvider.DEFAULT);

	RepositoryQuery query = lookupStrategy
		.resolveQuery(queryMethod("annotatedQueryWithValidTemplate"), TEST_REPOSITORY_METADATA,
			PROJECTION_FACTORY, namedQueries);
	assertThat(query).isInstanceOf(StringBasedNeo4jQuery.class);
}
 
Example 26
Source Project: sdn-rx   Source File: RepositoryQueryTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
void shouldDetectInvalidAnnotation() {

	Neo4jQueryMethod method = neo4jQueryMethod("annotatedQueryWithoutTemplate");
	assertThatExceptionOfType(MappingException.class)
		.isThrownBy(
			() -> StringBasedNeo4jQuery.create(mock(Neo4jOperations.class), mock(Neo4jMappingContext.class),
				QueryMethodEvaluationContextProvider.DEFAULT, method))
		.withMessage("Expected @Query annotation to have a value, but it did not.");
}
 
Example 27
Source Project: sdn-rx   Source File: RepositoryQueryTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
void shouldResolveNamedParameters() {

	Neo4jQueryMethod method = RepositoryQueryTest
		.neo4jQueryMethod("findByDontDoThisInRealLiveNamed", org.neo4j.driver.types.Point.class, String.class,
			String.class);

	StringBasedNeo4jQuery repositoryQuery = spy(StringBasedNeo4jQuery.create(mock(Neo4jOperations.class),
		mock(Neo4jMappingContext.class), QueryMethodEvaluationContextProvider.DEFAULT,
		method));

	// skip conversion
	doAnswer(invocation -> invocation.getArgument(0)).when(repositoryQuery).convertParameter(any());

	Point thePoint = Values.point(4223, 1, 2).asPoint();
	Map<String, Object> resolveParameters = repositoryQuery.bindParameters(
		new Neo4jParameterAccessor((Neo4jParameters) method.getParameters(),
			new Object[] { thePoint, "TheName", "TheFirstName" }));

	assertThat(resolveParameters)
		.hasSize(8)
		.containsEntry("0", thePoint)
		.containsEntry("location", thePoint)
		.containsEntry("1", "TheName")
		.containsEntry("name", "TheName")
		.containsEntry("2", "TheFirstName")
		.containsEntry("firstName", "TheFirstName")
		.containsEntry("__SpEL__0", "TheFirstName")
		.containsEntry("__SpEL__1", "TheNameTheFirstName");
}
 
Example 28
@Override
protected Optional<QueryLookupStrategy> getQueryLookupStrategy(
    QueryLookupStrategy.Key key,
    QueryMethodEvaluationContextProvider evaluationContextProvider) {
    return Optional.of(new ReactiveCosmosQueryLookupStrategy(cosmosOperations,
        evaluationContextProvider));
}
 
Example 29
public DatastoreQueryLookupStrategy(DatastoreMappingContext datastoreMappingContext,
		DatastoreOperations datastoreOperations,
		QueryMethodEvaluationContextProvider evaluationContextProvider) {
	Assert.notNull(datastoreMappingContext,
			"A non-null DatastoreMappingContext is required.");
	Assert.notNull(datastoreOperations,
			"A non-null DatastoreOperations is required.");
	Assert.notNull(evaluationContextProvider,
			"A non-null EvaluationContextProvider is required.");
	this.datastoreMappingContext = datastoreMappingContext;
	this.evaluationContextProvider = evaluationContextProvider;
	this.datastoreOperations = datastoreOperations;
}
 
Example 30
Source Project: spring-cloud-gcp   Source File: GqlDatastoreQuery.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Constructor.
 * @param type the underlying entity type
 * @param queryMethod the underlying query method to support.
 * @param datastoreTemplate used for executing queries.
 * @param gql the query text.
 * @param evaluationContextProvider the provider used to evaluate SpEL expressions in
 *     queries.
 * @param datastoreMappingContext used for getting metadata about entities.
 */
public GqlDatastoreQuery(Class<T> type, DatastoreQueryMethod queryMethod,
						DatastoreOperations datastoreTemplate, String gql,
						QueryMethodEvaluationContextProvider evaluationContextProvider,
						DatastoreMappingContext datastoreMappingContext) {
	super(queryMethod, datastoreTemplate, datastoreMappingContext, type);
	this.evaluationContextProvider = evaluationContextProvider;
	this.originalGql = StringUtils.trimTrailingCharacter(gql.trim(), ';');
	setOriginalParamTags();
	setEvaluatingSpelQueryContext();
	setGqlResolvedEntityClassName();
}