Пример #1
0
  /*
   * Writes the SOLR query for spatial operator : BBOX, IsWithin, IsDisjointTo, IsWithin,
   * Intersects, Contains
   *
   * @param filter spatial operator to encode
   */
  private Object visitBinarySpatialOperator(BinarySpatialOperator filter, Object extraData) {
    StringWriter output = asStringWriter(extraData);
    Expression e1 = filter.getExpression1();
    checkExpressionIsProperty(e1);
    Expression e2 = filter.getExpression2();
    checkExpressionIsLiteral(e2);
    ExpressionToSolr visitor = new ExpressionToSolr();
    e1.accept(visitor, extraData);
    if (filter instanceof BBOX) {
      output.append(":\"Intersects(");
      e2.accept(visitor, extraData);
      output.append(")\"");
    } else if (filter instanceof Disjoint) {
      output.append(":\"IsDisjointTo(");
      e2.accept(visitor, extraData);
      output.append(")\"");
    } else if (filter instanceof Within) {
      output.append(":\"IsWithin(");
      e2.accept(visitor, extraData);
      output.append(")\"");
    } else if (filter instanceof Intersects) {
      output.append(":\"Intersects(");
      e2.accept(visitor, extraData);
      output.append(")\"");
    } else if (filter instanceof Contains) {
      output.append(":\"Contains(");
      e2.accept(visitor, extraData);
      output.append(")\"");
    } else {
      throw new RuntimeException("Unsupported filter type " + filter.getClass());
    }

    return output;
  }
Пример #2
0
  protected Object visitBinarySpatialOperator(
      BinarySpatialOperator filter,
      Expression e1,
      Expression e2,
      boolean swapped,
      Object extraData) {

    String checkValue = "1";

    try {
      // currentSRID=getSRID();
      LOGGER.finer("Generating GeometryFilter WHERE clause for " + filter);
      if (filter instanceof Equals) {
        out.write("db2gse.ST_Equals");
      } else if (filter instanceof Disjoint && this.selectivityClause == null) {
        out.write("db2gse.ST_Disjoint");
      } else if (filter instanceof Disjoint && this.selectivityClause != null) {
        out.write("db2gse.ST_Intersects");
        checkValue = "0";
      } else if (filter instanceof Intersects || filter instanceof BBOX) {
        out.write("db2gse.ST_Intersects");
      } else if (filter instanceof Crosses) {
        out.write("db2gse.ST_Crosses");
      } else if (filter instanceof Within) {
        if (swapped) out.write("db2gse.ST_Contains");
        else out.write("db2gse.ST_Within");
      } else if (filter instanceof Contains) {
        if (swapped) out.write("db2gse.ST_Within");
        else out.write("db2gse.ST_Contains");
      } else if (filter instanceof Overlaps) {
        out.write("db2gse.ST_Overlaps");
      } else if (filter instanceof Touches) {
        out.write("db2gse.ST_Touches");
      } else {
        throw new RuntimeException("Unsupported filter type " + filter.getClass());
      }
      out.write("(");

      e1.accept(this, extraData);
      out.write(", ");
      e2.accept(this, extraData);

      out.write(") = ");
      out.write(checkValue);
      out.write(" ");
      addSelectivity(); // add selectivity clause if needed

      LOGGER.fine(this.out.toString());
      return extraData;
    } catch (IOException ex) {
      throw new RuntimeException(ex);
    }
  }
  private void visitBinarySpatialOperator(BinarySpatialOperator filter) {
    if (original == null) original = filter;

    Class[] spatialOps =
        new Class[] {
          Beyond.class,
          Contains.class,
          Crosses.class,
          Disjoint.class,
          DWithin.class,
          Equals.class,
          Intersects.class,
          Overlaps.class,
          Touches.class,
          Within.class
        };

    for (int i = 0; i < spatialOps.length; i++) {
      if (spatialOps[i].isAssignableFrom(filter.getClass())) {
        if (!fcs.supports(spatialOps[i])) {
          postStack.push(filter);
          return;
        } else {
          // fcs supports this filter, no need to check the rest
          break;
        }
      }
    }

    // TODO check against tranasaction ?

    int i = postStack.size();

    Expression leftGeometry, rightGeometry;
    leftGeometry = ((BinarySpatialOperator) filter).getExpression1();
    rightGeometry = ((BinarySpatialOperator) filter).getExpression2();

    if (leftGeometry == null || rightGeometry == null) {
      postStack.push(filter);
      return;
    }
    leftGeometry.accept(this, null);

    if (i < postStack.size()) {
      postStack.pop();
      postStack.push(filter);

      return;
    }

    rightGeometry.accept(this, null);

    if (i < postStack.size()) {
      preStack.pop(); // left
      postStack.pop();
      postStack.push(filter);

      return;
    }

    preStack.pop(); // left side
    preStack.pop(); // right side
    preStack.push(filter);
  }