protected <N extends Number> NumericRangeQuery<?> numericRange(
     Class<N> clazz,
     String field,
     @Nullable N min,
     @Nullable N max,
     boolean minInc,
     boolean maxInc) {
   if (clazz.equals(Integer.class)) {
     return NumericRangeQuery.newIntRange(field, (Integer) min, (Integer) max, minInc, maxInc);
   } else if (clazz.equals(Double.class)) {
     return NumericRangeQuery.newDoubleRange(field, (Double) min, (Double) max, minInc, minInc);
   } else if (clazz.equals(Float.class)) {
     return NumericRangeQuery.newFloatRange(field, (Float) min, (Float) max, minInc, minInc);
   } else if (clazz.equals(Long.class)) {
     return NumericRangeQuery.newLongRange(field, (Long) min, (Long) max, minInc, minInc);
   } else if (clazz.equals(Byte.class) || clazz.equals(Short.class)) {
     return NumericRangeQuery.newIntRange(
         field,
         min != null ? min.intValue() : null,
         max != null ? max.intValue() : null,
         minInc,
         maxInc);
   } else {
     throw new IllegalArgumentException("Unsupported numeric type " + clazz.getName());
   }
 }
 public void testToQueryNumericRangeQuery() throws Exception {
   assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
   Query query =
       queryStringQuery("12~0.2").defaultField(INT_FIELD_NAME).toQuery(createShardContext());
   NumericRangeQuery fuzzyQuery = (NumericRangeQuery) query;
   assertThat(fuzzyQuery.getMin().longValue(), equalTo(12l));
   assertThat(fuzzyQuery.getMax().longValue(), equalTo(12l));
 }
 private static void planNumericRangeQuery(
     final StringBuilder builder, final NumericRangeQuery<?> query) {
   builder.append(query.getMin());
   builder.append(" TO ");
   builder.append(query.getMax());
   builder.append(" AS ");
   builder.append(query.getMin().getClass().getSimpleName());
 }
 private void assertRange(final Query q, final Class<?> type, final Number min, final Number max) {
   assertThat(q, is(NumericRangeQuery.class));
   final NumericRangeQuery nq = (NumericRangeQuery) q;
   assertThat(nq.getMin(), is(type));
   assertThat(nq.getMax(), is(type));
   assertThat(nq.getMin(), is(min));
   assertThat(nq.getMax(), is(max));
 }
