Examples with Predicate com.google.gerrit.index.query.Predicate used on opensource projects

Example 6 with Predicate

use of com.google.gerrit.index.query.Predicate in project gerrit by GerritCodeReview.

the class ChangeIndexRewriter method rewriteImpl.

/**
 * Rewrite a single predicate subtree.
 *
 * @param in predicate to rewrite.
 * @param index index whose schema determines which fields are indexed.
 * @param opts other query options.
 * @param leafTerms number of leaf index query terms encountered so far.
 * @return {@code null} if no part of this subtree can be queried in the index directly. {@code
 *     in} if this subtree and all its children can be queried directly in the index. Otherwise, a
 *     predicate that is semantically equivalent, with some of its subtrees wrapped to query the
 *     index directly.
 * @throws QueryParseException if the underlying index implementation does not support this
 *     predicate.
 */
private Predicate<ChangeData> rewriteImpl(Predicate<ChangeData> in, ChangeIndex index, QueryOptions opts, MutableInteger leafTerms) throws QueryParseException {
    in = IsSubmittablePredicate.rewrite(in);
    if (isIndexPredicate(in, index)) {
        if (++leafTerms.value > config.maxTerms()) {
            throw new TooManyTermsInQueryException();
        }
        return in;
    } else if (in instanceof LimitPredicate) {
        // and included that in their limit computation.
        return new LimitPredicate<>(ChangeQueryBuilder.FIELD_LIMIT, opts.limit());
    } else if (!isRewritePossible(in)) {
        if (in instanceof IndexPredicate) {
            throw new QueryParseException("Unsupported index predicate: " + in.toString());
        }
        // magic to indicate "in" cannot be rewritten
        return null;
    }
    int n = in.getChildCount();
    BitSet isIndexed = new BitSet(n);
    BitSet notIndexed = new BitSet(n);
    BitSet rewritten = new BitSet(n);
    BitSet changeSource = new BitSet(n);
    List<Predicate<ChangeData>> newChildren = Lists.newArrayListWithCapacity(n);
    for (int i = 0; i < n; i++) {
        Predicate<ChangeData> c = in.getChild(i);
        Predicate<ChangeData> nc = rewriteImpl(c, index, opts, leafTerms);
        if (isSameInstance(nc, c)) {
            isIndexed.set(i);
            newChildren.add(c);
        } else if (nc == null) /* cannot rewrite c */
        {
            notIndexed.set(i);
            newChildren.add(c);
        } else {
            if (nc instanceof ChangeDataSource) {
                changeSource.set(i);
            }
            rewritten.set(i);
            newChildren.add(nc);
        }
    }
    if (isIndexed.cardinality() == n) {
        // All children are indexed, leave as-is for parent.
        return in;
    } else if (notIndexed.cardinality() == n) {
        // Can't rewrite any children, so cannot rewrite in.
        return null;
    } else if (rewritten.cardinality() == n) {
        // All children were rewritten.
        if (changeSource.cardinality() == n) {
            return copy(in, newChildren);
        }
        return in.copy(newChildren);
    }
    return partitionChildren(in, newChildren, isIndexed, index, opts);
}

Example 7 with Predicate

use of com.google.gerrit.index.query.Predicate in project gerrit by GerritCodeReview.

the class ProjectsConsistencyChecker method executeQueryAndAutoCloseChanges.

