Esempio n. 1
0
  @Override
  public Iterator<Item> findByMetadataQuery(
      Context context,
      List<List<MetadataField>> listFieldList,
      List<String> query_op,
      List<String> query_val,
      List<UUID> collectionUuids,
      String regexClause,
      int offset,
      int limit)
      throws SQLException {
    Criteria criteria = createCriteria(context, Item.class, "item");
    criteria.setFirstResult(offset);
    criteria.setMaxResults(limit);

    if (!collectionUuids.isEmpty()) {
      DetachedCriteria dcollCriteria = DetachedCriteria.forClass(Collection.class, "coll");
      dcollCriteria.setProjection(Projections.property("coll.id"));
      dcollCriteria.add(Restrictions.eqProperty("coll.id", "item.owningCollection"));
      dcollCriteria.add(Restrictions.in("coll.id", collectionUuids));
      criteria.add(Subqueries.exists(dcollCriteria));
    }

    int index = Math.min(listFieldList.size(), Math.min(query_op.size(), query_val.size()));
    StringBuilder sb = new StringBuilder();

    for (int i = 0; i < index; i++) {
      OP op = OP.valueOf(query_op.get(i));
      if (op == null) {
        log.warn("Skipping Invalid Operator: " + query_op.get(i));
        continue;
      }

      if (op == OP.matches || op == OP.doesnt_match) {
        if (regexClause.isEmpty()) {
          log.warn("Skipping Unsupported Regex Operator: " + query_op.get(i));
          continue;
        }
      }

      DetachedCriteria subcriteria = DetachedCriteria.forClass(MetadataValue.class, "mv");
      subcriteria.add(Property.forName("mv.dSpaceObject").eqProperty("item.id"));
      subcriteria.setProjection(Projections.property("mv.dSpaceObject"));

      if (!listFieldList.get(i).isEmpty()) {
        subcriteria.add(Restrictions.in("metadataField", listFieldList.get(i)));
      }

      sb.append(op.name() + " ");
      if (op == OP.equals || op == OP.not_equals) {
        subcriteria.add(Property.forName("mv.value").eq(query_val.get(i)));
        sb.append(query_val.get(i));
      } else if (op == OP.like || op == OP.not_like) {
        subcriteria.add(Property.forName("mv.value").like(query_val.get(i)));
        sb.append(query_val.get(i));
      } else if (op == OP.contains || op == OP.doesnt_contain) {
        subcriteria.add(Property.forName("mv.value").like("%" + query_val.get(i) + "%"));
        sb.append(query_val.get(i));
      } else if (op == OP.matches || op == OP.doesnt_match) {
        subcriteria.add(
            Restrictions.sqlRestriction(regexClause, query_val.get(i), StandardBasicTypes.STRING));
        sb.append(query_val.get(i));
      }

      if (op == OP.exists
          || op == OP.equals
          || op == OP.like
          || op == OP.contains
          || op == OP.matches) {
        criteria.add(Subqueries.exists(subcriteria));
      } else {
        criteria.add(Subqueries.notExists(subcriteria));
      }
    }
    log.debug(String.format("Running custom query with %d filters", index));

    return list(criteria).iterator();
  }
Esempio n. 2
0
 public Object eval() throws Exception {
   Object o = OP.doHardOP(expr);
   if (!(o instanceof String)) throw new RTException("CastException", "REG2ORA");
   return reg2ora((String) o);
 }
