示例#1
0
  private void addGeoTemporalQueries(
      QueryProcessor queryProcessor,
      QueryProcessor.QueryTarget queryTarget,
      StringBuilder finalQuery) {
    Query.GeographicQuery gq = queryProcessor.getQ().getGeographicQuery();

    boolean wantLastTime = false;
    if (queryProcessor.getQ().getTimes() != null) {
      for (Query.Times.Term time : queryProcessor.getQ().getTimes().getTerms()) {
        if (time.getTime().equals("lastTime")) {
          wantLastTime = true;
          break;
        }
      }
    }

    Query.TemporalQuery tq = queryProcessor.getQ().getTemporalQuery();

    if (gq != null && gq.getQuery() != null) finalQuery.append(" " + gq.getQuery() + " ");

    if (wantLastTime) finalQuery.append(" time:2005 radiumYears:10 ");
    else if (tq != null && tq.getQuery() != null) finalQuery.append(" " + tq.getQuery() + " ");

    if ((gq != null && gq.getQuery() != null) || (tq != null && tq.getQuery() != null))
      finalQuery.append(" filter: no ");
  }
示例#2
0
  private List<List<ChangeInfo>> query() throws OrmException, QueryParseException {
    if (imp.isDisabled()) {
      throw new QueryParseException("query disabled");
    }
    if (queries == null || queries.isEmpty()) {
      queries = Collections.singletonList("status:open");
    } else if (queries.size() > 10) {
      // Hard-code a default maximum number of queries to prevent
      // users from submitting too much to the server in a single call.
      throw new QueryParseException("limit of 10 queries");
    }

    IdentifiedUser self = null;
    try {
      if (user.get().isIdentifiedUser()) {
        self = (IdentifiedUser) user.get();
        self.asyncStarredChanges();
      }
      return query0();
    } finally {
      if (self != null) {
        self.abortStarredChanges();
      }
    }
  }
示例#3
0
 private void addWikipediaTermQueries(
     QueryProcessor queryProcessor,
     QueryProcessor.QueryTarget queryTarget,
     StringBuilder finalQuery) {
   String queryTermsWikipedia = queryProcessor.getWikipediaTermsQuery(queryTarget);
   finalQuery.append(" " + queryTermsWikipedia + " ");
 }
示例#4
0
 @Inject
 InternalChangeQuery(
     IndexConfig indexConfig, QueryProcessor queryProcessor, IndexCollection indexes) {
   this.indexConfig = indexConfig;
   qp = queryProcessor.enforceVisibility(false);
   this.indexes = indexes;
 }
 public List<ChangeData> query(Predicate<ChangeData> p) throws OrmException {
   try {
     return qp.queryChanges(p).changes();
   } catch (QueryParseException e) {
     throw new OrmException(e);
   }
 }
  @Test
  public void prepopulatedFields() throws Exception {
    assume().that(notesMigration.enabled()).isFalse();
    TestRepository<Repo> repo = createProject("repo");
    Change change = newChange(repo, null, null, null, null).insert();

    db = new DisabledReviewDb();
    requestContext.setContext(newRequestContext(userId));
    // Use QueryProcessor directly instead of API so we get ChangeDatas back.
    List<ChangeData> cds =
        queryProcessor.queryChanges(queryBuilder.parse(change.getId().toString())).changes();
    assertThat(cds).hasSize(1);

    ChangeData cd = cds.get(0);
    cd.change();
    cd.patchSets();
    cd.currentApprovals();
    cd.changedLines();
    cd.reviewedBy();

    // TODO(dborowitz): Swap out GitRepositoryManager somehow? Will probably be
    // necessary for notedb anyway.
    cd.isMergeable();

    // Don't use ExpectedException since that wouldn't distinguish between
    // failures here and on the previous calls.
    try {
      cd.messages();
    } catch (AssertionError e) {
      assertThat(e.getMessage()).isEqualTo(DisabledReviewDb.MESSAGE);
    }
  }
 private static UntypedResultSet execute(String query) throws Throwable {
   try {
     return QueryProcessor.executeInternal(String.format(query));
   } catch (RuntimeException exc) {
     if (exc.getCause() != null) throw exc.getCause();
     throw exc;
   }
 }