Exemple #5
0
  public CObjList searchFiles(String comid, String share, String qstr, Sort srt) {
    BooleanQuery query = new BooleanQuery();

    Term pstterm = new Term(CObj.PARAM_TYPE, CObj.FILE);
    query.add(new TermQuery(pstterm), BooleanClause.Occur.MUST);

    Term comterm = new Term(CObj.docString(CObj.COMMUNITYID), comid);
    query.add(new TermQuery(comterm), BooleanClause.Occur.MUST);

    NumericRangeQuery<Long> nq =
        NumericRangeQuery.newLongRange(
            CObj.docNumber(CObj.NUMBER_HAS), 0L, Long.MAX_VALUE, false, true);
    query.add(nq, BooleanClause.Occur.MUST);

    if (share != null) {
      Term shareterm = new Term(CObj.docString(CObj.SHARE_NAME), share);
      query.add(new TermQuery(shareterm), BooleanClause.Occur.MUST);
    }

    Matcher m = Pattern.compile("\\S+").matcher(qstr);

    if (m.find()) {
      StringBuilder sb = new StringBuilder();
      sb.append(CObj.docStringText(CObj.NAME));
      sb.append(":\"");
      sb.append(qstr);
      sb.append("\"");
      return search(query, sb.toString(), Integer.MAX_VALUE, srt);
    } else {
      return search(query, Integer.MAX_VALUE, srt);
    }
  }
 private Query innerRangeQuery(
     Object lowerTerm,
     Object upperTerm,
     boolean includeLower,
     boolean includeUpper,
     @Nullable DateTimeZone timeZone,
     @Nullable DateMathParser forcedDateParser) {
   return NumericRangeQuery.newLongRange(
       names.indexName(),
       precisionStep,
       lowerTerm == null
           ? null
           : parseToMilliseconds(
               lowerTerm,
               !includeLower,
               timeZone,
               forcedDateParser == null ? dateMathParser : forcedDateParser),
       upperTerm == null
           ? null
           : parseToMilliseconds(
               upperTerm,
               includeUpper,
               timeZone,
               forcedDateParser == null ? dateMathParser : forcedDateParser),
       includeLower,
       includeUpper);
 }
  public Concept getNextConceptToUpdate() {
    synchronized (lock) {
      IndexHits<Node> hits =
          conceptsForUpdate.query(
              new QueryContext(
                      NumericRangeQuery.newLongRange(
                          NamespaceConstants.DATE_UPDATED,
                          Long.MIN_VALUE,
                          Long.MAX_VALUE,
                          true,
                          true))
                  .sort(
                      new Sort(
                          new SortField(NamespaceConstants.DATE_UPDATED, SortField.LONG, false))));

      if (hits.hasNext()) {
        Node job = hits.next();
        System.out.println(job.getId());
        Concept concept = getByNode(job);
        removeFromCU(concept);
        return concept;
      }
    }
    return null;
  }
 @Override
 public Query fuzzyQuery(String value, double minSim, int prefixLength, int maxExpansions) {
   short iValue = Short.parseShort(value);
   short iSim = (short) (minSim * dFuzzyFactor);
   return NumericRangeQuery.newIntRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 public Query createQuery() {
   Calendar[] dates = generate(date);
   /* we dont cache query because of the dates */
   return NumericRangeQuery.newLongRange(
       getLuceneField(), dates[0].getTimeInMillis(), dates[1].getTimeInMillis(), true, true);
 }
 public static Query createMultiIntQuery(String field, int[] ids) {
   BooleanQuery query = new BooleanQuery();
   for (int id : ids) {
     query.add(NumericRangeQuery.newIntRange(field, id, id, true, true), Occur.SHOULD);
   }
   return query;
 }
 @Override
 public Query fuzzyQuery(
     String value, double minSim, int prefixLength, int maxExpansions, boolean transpositions) {
   long iValue = Long.parseLong(value);
   long iSim = (long) (minSim * dFuzzyFactor);
   return NumericRangeQuery.newLongRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
  @Override
  public void addNumericRangeTerm(
      BooleanQuery booleanQuery, String field, Long startValue, Long endValue) {

    NumericRangeQuery<?> numericRangeQuery =
        NumericRangeQuery.newLongRange(field, startValue, endValue, true, true);

    booleanQuery.add(numericRangeQuery, BooleanClause.Occur.SHOULD);
  }
  public void testDateRangeBoundaries() throws IOException {
    assumeTrue("test runs only when at least a type is registered", getCurrentTypes().length > 0);
    String query =
        "{\n"
            + "    \"range\" : {\n"
            + "        \""
            + DATE_FIELD_NAME
            + "\" : {\n"
            + "            \"gte\": \"2014-11-05||/M\",\n"
            + "            \"lte\": \"2014-12-08||/d\"\n"
            + "        }\n"
            + "    }\n"
            + "}\n";
    Query parsedQuery = parseQuery(query).toQuery(createShardContext()).rewrite(null);
    assertThat(parsedQuery, instanceOf(NumericRangeQuery.class));
    NumericRangeQuery rangeQuery = (NumericRangeQuery) parsedQuery;

    DateTime min = DateTime.parse("2014-11-01T00:00:00.000+00");
    assertThat(rangeQuery.getMin().longValue(), is(min.getMillis()));
    assertTrue(rangeQuery.includesMin());

    DateTime max = DateTime.parse("2014-12-08T23:59:59.999+00");
    assertThat(rangeQuery.getMax().longValue(), is(max.getMillis()));
    assertTrue(rangeQuery.includesMax());

    query =
        "{\n"
            + "    \"range\" : {\n"
            + "        \""
            + DATE_FIELD_NAME
            + "\" : {\n"
            + "            \"gt\": \"2014-11-05||/M\",\n"
            + "            \"lt\": \"2014-12-08||/d\"\n"
            + "        }\n"
            + "    }\n"
            + "}";
    parsedQuery = parseQuery(query).toQuery(createShardContext()).rewrite(null);
    assertThat(parsedQuery, instanceOf(NumericRangeQuery.class));
    rangeQuery = (NumericRangeQuery) parsedQuery;

    min = DateTime.parse("2014-11-30T23:59:59.999+00");
    assertThat(rangeQuery.getMin().longValue(), is(min.getMillis()));
    assertFalse(rangeQuery.includesMin());

    max = DateTime.parse("2014-12-08T00:00:00.000+00");
    assertThat(rangeQuery.getMax().longValue(), is(max.getMillis()));
    assertFalse(rangeQuery.includesMax());
  }
  /**
   * Returns a number of random songs.
   *
   * @param criteria Search criteria.
   * @return List of random songs.
   */
  public List<MediaFile> getRandomSongs(RandomSearchCriteria criteria) {
    List<MediaFile> result = new ArrayList<MediaFile>();

    IndexReader reader = null;
    try {
      reader = createIndexReader(SONG);
      Searcher searcher = new IndexSearcher(reader);

      BooleanQuery query = new BooleanQuery();
      query.add(
          new TermQuery(new Term(FIELD_MEDIA_TYPE, MediaFile.MediaType.MUSIC.name().toLowerCase())),
          BooleanClause.Occur.MUST);
      if (criteria.getGenre() != null) {
        String genre = normalizeGenre(criteria.getGenre());
        query.add(new TermQuery(new Term(FIELD_GENRE, genre)), BooleanClause.Occur.MUST);
      }
      if (criteria.getFromYear() != null || criteria.getToYear() != null) {
        NumericRangeQuery<Integer> rangeQuery =
            NumericRangeQuery.newIntRange(
                FIELD_YEAR, criteria.getFromYear(), criteria.getToYear(), true, true);
        query.add(rangeQuery, BooleanClause.Occur.MUST);
      }

      List<SpanTermQuery> musicFolderQueries = new ArrayList<SpanTermQuery>();
      for (MusicFolder musicFolder : criteria.getMusicFolders()) {
        musicFolderQueries.add(
            new SpanTermQuery(new Term(FIELD_FOLDER, musicFolder.getPath().getPath())));
      }
      query.add(
          new SpanOrQuery(musicFolderQueries.toArray(new SpanQuery[musicFolderQueries.size()])),
          BooleanClause.Occur.MUST);

      TopDocs topDocs = searcher.search(query, null, Integer.MAX_VALUE);
      List<ScoreDoc> scoreDocs = Lists.newArrayList(topDocs.scoreDocs);
      Random random = new Random(System.currentTimeMillis());

      while (!scoreDocs.isEmpty() && result.size() < criteria.getCount()) {
        int index = random.nextInt(scoreDocs.size());
        Document doc = searcher.doc(scoreDocs.remove(index).doc);
        int id = Integer.valueOf(doc.get(FIELD_ID));
        try {
          addIfNotNull(mediaFileService.getMediaFile(id), result);
        } catch (Exception x) {
          LOG.warn("Failed to get media file " + id);
        }
      }

    } catch (Throwable x) {
      LOG.error("Failed to search or random songs.", x);
    } finally {
      FileUtil.closeQuietly(reader);
    }
    return result;
  }
 @Override
 public Query rangeQuery(
     Object lowerTerm, Object upperTerm, boolean includeLower, boolean includeUpper) {
   return NumericRangeQuery.newIntRange(
       name(),
       numericPrecisionStep(),
       lowerTerm == null ? null : (int) parseValue(lowerTerm),
       upperTerm == null ? null : (int) parseValue(upperTerm),
       includeLower,
       includeUpper);
 }
  private static JsonObject convertNumericRangeQuery(NumericRangeQuery<?> query) {
    JsonObject interval = new JsonObject();
    if (query.getMin() != null) {
      interval.addProperty(query.includesMin() ? "gte" : "gt", query.getMin());
    }
    if (query.getMax() != null) {
      interval.addProperty(query.includesMax() ? "lte" : "lt", query.getMax());
    }
    interval.addProperty("boost", query.getBoost());

    JsonObject range =
        JsonBuilder.object()
            .add("range", JsonBuilder.object().add(query.getField(), interval))
            .build();

    return wrapQueryForNestedIfRequired(query.getField(), range);
  }
 @Override
 public Query fuzzyQuery(
     Object value,
     Fuzziness fuzziness,
     int prefixLength,
     int maxExpansions,
     boolean transpositions) {
   byte iValue = parseValue(value);
   byte iSim = fuzziness.asByte();
   return NumericRangeQuery.newIntRange(
       name(), numericPrecisionStep(), iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 public Query fuzzyQuery(
     String value,
     Fuzziness fuzziness,
     int prefixLength,
     int maxExpansions,
     boolean transpositions) {
   int iValue = Integer.parseInt(value);
   int iSim = fuzziness.asInt();
   return NumericRangeQuery.newIntRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 public Query fuzzyQuery(
     String value,
     Fuzziness fuzziness,
     int prefixLength,
     int maxExpansions,
     boolean transpositions) {
   double iValue = Double.parseDouble(value);
   double iSim = fuzziness.asDouble();
   return NumericRangeQuery.newDoubleRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 public Query fuzzyQuery(
     String value,
     Fuzziness fuzziness,
     int prefixLength,
     int maxExpansions,
     boolean transpositions) {
   short iValue = Short.parseShort(value);
   short iSim = fuzziness.asShort();
   return NumericRangeQuery.newIntRange(
       names().indexName(), numericPrecisionStep(), iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 public Query fuzzyQuery(String value, String minSim, int prefixLength, int maxExpansions) {
   short iValue = Short.parseShort(value);
   short iSim;
   try {
     iSim = Short.parseShort(minSim);
   } catch (NumberFormatException e) {
     iSim = (short) Float.parseFloat(minSim);
   }
   return NumericRangeQuery.newIntRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 protected void doAssertLuceneQuery(
     RangeQueryBuilder queryBuilder, Query query, QueryShardContext context) throws IOException {
   if (getCurrentTypes().length == 0
       || (queryBuilder.fieldName().equals(DATE_FIELD_NAME) == false
           && queryBuilder.fieldName().equals(INT_FIELD_NAME) == false)) {
     assertThat(query, instanceOf(TermRangeQuery.class));
     TermRangeQuery termRangeQuery = (TermRangeQuery) query;
     assertThat(termRangeQuery.getField(), equalTo(queryBuilder.fieldName()));
     assertThat(termRangeQuery.getLowerTerm(), equalTo(BytesRefs.toBytesRef(queryBuilder.from())));
     assertThat(termRangeQuery.getUpperTerm(), equalTo(BytesRefs.toBytesRef(queryBuilder.to())));
     assertThat(termRangeQuery.includesLower(), equalTo(queryBuilder.includeLower()));
     assertThat(termRangeQuery.includesUpper(), equalTo(queryBuilder.includeUpper()));
   } else if (queryBuilder.fieldName().equals(DATE_FIELD_NAME)) {
     // we can't properly test unmapped dates because LateParsingQuery is package private
   } else if (queryBuilder.fieldName().equals(INT_FIELD_NAME)) {
     assertThat(query, instanceOf(NumericRangeQuery.class));
     NumericRangeQuery numericRangeQuery = (NumericRangeQuery) query;
     assertThat(numericRangeQuery.getField(), equalTo(queryBuilder.fieldName()));
     assertThat(numericRangeQuery.getMin(), equalTo(queryBuilder.from()));
     assertThat(numericRangeQuery.getMax(), equalTo(queryBuilder.to()));
     assertThat(numericRangeQuery.includesMin(), equalTo(queryBuilder.includeLower()));
     assertThat(numericRangeQuery.includesMax(), equalTo(queryBuilder.includeUpper()));
   } else {
     throw new UnsupportedOperationException();
   }
 }
 @Override
 public Query fuzzyQuery(
     String value, String minSim, int prefixLength, int maxExpansions, boolean transpositions) {
   long iValue = Long.parseLong(value);
   long iSim;
   try {
     iSim = Long.parseLong(minSim);
   } catch (NumberFormatException e) {
     iSim = (long) Double.parseDouble(minSim);
   }
   return NumericRangeQuery.newLongRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
 @Override
 public Query fuzzyQuery(
     String value, String minSim, int prefixLength, int maxExpansions, boolean transpositions) {
   byte iValue = Byte.parseByte(value);
   byte iSim;
   try {
     iSim = Byte.parseByte(minSim);
   } catch (NumberFormatException e) {
     iSim = (byte) Float.parseFloat(minSim);
   }
   return NumericRangeQuery.newIntRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }
Exemple #25
0
  // Could be based on creator and sequence number, but
  // not enough to worry about.  Just send all.
  public CObjList getCommunities(String creator, long first, long last) {
    BooleanQuery bq = new BooleanQuery();
    Term typterm = new Term(CObj.PARAM_TYPE, CObj.COMMUNITY);
    bq.add(new TermQuery(typterm), BooleanClause.Occur.MUST);

    Term memterm = new Term(CObj.docString(CObj.CREATOR), creator);
    bq.add(new TermQuery(memterm), BooleanClause.Occur.MUST);

    NumericRangeQuery<Long> nq =
        NumericRangeQuery.newLongRange(CObj.docNumber(CObj.SEQNUM), first, last, true, true);
    bq.add(nq, BooleanClause.Occur.MUST);

    return search(bq, Integer.MAX_VALUE);
  }
  @Test
  public void testQueryNumeric() {

    Float boost = 0.7f;
    Object[] values = new Object[] {1, 2, 3};

    Schema schema = schema().mapper("name", integerMapper()).build();

    ContainsCondition condition = new ContainsCondition(boost, "name", values);
    Query query = condition.query(schema);
    assertNotNull("Query is not built", query);
    assertEquals("Query type is wrong", BooleanQuery.class, query.getClass());

    BooleanQuery booleanQuery = (BooleanQuery) query;
    assertEquals("Boost is not set", 0.7f, query.getBoost(), 0);
    BooleanClause[] clauses = booleanQuery.getClauses();
    assertEquals("Query is wrong", values.length, clauses.length);
    for (int i = 0; i < values.length; i++) {
      NumericRangeQuery<?> numericRangeQuery = (NumericRangeQuery<?>) clauses[i].getQuery();
      assertEquals("Query is wrong", values[i], numericRangeQuery.getMin());
      assertEquals("Query is wrong", values[i], numericRangeQuery.getMax());
    }
  }
 @Override
 public Query rangeQuery(
     String lowerTerm,
     String upperTerm,
     boolean includeLower,
     boolean includeUpper,
     @Nullable QueryParseContext context) {
   return NumericRangeQuery.newIntRange(
       names.indexName(),
       precisionStep,
       lowerTerm == null ? null : Integer.parseInt(lowerTerm),
       upperTerm == null ? null : Integer.parseInt(upperTerm),
       includeLower,
       includeUpper);
 }
 @Override
 public Query rangeQuery(
     Object lowerTerm,
     Object upperTerm,
     boolean includeLower,
     boolean includeUpper,
     @Nullable QueryParseContext context) {
   return NumericRangeQuery.newIntRange(
       names.indexName(),
       precisionStep,
       lowerTerm == null ? null : parseValue(lowerTerm),
       upperTerm == null ? null : parseValue(upperTerm),
       includeLower,
       includeUpper);
 }
Exemple #29
0
  public CObjList getUnDecodedMemberships(long lastdec) {
    BooleanQuery bq = new BooleanQuery();
    Term typterm = new Term(CObj.PARAM_TYPE, CObj.MEMBERSHIP);
    bq.add(new TermQuery(typterm), BooleanClause.Occur.MUST);

    Term nondec = new Term(CObj.docPrivate(CObj.DECODED), "false");
    bq.add(new TermQuery(nondec), BooleanClause.Occur.MUST);

    NumericRangeQuery<Long> nq =
        NumericRangeQuery.newLongRange(
            CObj.docPrivateNumber(CObj.LASTUPDATE), lastdec, Long.MAX_VALUE, true, true);
    bq.add(nq, BooleanClause.Occur.MUST);

    return search(bq, Integer.MAX_VALUE);
  }
 @Override
 public Query fuzzyQuery(
     String value,
     Fuzziness fuzziness,
     int prefixLength,
     int maxExpansions,
     boolean transpositions) {
   long iValue = ipToLong(value);
   long iSim;
   try {
     iSim = ipToLong(fuzziness.asString());
   } catch (ElasticsearchIllegalArgumentException e) {
     iSim = fuzziness.asLong();
   }
   return NumericRangeQuery.newLongRange(
       names.indexName(), precisionStep, iValue - iSim, iValue + iSim, true, true);
 }