private ImmutableList<ChangeInfo> executeQueryAndAutoCloseChanges(Predicate<ChangeData> basePredicate, Set<Change.Id> seenChanges, List<Predicate<ChangeData>> predicates, boolean fix, Map<Change.Key, ObjectId> changeIdToMergedSha1, List<ObjectId> mergedSha1s) {
    if (predicates.isEmpty()) {
        return ImmutableList.of();
    }
    try {
        List<ChangeData> queryResult = retryHelper.changeIndexQuery("projectsConsistencyCheckerQueryChanges", q -> q.setRequestedFields(ChangeField.CHANGE, ChangeField.PATCH_SET).query(and(basePredicate, or(predicates)))).call();
        // Result for this query that we want to return to the client.
        ImmutableList.Builder<ChangeInfo> autoCloseableChangesByBranch = ImmutableList.builder();
        for (ChangeData autoCloseableChange : queryResult) {
            // earlier queries.
            if (seenChanges.add(autoCloseableChange.getId())) {
                retryHelper.changeUpdate("projectsConsistencyCheckerAutoCloseChanges", () -> {
                    // Auto-close by change
                    if (changeIdToMergedSha1.containsKey(autoCloseableChange.change().getKey())) {
                        autoCloseableChangesByBranch.add(changeJson(fix, changeIdToMergedSha1.get(autoCloseableChange.change().getKey())).format(autoCloseableChange));
                        return null;
                    }
                    // Auto-close by commit
                    for (ObjectId patchSetSha1 : autoCloseableChange.patchSets().stream().map(PatchSet::commitId).collect(toSet())) {
                        if (mergedSha1s.contains(patchSetSha1)) {
                            autoCloseableChangesByBranch.add(changeJson(fix, patchSetSha1).format(autoCloseableChange));
                            break;
                        }
                    }
                    return null;
                }).call();
            }
        }
        return autoCloseableChangesByBranch.build();
    } catch (Exception e) {
        Throwables.throwIfUnchecked(e);
        throw new StorageException(e);
    }
}

Example 8 with Predicate

use of com.google.gerrit.index.query.Predicate in project gerrit by GerritCodeReview.

the class ProjectsConsistencyChecker method checkForAutoCloseableChanges.