示例#8
0
 @Option(
     name = "--start",
     aliases = {"-S"},
     metaVar = "CNT",
     usage = "Number of changes to skip")
 public void setStart(int start) {
   imp.setStart(start);
 }
示例#9
0
 @Option(
     name = "--limit",
     aliases = {"-n"},
     metaVar = "CNT",
     usage = "Maximum number of results to return")
 public void setLimit(int limit) {
   imp.setLimit(limit);
 }
示例#10
0
  private void addFilterQueries(
      QueryProcessor queryProcessor,
      QueryProcessor.QueryTarget queryTarget,
      StringBuilder finalQuery) {
    String queryPlaceRefsFilters =
        queryProcessor.getPlaceRefsFiltersAsQueries(queryTarget, Config.placeRefFactor);

    String queryPlaceBelongTosFilters =
        queryProcessor.getPlaceFiltersAsQueriesBelongTos(queryTarget, Config.belongTosFactor);
    String queryPlaceTypeFilters = queryProcessor.getPlaceTypeFiltersAsQueries(queryTarget);

    String queryTimeFiltersKeys = null;
    String queryTimeFiltersRelative = null;
    String queryTimeFiltersDuration = null;
    String queryTimeTypeFilters;
    if (queryProcessor.isTime_key()) {
      queryTimeFiltersKeys = queryProcessor.getTimeKeyPointsFiltersAsQueries(queryTarget, "1");
      queryTimeTypeFilters = queryProcessor.getTimeKeyTypeFiltersAsQueries(queryTarget);
    } else {
      queryTimeFiltersKeys =
          queryProcessor.getTimeKeyPointsFiltersAsQueries(queryTarget, Config.keyTimeFactor);
      queryTimeFiltersRelative =
          queryProcessor.getTimeRelativePointsFiltersAsQueries(
              queryTarget, Config.relativeTimeFactor);
      //            queryTimeFiltersDuration =
      // queryProcessor.getTimeDurationPointsFiltersAsQueries(queryTarget,
      // Config.durationTimeFactor);

      queryTimeTypeFilters = queryProcessor.getTimeTypeFiltersAsQueries(queryTarget);
    }
    // append FILTER QUERIES
    if (queryPlaceRefsFilters != null && queryPlaceRefsFilters.trim().length() > 0)
      finalQuery.append(" ").append(queryPlaceRefsFilters);
    if (usePlaceRefsBelongTosFiltersInQuery
        && queryPlaceBelongTosFilters != null
        && queryPlaceBelongTosFilters.trim().length() > 0)
      finalQuery.append(" ").append(queryPlaceBelongTosFilters);
    if (usePlaceRefsTypesFiltersInQuery
        && queryPlaceTypeFilters != null
        && queryPlaceTypeFilters.trim().length() > 0)
      finalQuery.append(" ").append(queryPlaceTypeFilters);
    if (queryTimeFiltersKeys != null && queryTimeFiltersKeys.trim().length() > 0)
      finalQuery.append(" ").append(queryTimeFiltersKeys);
    if (queryTimeFiltersRelative != null && queryTimeFiltersRelative.trim().length() > 0)
      finalQuery.append(" ").append(queryTimeFiltersRelative);
    if (queryTimeFiltersDuration != null && queryTimeFiltersDuration.trim().length() > 0)
      finalQuery.append(" ").append(queryTimeFiltersDuration);
    if (queryTimeTypeFilters != null && queryTimeTypeFilters.trim().length() > 0)
      finalQuery.append(" ").append(queryTimeTypeFilters);
  }
 @Inject
 InternalChangeQuery(
     IndexConfig indexConfig,
     QueryProcessor queryProcessor,
     IndexCollection indexes,
     ChangeData.Factory changeDataFactory) {
   this.indexConfig = indexConfig;
   qp = queryProcessor.enforceVisibility(false);
   this.indexes = indexes;
   this.changeDataFactory = changeDataFactory;
 }