Esempio n. 3
0
  /** Метод возвращает следующую лексему */
  public void next() throws Exception {
    int state = SS; // начинаем со стартового состояния :)
    mystring = new StringBuffer();
    if (GLOBAL.calc_debug > 26) System.out.println("~clac.Lexemator::next : begin parsing");
    try { // отлавливаем конец потока символов
      char ch = text[counter];
      while (true) { // цикл по символам
        if (ch == '$') {
          ch = text[++counter];
          state = STAG;
        }
        if (GLOBAL.calc_debug > 26)
          System.out.println(
              "~clac.Lexemator::next : state=" + states[state] + ":" + counter + ":" + ch);
        switch (state) { // витвление по состоянию автомата
            // start ---------------------------------------------------
          case SS: // стартовое состояние
            // крутимся пока не начнется лексема
            if (is_DIL(ch)) { // если разделитель
              state = SS; // опять на старт
              ch = text[++counter];
            }
            // началась лексема
            // проверим на операцию
            else if (is_op(ch)) state = SOP; // операция
            else if (is_AZ(ch)) state = SAZ; // идентификатор
            // проверим на начало строки
            else if (ch == '\'') state = SSTR; // строка
            // проверим на начало выражения
            else if (is_OBK(ch)) {
                /* ( */
              ++counter;
              mystring = readExpr();
              ch = text[counter];
              state = SF;
              mytype = LEXPR;
            }
            // проверим на число
            else if (is_NUM(ch)) state = SNUM; // число
            else { // что-то непонятное
              ch = text[counter++];
              throw new ResonException("Lexemator: '" + ch + "'");
            }
            break;
            // Разбор идентификатора или метки --------------------------------------
          case SAZ: // идентификатор
            while (is_AZ(ch) || is_NUM(ch)) {
              // пока символы алфавита
              mystring.append(ch); // добавить в строку резалта
              ch = text[++counter];
            }
            if (ch == ':') {
              op = new LABEL(mystring.toString());
              mytype = LOP;
              state = SF;
              ch = text[++counter];
            } else if (is_XDIL(ch)) { // конец идентификатора
              mytype = LDEF;
              state = SF; // финиш
            } else throw new ResonException("Lexemator: '" + ch + "'");
            break;
            // Разбор тега   -------------------------------------------
          case STAG: // тег
            while (is_AZ(ch) || is_NUM(ch) || (ch == '(')) {
              // пока символы алфавита
              if (ch == '(') {
                ++counter;
                mystring.append("(" + readExpr() + ")");
                --counter;
              } else mystring.append(ch); // добавить в строку резалта
              ch = text[++counter];
            }
            if (is_XDIL(ch)) { // конец ТЕГА
              mytype = LTAG;
              state = SF; // финиш
            } else throw new ResonException("Lexemator: '" + ch + "'");
            args = new String(text, counter, text.length - counter);
            if (GLOBAL.calc_debug > 2)
              System.out.println("~clac.Lexemator::next : TAG " + mystring + "args " + args);
            counter = text.length;
            break;
            // Разбор числа ----------------------------------------------------
          case SNUM: // число
            while (is_NUM(ch)) {
              // пока цифры
              mystring.append(ch); // добавить в строку резалта
              ch = text[++counter];
            }
            if (is_XDIL(ch)) {
              mytype = LNUM;
              state = SF; // финиш
              break;
            } else if (ch == '.') {
              mystring.append(".");
              ch = text[++counter];
              while (is_NUM(ch)) { // пока цифры
                mystring.append(ch); // добавить в строку резалта
                ch = text[++counter];
              }
              if (is_XDIL(ch)) { // конец числа
                mytype = LNUM;
                state = SF; // финиш
                break;
              }
            }
            throw new ResonException("Lexemator: '" + ch + "'");
            // Разбор операции  ----------------------------------------------------
          case SOP:
            op = OP.getOP(ch, text[counter + 1]);
            if (op != null) {
              counter += 2;
              ch = text[counter];
            } else if ((op = OP.getOP(ch)) != null) {
              ch = text[++counter];
            } else throw new ResonException("Lexemator: Bad Operation '" + ch + "'");
            mytype = LOP;
            state = SF;
            mystring = new StringBuffer(op.toString());
            break;

            // Разбор строки  ----------------------------------------------------
          case SSTR: // разбор строки
            ch = text[++counter];
            while (ch != '\'') { // пока не конец строки
              if (ch == '\\') {
                ch = text[++counter];
                switch (ch) {
                  case 't':
                  case 'T':
                    ch = '\t';
                    break;
                  case 'n':
                  case 'N':
                    ch = '\n';
                    break;
                  case 'b':
                  case 'B':
                    ch = '\b';
                    break;
                  case 'e':
                  case 'E':
                    ch = '\033';
                    break;
                }
              }
              mystring.append(ch); // записываем символы строки
              ch = text[++counter];
            }
            mytype = LSTR;
            state = SF; // финиш
            ++counter;
            break;
            // stop -----------------------------------------------------------
          case SF: // ФИНИШ
            if (GLOBAL.calc_debug > 26)
              System.out.println(
                  "~clac.Lexemator::"
                      + GLOBAL.PRINT_LIGHT
                      + lextypes[mytype]
                      + ":"
                      + as_string()
                      + GLOBAL.PRINT_NORMAL
                      + "\n");
            return;

            // error ??  -----------------------------------------------------------
          default:
            throw new Exception("Lexemator: !!!! UNCKNOWN STATE ????");
        }
      }

    } catch (ArrayIndexOutOfBoundsException e) {
      // e.printStackTrace();
      mytype = LEND;
      return;
    }
  }