private AutoCloseableChangesCheckResult checkForAutoCloseableChanges(Project.NameKey projectName, AutoCloseableChangesCheckInput input) throws IOException, RestApiException {
    AutoCloseableChangesCheckResult r = new AutoCloseableChangesCheckResult();
    if (Strings.isNullOrEmpty(input.branch)) {
        throw new BadRequestException("branch is required");
    }
    boolean fix = input.fix != null ? input.fix : false;
    if (input.maxCommits != null && input.maxCommits > AUTO_CLOSE_MAX_COMMITS_LIMIT) {
        throw new BadRequestException("max commits can at most be set to " + AUTO_CLOSE_MAX_COMMITS_LIMIT);
    }
    int maxCommits = input.maxCommits != null ? input.maxCommits : AUTO_CLOSE_MAX_COMMITS_LIMIT;
    // Result that we want to return to the client.
    List<ChangeInfo> autoCloseableChanges = new ArrayList<>();
    // Remember the change IDs of all changes that we already included into the result, so that we
    // can avoid including the same change twice.
    Set<Change.Id> seenChanges = new HashSet<>();
    try (Repository repo = repoManager.openRepository(projectName);
        RevWalk rw = new RevWalk(repo)) {
        String branch = RefNames.fullName(input.branch);
        Ref ref = repo.exactRef(branch);
        if (ref == null) {
            throw new UnprocessableEntityException(String.format("branch '%s' not found", input.branch));
        }
        rw.reset();
        rw.markStart(rw.parseCommit(ref.getObjectId()));
        rw.sort(RevSort.TOPO);
        rw.sort(RevSort.REVERSE);
        // Cache the SHA1's of all merged commits. We need this for knowing which commit merged the
        // change when auto-closing changes by commit.
        List<ObjectId> mergedSha1s = new ArrayList<>();
        // Cache the Change-Id to commit SHA1 mapping for all Change-Id's that we find in merged
        // commits. We need this for knowing which commit merged the change when auto-closing
        // changes by Change-Id.
        Map<Change.Key, ObjectId> changeIdToMergedSha1 = new HashMap<>();
        // Base predicate which is fixed for every change query.
        Predicate<ChangeData> basePredicate = and(ChangePredicates.project(projectName), ChangePredicates.ref(branch), open());
        int maxLeafPredicates = indexConfig.maxTerms() - basePredicate.getLeafCount();
        // List of predicates by which we want to find open changes for the branch. These predicates
        // will be combined with the 'or' operator.
        List<Predicate<ChangeData>> predicates = new ArrayList<>(maxLeafPredicates);
        RevCommit commit;
        int skippedCommits = 0;
        int walkedCommits = 0;
        while ((commit = rw.next()) != null) {
            if (input.skipCommits != null && skippedCommits < input.skipCommits) {
                skippedCommits++;
                continue;
            }
            if (walkedCommits >= maxCommits) {
                break;
            }
            walkedCommits++;
            ObjectId commitId = commit.copy();
            mergedSha1s.add(commitId);
            // Consider all Change-Id lines since this is what ReceiveCommits#autoCloseChanges does.
            List<String> changeIds = ChangeUtil.getChangeIdsFromFooter(commit, urlFormatter.get());
            // Number of predicates that we need to add for this commit, 1 per Change-Id plus one for
            // the commit.
            int newPredicatesCount = changeIds.size() + 1;
            // the query and start a new one.
            if (predicates.size() + newPredicatesCount > maxLeafPredicates) {
                autoCloseableChanges.addAll(executeQueryAndAutoCloseChanges(basePredicate, seenChanges, predicates, fix, changeIdToMergedSha1, mergedSha1s));
                mergedSha1s.clear();
                changeIdToMergedSha1.clear();
                predicates.clear();
                if (newPredicatesCount > maxLeafPredicates) {
                    // Whee, a single commit generates more than maxLeafPredicates predicates. Give up.
                    throw new ResourceConflictException(String.format("commit %s contains more Change-Ids than we can handle", commit.name()));
                }
            }
            changeIds.forEach(changeId -> {
                // It can happen that there are multiple merged commits with the same Change-Id
                // footer (e.g. if a change was cherry-picked to a stable branch stable branch which
                // then got merged back into master, or just by directly pushing several commits
                // with the same Change-Id). In this case it is hard to say which of the commits
                // should be used to auto-close an open change with the same Change-Id (and branch).
                // Possible approaches are:
                // 1. use the oldest commit with that Change-Id to auto-close the change
                // 2. use the newest commit with that Change-Id to auto-close the change
                // Possibility 1. has the disadvantage that the commit may have been merged before
                // the change was created in which case it is strange how it could auto-close the
                // change. Also this strategy would require to walk all commits since otherwise we
                // cannot be sure that we have seen the oldest commit with that Change-Id.
                // Possibility 2 has the disadvantage that it doesn't produce the same result as if
                // auto-closing on push would have worked, since on direct push the first commit with
                // a Change-Id of an open change would have closed that change. Also for this we
                // would need to consider all commits that are skipped.
                // Since both possibilities are not perfect and require extra effort we choose the
                // easiest approach, which is use the newest commit with that Change-Id that we have
                // seen (this means we ignore skipped commits). This should be okay since the
                // important thing for callers is that auto-closable changes are closed. Which of the
                // commits is used to auto-close a change if there are several candidates is of minor
                // importance and hence can be non-deterministic.
                Change.Key changeKey = Change.key(changeId);
                if (!changeIdToMergedSha1.containsKey(changeKey)) {
                    changeIdToMergedSha1.put(changeKey, commitId);
                }
                // Find changes that have a matching Change-Id.
                predicates.add(ChangePredicates.idPrefix(changeId));
            });
            // Find changes that have a matching commit.
            predicates.add(ChangePredicates.commitPrefix(commit.name()));
        }
        if (!predicates.isEmpty()) {
            // Execute the query with the remaining predicates that were collected.
            autoCloseableChanges.addAll(executeQueryAndAutoCloseChanges(basePredicate, seenChanges, predicates, fix, changeIdToMergedSha1, mergedSha1s));
        }
    }
    r.autoCloseableChanges = autoCloseableChanges;
    return r;
}

Example 9 with Predicate

use of com.google.gerrit.index.query.Predicate in project gerrit by GerritCodeReview.

the class ReviewersUtil method suggestAccounts.