示例#12
0
 private List<List<ChangeInfo>> query0() throws OrmException, QueryParseException {
   int cnt = queries.size();
   List<QueryResult> results = imp.queryChanges(qb.parse(queries));
   List<List<ChangeInfo>> res = json.create(options).formatQueryResults(results);
   for (int n = 0; n < cnt; n++) {
     List<ChangeInfo> info = res.get(n);
     if (results.get(n).moreChanges()) {
       info.get(info.size() - 1)._moreChanges = true;
     }
   }
   return res;
 }
示例#13
0
    protected Filter createBaseFilter(QueryProcessor q, String suffix) {
      if (q.wantPlaces() && q.wantTimes()) {
        TermsFilter timeFilter = new TermsFilter();
        if (q.isTime_key())
          timeFilter.addTerm(new Term(Config.S_HAS_TIME_POINTS_KEY + suffix, "true"));
        else
          timeFilter.addTerm(
              new Term(Config.S_HAS_ANY_TIME_POINT + suffix, "true")); // OPTAR POR DURACOES

        TermsFilter filterGeo = new TermsFilter();
        filterGeo.addTerm(new Term(Config.S_GEO_INDEXED + suffix, "true"));

        Filter[] filterChain = new Filter[] {filterGeo, timeFilter};
        int[] actionType = new int[] {SerialChainFilter.AND, SerialChainFilter.AND};
        return new SerialChainFilter(filterChain, actionType);
      } else if (q.wantPlaces()) {
        TermsFilter filter = new TermsFilter();
        filter.addTerm(new Term(Config.S_GEO_INDEXED + suffix, "true"));
        return filter;
      } else if (q.wantTimes()) {
        if (q.isTime_key()) {
          TermsFilter filter = new TermsFilter();
          filter.addTerm(new Term(Config.S_HAS_YYYY_KEY + suffix, "true"));
          return filter;
        } else {
          TermsFilter filter = new TermsFilter();
          filter.addTerm(
              new Term(Config.S_HAS_ANY_TIME_POINT + suffix, "true")); // OPTAR POR DURACOES
          return filter;
        }
      } else return null;
    }
示例#14
0
 @VisibleForTesting
 Iterable<ChangeData> byCommitsOnBranchNotMerged(
     Schema<ChangeData> schema, Branch.NameKey branch, List<String> hashes, int batchSize)
     throws OrmException {
   List<Predicate<ChangeData>> commits = commits(schema, hashes);
   int numBatches = (hashes.size() / batchSize) + 1;
   List<Predicate<ChangeData>> queries = new ArrayList<>(numBatches);
   for (List<Predicate<ChangeData>> batch : Iterables.partition(commits, batchSize)) {
     queries.add(commitsOnBranchNotMerged(branch, batch));
   }
   try {
     return FluentIterable.from(qp.queryChanges(queries))
         .transformAndConcat(
             new Function<QueryResult, List<ChangeData>>() {
               @Override
               public List<ChangeData> apply(QueryResult in) {
                 return in.changes();
               }
             });
   } catch (QueryParseException e) {
     throw new OrmException(e);
   }
 }
