@Override protected RepositoryFragments getRepositoryFragments(RepositoryMetadata metadata) { RepositoryFragments fragments = RepositoryFragments.empty(); boolean isQueryDslRepository = QUERY_DSL_PRESENT && ReactiveQuerydslPredicateExecutor.class.isAssignableFrom(metadata.getRepositoryInterface()); if (isQueryDslRepository) { MongoEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType(), metadata); fragments = fragments.append(RepositoryFragment.implemented(getTargetRepositoryViaReflection( ReactiveQuerydslMongoPredicateExecutor.class, entityInformation, operations))); } return fragments; }
private <T, ID> MongoEntityInformation<T, ID> getEntityInformation(Class<T> domainClass, @Nullable RepositoryMetadata metadata) { MongoPersistentEntity<?> entity = mappingContext.getRequiredPersistentEntity(domainClass); return MongoEntityInformationSupport.<T, ID> entityInformationFor(entity, metadata != null ? metadata.getIdType() : null); }
@Override protected RepositoryFragments getRepositoryFragments(RepositoryMetadata metadata) { RepositoryFragments fragments = RepositoryFragments.empty(); boolean isQueryDslRepository = QUERY_DSL_PRESENT && QuerydslPredicateExecutor.class.isAssignableFrom(metadata.getRepositoryInterface()); if (isQueryDslRepository) { if (metadata.isReactiveRepository()) { throw new InvalidDataAccessApiUsageException( "Cannot combine Querydsl and reactive repository support in a single interface"); } MongoEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType(), metadata); fragments = fragments.append(RepositoryFragment.implemented( getTargetRepositoryViaReflection(QuerydslMongoPredicateExecutor.class, entityInformation, operations))); } return fragments; }
/** * Creates a new {@link RepositoryAwareMethodLookup} for the given {@link RepositoryMetadata}. * * @param repositoryMetadata must not be {@literal null}. */ public RepositoryAwareMethodLookup(RepositoryMetadata repositoryMetadata) { Assert.notNull(repositoryMetadata, "Repository metadata must not be null!"); this.entityType = ResolvableType.forClass(repositoryMetadata.getDomainType()); this.idType = ResolvableType.forClass(repositoryMetadata.getIdType()); this.repositoryInterface = repositoryMetadata.getRepositoryInterface(); }
@Override public RepositoryQuery resolveQuery(final Method mtd, final RepositoryMetadata metadata, final ProjectionFactory factory, NamedQueries namedQueries) { final Query annotation = mtd.getAnnotation(Query.class); if (annotation != null) { String qryStr = annotation.value(); if (key != Key.CREATE && StringUtils.hasText(qryStr)) return new IgniteRepositoryQuery(metadata, new IgniteQuery(qryStr, isFieldQuery(qryStr), IgniteQueryGenerator.getOptions(mtd)), mtd, factory, ignite.getOrCreateCache(repoToCache.get(metadata.getRepositoryInterface()))); } if (key == QueryLookupStrategy.Key.USE_DECLARED_QUERY) throw new IllegalStateException("To use QueryLookupStrategy.Key.USE_DECLARED_QUERY, pass " + "a query string via org.apache.ignite.springdata.repository.config.Query annotation."); return new IgniteRepositoryQuery(metadata, IgniteQueryGenerator.generateSql(mtd, metadata), mtd, factory, ignite.getOrCreateCache(repoToCache.get(metadata.getRepositoryInterface()))); } };
/** * @param metadata Metadata. * @param qry Query. * @param mtd Method. * @param factory Factory. * @param cache Cache. */ public IgniteRepositoryQuery(RepositoryMetadata metadata, IgniteQuery qry, Method mtd, ProjectionFactory factory, IgniteCache cache) { type = metadata.getDomainType(); this.qry = qry; this.cache = cache; this.metadata = metadata; this.mtd = mtd; this.factory = factory; returnStgy = calcReturnType(mtd, qry.isFieldQuery()); }
@Override public final RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, ProjectionFactory factory, NamedQueries namedQueries) { return createDynamoDBQuery(method, metadata, factory, metadata.getDomainType(), metadata.getIdType(), namedQueries); }
/** * Returns the domain class the query method is targeted at. * * @return will never be {@literal null}. */ protected Class<?> getDomainClass() { Class<?> repositoryDomainClass = metadata.getDomainType(); Class<?> methodDomainClass = metadata.getReturnedDomainClass(method); return repositoryDomainClass == null || repositoryDomainClass.isAssignableFrom(methodDomainClass) ? methodDomainClass : repositoryDomainClass; }
@Override protected boolean useRepositoryConfiguration(RepositoryMetadata metadata) { return metadata.isReactiveRepository(); } }
@Override public Class<?> getReturnedDomainType() { return metadata.getReturnedDomainClass(method); } }
/** * Creates a new {@link RepositoryAwareMethodLookup} for the given {@link RepositoryMetadata}. * * @param repositoryMetadata must not be {@literal null}. */ public RepositoryAwareMethodLookup(RepositoryMetadata repositoryMetadata) { Assert.notNull(repositoryMetadata, "Repository metadata must not be null!"); this.entityType = ResolvableType.forClass(repositoryMetadata.getDomainType()); this.idType = ResolvableType.forClass(repositoryMetadata.getIdType()); this.repositoryInterface = repositoryMetadata.getRepositoryInterface(); }
/** {@inheritDoc} */ @Override protected Optional<QueryLookupStrategy> getQueryLookupStrategy(final QueryLookupStrategy.Key key, EvaluationContextProvider evaluationCtxProvider) { return Optional.of((mtd, metadata, factory, namedQueries) -> { final Query annotation = mtd.getAnnotation(Query.class); if (annotation != null) { String qryStr = annotation.value(); if (key != QueryLookupStrategy.Key.CREATE && StringUtils.hasText(qryStr)) { return new IgniteRepositoryQuery(metadata, new IgniteQuery(qryStr, isFieldQuery(qryStr), IgniteQueryGenerator.getOptions(mtd)), mtd, factory, ignite.getOrCreateCache(repoToCache.get(metadata.getRepositoryInterface()))); } } if (key == QueryLookupStrategy.Key.USE_DECLARED_QUERY) { throw new IllegalStateException("To use QueryLookupStrategy.Key.USE_DECLARED_QUERY, pass " + "a query string via org.apache.ignite.springdata.repository.config.Query annotation."); } return new IgniteRepositoryQuery(metadata, IgniteQueryGenerator.generateSql(mtd, metadata), mtd, factory, ignite.getOrCreateCache(repoToCache.get(metadata.getRepositoryInterface()))); }); }
/** * @param metadata Metadata. * @param qry Query. * @param mtd Method. * @param factory Factory. * @param cache Cache. */ public IgniteRepositoryQuery(RepositoryMetadata metadata, IgniteQuery qry, Method mtd, ProjectionFactory factory, IgniteCache cache) { type = metadata.getDomainType(); this.qry = qry; this.cache = cache; this.metadata = metadata; this.mtd = mtd; this.factory = factory; returnStgy = calcReturnType(mtd, qry.isFieldQuery()); }
@Override public final RepositoryQuery resolveQuery(Method method, RepositoryMetadata metadata, NamedQueries namedQueries) { return createDynamoDBQuery(method, metadata, metadata.getDomainType(), metadata.getIdType(), namedQueries); }
@Override protected boolean useRepositoryConfiguration(RepositoryMetadata metadata) { return metadata.isReactiveRepository(); } }
/** * Returns the type of the object that will be returned. * * @return */ public Class<?> getReturnedObjectType() { return metadata.getReturnedDomainClass(method); }
@Override protected RepositoryFragments getRepositoryFragments(RepositoryMetadata metadata) { RepositoryFragments fragments = RepositoryFragments.empty(); if (QueryByExampleExecutor.class.isAssignableFrom(metadata.getRepositoryInterface())) { RedisMappingContext mappingContext = (RedisMappingContext) this.operations.getMappingContext(); RedisPersistentEntity<?> persistentEntity = mappingContext.getRequiredPersistentEntity(metadata.getDomainType()); MappingRedisEntityInformation<?, ?> entityInformation = new MappingRedisEntityInformation<>(persistentEntity); fragments = fragments.append(RepositoryFragment.implemented(QueryByExampleExecutor.class, getTargetRepositoryViaReflection(QueryByExampleRedisExecutor.class, entityInformation, operations))); } return fragments; }
/** * Creates a new {@link RepositoryAwareMethodLookup} for the given {@link RepositoryMetadata}. * * @param repositoryMetadata must not be {@literal null}. */ public RepositoryAwareMethodLookup(RepositoryMetadata repositoryMetadata) { Assert.notNull(repositoryMetadata, "Repository metadata must not be null!"); this.entityType = ResolvableType.forClass(repositoryMetadata.getDomainType()); this.idType = ResolvableType.forClass(repositoryMetadata.getIdType()); this.repositoryInterface = repositoryMetadata.getRepositoryInterface(); }
@Override protected RepositoryComposition.RepositoryFragments getRepositoryFragments(RepositoryMetadata metadata) { RepositoryComposition.RepositoryFragments fragments = RepositoryComposition.RepositoryFragments.empty(); boolean isQueryDslRepository = QUERY_DSL_PRESENT && QuerydslPredicateExecutor.class.isAssignableFrom(metadata.getRepositoryInterface()); if (isQueryDslRepository) { if (metadata.isReactiveRepository()) { throw new InvalidDataAccessApiUsageException( "Cannot combine Querydsl and reactive repository support in a single interface"); } JpaEntityInformation<?, Serializable> entityInformation = getEntityInformation(metadata.getDomainType()); Object querydslFragment = getTargetRepositoryViaReflection(QuerydslJpaPredicateExecutor.class, entityInformation, entityManager, entityPathResolver, crudMethodMetadataPostProcessor.getCrudMethodMetadata()); fragments = fragments.append(RepositoryFragment.implemented(querydslFragment)); } return fragments; }
@Override public boolean isExported(RepositoryMetadata metadata) { return isExplicitlyExported(metadata.getRepositoryInterface(), false); } };