コード例 #1
0
  /**
   * Recursive methods to create a {@link Function} starting from a {@link BinaryExpression} We
   * consider all possible values of the left and right expressions
   *
   * @param pred
   * @param lookupTable
   * @return
   */
  private Function getFunction(Expression pred, LookupTable lookupTable) {
    if (pred instanceof BinaryExpression) {
      return getFunction((BinaryExpression) pred, lookupTable);
    } else if (pred instanceof IsNullExpression) {
      return getFunction((IsNullExpression) pred, lookupTable);
    } else if (pred instanceof Parenthesis) {
      Expression inside = ((Parenthesis) pred).getExpression();
      return getFunction(inside, lookupTable);
    } else if (pred instanceof Between) {
      Between between = (Between) pred;
      Expression left = between.getLeftExpression();
      Expression e1 = between.getBetweenExpressionStart();
      Expression e2 = between.getBetweenExpressionEnd();

      GreaterThanEquals gte = new GreaterThanEquals();
      gte.setLeftExpression(left);
      gte.setRightExpression(e1);

      MinorThanEquals mte = new MinorThanEquals();
      mte.setLeftExpression(left);
      mte.setRightExpression(e2);

      AndExpression ande = new AndExpression(gte, mte);
      return getFunction(ande, lookupTable);
    } else if (pred instanceof InExpression) {
      InExpression inExpr = (InExpression) pred;
      Expression left = inExpr.getLeftExpression();
      ExpressionList ilist = (ExpressionList) inExpr.getRightItemsList();

      List<EqualsTo> eqList = new ArrayList<EqualsTo>();
      for (Expression item : ilist.getExpressions()) {
        EqualsTo eq = new EqualsTo();
        eq.setLeftExpression(left);
        eq.setRightExpression(item);
        eqList.add(eq);
      }
      int size = eqList.size();
      if (size > 1) {
        OrExpression or = new OrExpression(eqList.get(size - 1), eqList.get(size - 2));
        for (int i = size - 3; i >= 0; i--) {
          OrExpression orexpr = new OrExpression(eqList.get(i), or);
          or = orexpr;
        }
        return getFunction(or, lookupTable);
      } else {
        return getFunction(eqList.get(0), lookupTable);
      }
    } else return null;
  }
コード例 #2
0
    public void putLanMatchesOnStack(TermMap left, TermMap right) {
      EqualsTo eqExpr = new EqualsTo();
      // wrap into to_lowercase functions
      Function funcLeftLower = new Function();
      funcLeftLower.setName("LOWER");
      funcLeftLower.setParameters(new ExpressionList(Arrays.asList(left.getLiteralValString())));

      Function funcRightLower = new Function();
      funcRightLower.setName("LOWER");
      funcRightLower.setParameters(new ExpressionList(Arrays.asList(right.getLiteralValString())));

      eqExpr.setLeftExpression(funcLeftLower);
      eqExpr.setRightExpression(funcRightLower);

      tms.push(tmf.createBoolTermMap(eqExpr));
    }
コード例 #3
0
    private void putArithmeticOnStack(
        TermMap left, TermMap right, Class<? extends BinaryExpression> arithmeticOp) {
      try {
        BinaryExpression arithmetical = arithmeticOp.newInstance();
        arithmetical.setLeftExpression(DataTypeHelper.uncast(right.getLiteralValNumeric()));

        arithmetical.setRightExpression(DataTypeHelper.uncast(left.getLiteralValNumeric()));

        // for division we always return decimal
        if (arithmeticOp.equals(Division.class)) {
          Expression datatype =
              dth.cast(
                  new StringValue("'" + XSDDatatype.XSDdecimal.getURI() + "'"),
                  dth.getStringCastType());
          tms.push(tmf.createNumericalTermMap(arithmetical, datatype));
        } else {

          // determine the datatype

          if (optConf.isShortcutFilters()) {
            // check if we can determine the datatype of both parameters
            Expression dtLeft = DataTypeHelper.uncast(left.getLiteralType());
            Expression dtRight = DataTypeHelper.uncast(right.getLiteralType());
            if (DataTypeHelper.constantValueExpressions.contains(dtLeft.getClass())
                && DataTypeHelper.constantValueExpressions.contains(dtRight.getClass())) {
              if (dtLeft.toString().equals(dtRight.toString())) {
                // the same, so we use
                tms.push(tmf.createNumericalTermMap(arithmetical, dtLeft));
              } else {
                // we just use decimal
                Expression datatype =
                    dth.cast(
                        new StringValue("'" + XSDDatatype.XSDdecimal.getURI() + "'"),
                        dth.getStringCastType());
                tms.push(tmf.createNumericalTermMap(arithmetical, datatype));
              }

              return;
            }
          }

          // it was not possible to short, so create the dynamic datatype expression
          CaseExpression datatypeCase = new CaseExpression();

          WhenClause datatypeEquals = new WhenClause();
          EqualsTo datatypesAreEqualwhen = new EqualsTo();
          datatypesAreEqualwhen.setLeftExpression(left.getLiteralType());
          Expression datatypesEqualThen = left.getLiteralType();

          datatypeEquals.setWhenExpression(datatypesAreEqualwhen);
          datatypeEquals.setThenExpression(datatypesEqualThen);

          Expression elseDataType = new StringValue("'" + XSDDatatype.XSDdecimal.getURI() + "'");

          datatypeCase.setWhenClauses(Arrays.asList((Expression) datatypeEquals));

          datatypeCase.setElseExpression(elseDataType);

          tms.push(tmf.createNumericalTermMap(arithmetical, datatypeCase));
        }

      } catch (InstantiationException | IllegalAccessException e) {
        log.error("Error creating arithmetic operator", e);
      }
    }