示例#15
0
  private void addTermQueries(
      QueryProcessor queryProcessor,
      QueryProcessor.QueryTarget queryTarget,
      StringBuilder finalQuery) {
    String queryTermsSentences = queryProcessor.getTermsQuery(queryTarget);
    String queryPlacesRef = queryProcessor.getPlacesRefQuery(queryTarget, Config.placeRefFactor);
    String queryPlacesBelongTos =
        queryProcessor.getPlacesBeolongTosQuery(queryTarget, Config.belongTosFactor);
    String queryTimesKeys;
    String queryTimesRelative = null;
    String queryTimesDuration = null;
    if (queryProcessor.isTime_key())
      queryTimesKeys = queryProcessor.getTimesQueryKeyTimeExpressions(queryTarget, "1");
    else {
      queryTimesKeys =
          queryProcessor.getTimesQueryKeyTimeExpressions(queryTarget, Config.keyTimeFactor);
      queryTimesRelative =
          queryProcessor.getTimesQueryRelativeTimeExpressions(
              queryTarget, Config.relativeTimeFactor);
      //            queryTimesDuration =
      // queryProcessor.getTimesQueryDurationsTimeExpressions(queryTarget,
      // Config.durationTimeFactor);
    }

    finalQuery.append(queryTermsSentences);
    if (queryPlacesRef != null && queryPlacesRef.trim().length() > 0)
      finalQuery.append(" ").append(queryPlacesRef);
    if (queryPlacesBelongTos != null && queryPlacesBelongTos.trim().length() > 0)
      finalQuery.append(" ").append(queryPlacesBelongTos);
    if (queryTimesKeys != null && queryTimesKeys.trim().length() > 0)
      finalQuery.append(" ").append(queryTimesKeys);
    if (queryTimesRelative != null && queryTimesRelative.trim().length() > 0)
      finalQuery.append(" ").append(queryTimesRelative);
    if (queryTimesDuration != null && queryTimesDuration.trim().length() > 0)
      finalQuery.append(" ").append(queryTimesDuration);
  }
  public RowMutation mutationForKey(
      CFDefinition cfDef,
      ByteBuffer key,
      ColumnNameBuilder builder,
      boolean isRange,
      UpdateParameters params,
      ColumnGroupMap group)
      throws InvalidRequestException {
    QueryProcessor.validateKey(key);
    RowMutation rm = new RowMutation(cfDef.cfm.ksName, key);
    ColumnFamily cf = rm.addOrGet(columnFamily());

    if (columns.isEmpty() && builder.componentCount() == 0) {
      // No columns, delete the row
      cf.delete(new DeletionInfo(params.timestamp, params.localDeletionTime));
    } else {
      if (isRange) {
        ByteBuffer start = builder.copy().build();
        ByteBuffer end = builder.buildAsEndOfRange();
        QueryProcessor.validateColumnName(start); // If start is good, end is too
        cf.addAtom(params.makeRangeTombstone(start, end));
      } else {
        // Delete specific columns
        if (cfDef.isCompact) {
          ByteBuffer columnName = builder.build();
          QueryProcessor.validateColumnName(columnName);
          cf.addColumn(params.makeTombstone(columnName));
        } else {
          Iterator<Pair<CFDefinition.Name, Term>> iter = toRemove.iterator();
          while (iter.hasNext()) {
            Pair<CFDefinition.Name, Term> p = iter.next();
            CFDefinition.Name column = p.left;

            if (column.type.isCollection()) {
              CollectionType validator = (CollectionType) column.type;
              Term keySelected = p.right;

              if (keySelected == null) {
                // Delete the whole collection
                ByteBuffer start = builder.copy().add(column.name.key).build();
                QueryProcessor.validateColumnName(start);
                ColumnNameBuilder b = iter.hasNext() ? builder.copy() : builder;
                ByteBuffer end = b.add(column.name.key).buildAsEndOfRange();
                cf.addAtom(params.makeRangeTombstone(start, end));
              } else {
                builder.add(column.name.key);
                List<Term> args = Collections.singletonList(keySelected);

                Operation op;
                switch (validator.kind) {
                  case LIST:
                    op = ListOperation.DiscardKey(args);
                    break;
                  case SET:
                    op = SetOperation.Discard(args);
                    break;
                  case MAP:
                    op = MapOperation.DiscardKey(keySelected);
                    break;
                  default:
                    throw new InvalidRequestException("Unknown collection type: " + validator.kind);
                }

                op.execute(
                    cf,
                    builder,
                    validator,
                    params,
                    group == null ? null : group.getCollection(column.name.key));
              }
            } else {
              ColumnNameBuilder b = iter.hasNext() ? builder.copy() : builder;
              ByteBuffer columnName = b.add(column.name.key).build();
              QueryProcessor.validateColumnName(columnName);
              cf.addColumn(params.makeTombstone(columnName));
            }
          }
        }
      }
    }

    return rm;
  }
 public InternalChangeQuery setLimit(int n) {
   qp.setLimit(n);
   return this;
 }
 public InternalChangeQuery setRequestedFields(Set<String> fields) {
   qp.setRequestedFields(fields);
   return this;
 }
 public InternalChangeQuery enforceVisibility(boolean enforce) {
   qp.enforceVisibility(enforce);
   return this;
 }
示例#20
0
 public String getTopicId() {
   return queryProcessor.getQ().getId();
 }