private List<Account.Id> suggestAccounts(SuggestReviewers suggestReviewers) throws BadRequestException {
    try (Timer0.Context ctx = metrics.queryAccountsLatency.start()) {
        // For performance reasons we don't use AccountQueryProvider as it would always load the
        // complete account from the cache (or worse, from NoteDb) even though we only need the ID
        // which we can directly get from the returned results.
        Predicate<AccountState> pred = Predicate.and(AccountPredicates.isActive(), accountQueryBuilder.defaultQuery(suggestReviewers.getQuery()));
        logger.atFine().log("accounts index query: %s", pred);
        accountIndexRewriter.validateMaxTermsInQuery(pred);
        boolean useLegacyNumericFields = accountIndexes.getSearchIndex().getSchema().useLegacyNumericFields();
        FieldDef<AccountState, ?> idField = useLegacyNumericFields ? AccountField.ID : AccountField.ID_STR;
        ResultSet<FieldBundle> result = accountIndexes.getSearchIndex().getSource(pred, QueryOptions.create(indexConfig, 0, suggestReviewers.getLimit(), ImmutableSet.of(idField.getName()))).readRaw();
        List<Account.Id> matches = result.toList().stream().map(f -> fromIdField(f, useLegacyNumericFields)).collect(toList());
        logger.atFine().log("Matches: %s", matches);
        return matches;
    } catch (TooManyTermsInQueryException e) {
        throw new BadRequestException(e.getMessage());
    } catch (QueryParseException e) {
        logger.atWarning().withCause(e).log("Suggesting accounts failed, return empty result.");
        return ImmutableList.of();
    } catch (StorageException e) {
        if (e.getCause() instanceof TooManyTermsInQueryException) {
            throw new BadRequestException(e.getMessage());
        }
        if (e.getCause() instanceof QueryParseException) {
            return ImmutableList.of();
        }
        throw e;
    }
}

Example 10 with Predicate

use of com.google.gerrit.index.query.Predicate in project gerrit by GerritCodeReview.

the class CommitsCollection method canRead.

/**
 * Returns true if {@code commit} is visible to the caller.
 */
public boolean canRead(ProjectState state, Repository repo, RevCommit commit) throws IOException {
    Project.NameKey project = state.getNameKey();
    if (indexes.getSearchIndex() == null) {
        // as the commit might be a patchset of a not yet submitted change.
        return reachable.fromRefs(project, repo, commit, repo.getRefDatabase().getRefs());
    }
    // Check first if any patchset of any change references the commit in question. This is much
    // cheaper than ref visibility filtering and reachability computation.
    List<ChangeData> changes = retryHelper.changeIndexQuery("queryChangesByProjectCommitWithLimit1", q -> q.enforceVisibility(true).setLimit(1).byProjectCommit(project, commit)).call();
    if (!changes.isEmpty()) {
        return true;
    }
    // Maybe the commit was a merge commit of a change. Try to find promising candidates for
    // branches to check, by seeing if its parents were associated to changes.
    Predicate<ChangeData> pred = Predicate.and(ChangePredicates.project(project), Predicate.or(Arrays.stream(commit.getParents()).map(parent -> ChangePredicates.commitPrefix(parent.getId().getName())).collect(toImmutableList())));
    changes = retryHelper.changeIndexQuery("queryChangesByProjectCommit", q -> q.enforceVisibility(true).query(pred)).call();
    Set<Ref> branchesForCommitParents = new HashSet<>(changes.size());
    for (ChangeData cd : changes) {
        Ref ref = repo.exactRef(cd.change().getDest().branch());
        if (ref != null) {
            branchesForCommitParents.add(ref);
        }
    }
    if (reachable.fromRefs(project, repo, commit, branchesForCommitParents.stream().collect(Collectors.toList()))) {
        return true;
    }
    // If we have already checked change refs using the change index, spare any further checks for
    // changes.
    List<Ref> refs = repo.getRefDatabase().getRefsByPrefixWithExclusions(RefDatabase.ALL, ImmutableSet.of(RefNames.REFS_CHANGES));
    return reachable.fromRefs(project, repo, commit, refs);
}