コード例 #4
0
    @Override
    public void visit(ExprFunction1 func) {
      if (func instanceof E_Bound) {
        TermMap boundCheck = tms.pop();
        tms.push(translateIsBound(boundCheck));

      } else if (func instanceof E_LogicalNot) {
        TermMap notCheck = tms.pop();
        Expression bool = DataTypeHelper.uncast(notCheck.getLiteralValBool());
        if (bool instanceof IsNullExpression) {
          ((IsNullExpression) bool).setNot(!((IsNullExpression) bool).isNot());

        } else {
          Parenthesis parenthesis = new Parenthesis(bool);
          parenthesis.setNot();

          notCheck = tmf.createBoolTermMap(parenthesis);
        }

        tms.push(notCheck);

      } else if (func instanceof E_Lang) {
        TermMap langFunc = tms.pop();
        Expression lang = DataTypeHelper.uncast(langFunc.getLiteralLang());
        TermMap langTermMap = tmf.createStringTermMap(lang);
        tms.push(langTermMap);

      } else if (func instanceof E_Str) {
        TermMap strParam = tms.pop();

        // create the coalesce function here

        List<Expression> strExpressions = new ArrayList<Expression>();

        strExpressions.add(
            dth.cast(
                DataTypeHelper.uncast(strParam.getLiteralValBinary()), dth.getStringCastType()));
        strExpressions.add(
            dth.cast(DataTypeHelper.uncast(strParam.getLiteralValBool()), dth.getStringCastType()));
        strExpressions.add(
            dth.cast(DataTypeHelper.uncast(strParam.getLiteralValDate()), dth.getStringCastType()));
        strExpressions.add(
            dth.cast(
                DataTypeHelper.uncast(strParam.getLiteralValNumeric()), dth.getStringCastType()));
        strExpressions.add(
            dth.cast(
                DataTypeHelper.uncast(strParam.getLiteralValString()), dth.getStringCastType()));

        strExpressions.add(FilterUtil.concat(strParam.getExpressions().toArray(new Expression[0])));

        Expression toString = FilterUtil.coalesce(strExpressions.toArray(new Expression[0]));

        tms.push(tmf.createStringTermMap(toString));
      } else if (func instanceof E_IsBlank) {
        TermMap isBlank = tms.pop();
        EqualsTo eq = new EqualsTo();
        eq.setLeftExpression(isBlank.getTermType());
        eq.setRightExpression(new StringValue("'" + ColumnHelper.COL_VAL_TYPE_BLANK + "'"));
        tms.push(tmf.createBoolTermMap(eq));
      } else if (func instanceof E_IsIRI) {
        TermMap isIri = tms.pop();
        EqualsTo eq = new EqualsTo();
        eq.setLeftExpression(isIri.getTermType());
        eq.setRightExpression(new StringValue("'" + ColumnHelper.COL_VAL_TYPE_RESOURCE + "'"));
        tms.push(tmf.createBoolTermMap(eq));
      } else if (func instanceof E_IsLiteral) {
        TermMap isLiteral = tms.pop();
        EqualsTo eq = new EqualsTo();
        eq.setLeftExpression(isLiteral.getTermType());
        eq.setRightExpression(new StringValue("'" + ColumnHelper.COL_VAL_TYPE_LITERAL + "'"));
        tms.push(tmf.createBoolTermMap(eq));
      } else {
        throw new ImplementationException("Implement Conversion for " + func.toString());
      }
    }
コード例 #5
0
 @Override
 public void visit(EqualsTo et) {
   Table leftTable = visitSideEquals(et.getLeftExpression());
   Table rightTable = visitSideEquals(et.getRightExpression());
   _joinTablesExp.addEntry(leftTable, rightTable, et);
 }