queryparser.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 2,704 行 · 第 1/5 页

                }
              }
            }

            expr = LoadExpr.create(pathExpr, rootItem);

            expr = expr.bindSelect(this);
          }
        }

        resultList.add(expr);
      } while ((token = scanToken()) == ',');

      query.setHasFrom(hasFrom);

      if (hasFrom && (constructorName != null)) {

        if (token != ')')
          throw error(L.l("Expected ')' at {0} when calling constructor with SELECT NEW", tokenName(token)));

        token = scanToken();

        try {

          ClassLoader loader = Thread.currentThread().getContextClassLoader();

          Class cl = Class.forName(constructorName, false, loader);

          query.setConstructorClass(cl);

        } catch (ClassNotFoundException ex) {
          throw error(L.l("Unable to find class {0}. Make sure the class is fully qualified.", constructorName));
        }
      }

      _token = token;
    }

    if (hasFrom && (peekToken() != FROM))
      throw error(L.l("expected FROM at {0}", tokenName(token)));

    if (resultList.size() == 0) {

      if (_joinFetchMap.size() > 0)
        throw error(L.l("All associations referenced by JOIN FETCH must belong to an entity that is returned as a result of the query"));

      ArrayList<FromItem> fromList = _query.getFromList();

      if (fromList.size() > 0) {
        FromItem fromItem = fromList.get(0);

        AmberExpr expr = fromItem.getIdExpr();

        if (_isLazyResult) {
        }
        else if (expr instanceof PathExpr) {
          PathExpr pathExpr = (PathExpr) expr;

          expr = LoadExpr.create(pathExpr);
          expr = expr.bindSelect(this);
        }

        resultList.add(expr);
      }
    }
    else if (hasFrom) {

      int size = resultList.size();

      int matches = 0;

      for (int i = 0; i < size; i++) {

        AmberExpr expr = resultList.get(i);

        if (expr instanceof LoadEntityExpr) {

          expr = ((LoadEntityExpr) expr).getExpr();

          if (_joinFetchMap.get(expr) != null) {
            matches++;
          }
        }
      }

      if (matches < _joinFetchMap.size())
        throw error(L.l("All associations referenced by JOIN FETCH must belong to an entity that is returned as a result of the query"));

    }

    // jpa/1199
    if (_appendResultList != null)
      resultList.addAll(_appendResultList);

    query.setResultList(resultList);

    _parsingResult = false;

    _parseIndex = fromParseIndex;
    _token = fromToken;

    token = peekToken();

    boolean hasWhere = false;

    if (token == WHERE) {
      scanToken();

      hasWhere = true;

      AmberExpr expr = parseExpr();

      // jpa/119l: WHERE SIZE() is moved to HAVING COUNT()
      if (expr != null) {
        expr = expr.createBoolean();

        query.setWhere(expr.bindSelect(this));
      }
    }

    boolean hasGroupBy = false;

    ArrayList<AmberExpr> groupList = _groupList;

    token = peekToken();
    if (token == GROUP) {
      scanToken();

      if (peekToken() == BY) {
        scanToken();
        hasGroupBy = true;
      }

      if (groupList == null)
        groupList = new ArrayList<AmberExpr>();

      while (true) {
        // jpa/0w23
        AmberExpr groupExpr = parseExpr();

        groupExpr = groupExpr.bindSelect(this);

        if (groupExpr instanceof PathExpr) {
          // jpa/119n

          PathExpr pathExpr = (PathExpr) groupExpr;

          groupExpr = LoadExpr.create(pathExpr);

          groupExpr = groupExpr.bindSelect(this);
        }

        groupList.add(groupExpr);

        if (peekToken() == ',')
          scanToken();
        else
          break;
      }

      query.setGroupList(groupList);

      // Reset temp group list after parsing subselect.
      _groupList = null;
    }

    token = peekToken();
    if (token == HAVING) {

      if (! hasGroupBy)
        throw error(L.l("Use of HAVING without GROUP BY is not currently supported"));

      _parsingHaving = true;

      scanToken();

      AmberExpr havingExpr = parseExpr();

      // jpa/119l: SIZE()
      if (_havingExpr != null)
        havingExpr = AndExpr.create(havingExpr, _havingExpr);

      query.setHaving(havingExpr.createBoolean().bindSelect(this));

      _parsingHaving = false;
    }
    else if (hasWhere && _havingExpr != null) { // jpa/1199, jpa/119l
      query.setHaving(_havingExpr.createBoolean().bindSelect(this));
    }

    token = peekToken();
    if (token == ORDER) {
      scanToken();

      if (peekToken() == BY)
        scanToken();

      ArrayList<AmberExpr> orderList = new ArrayList<AmberExpr>();
      ArrayList<Boolean> ascList = new ArrayList<Boolean>();

      while (true) {
        AmberExpr expr = parseExpr();

        // jpa/1114
        if (isCollectionExpr(expr))
          throw error(L.l("Unexpected collection at ORDER BY '{0}'.",
                          expr.getClass().getName()));

        expr = expr.bindSelect(this);

        orderList.add(expr);

        if (peekToken() == DESC) {
          scanToken();
          ascList.add(Boolean.FALSE);
        }
        else if (peekToken() == ASC) {
          scanToken();
          ascList.add(Boolean.TRUE);
        }
        else
          ascList.add(Boolean.TRUE);

        if (peekToken() == ',')
          scanToken();
        else
          break;
      }

      query.setOrderList(orderList, ascList);
    }

    token = peekToken();

    if (token == OFFSET) {
      scanToken();

      token = scanToken();
      if (token != INTEGER)
        throw error(L.l("Expected INTEGER at {0}", tokenName(token)));

      int offset = Integer.parseInt(_lexeme);

      token = peekToken();

      query.setOffset(offset);
    }

    if (token == LIMIT) {
      scanToken();

      token = scanToken();
      if (token != INTEGER)
        throw error(L.l("Expected INTEGER at {0}", tokenName(token)));

      int limit = Integer.parseInt(_lexeme);
      query.setLimit(limit);

      token = peekToken();
    }

    if (! innerSelect) {
      query.setJoinFetchMap(_joinFetchMap);

      if (token > 0)
        throw error(L.l("expected end of query at {0}", tokenName(token)));

      if (! query.setArgList(_argList.toArray(new ArgExpr[_argList.size()])))
        throw error(L.l("Unable to parse all query parameters. Make sure named parameters are not mixed with positional parameters"));

    }

    query.init();

    _joinSemantics = oldJoinSemantics;
    _isJoinFetch = oldIsJoinFetch;
    _query = oldQuery;
    _depth = oldDepth;
    _havingExpr = oldHavingExpr;
    _appendResultList = oldAppendResultList;

    return query;
  }

  private AbstractQuery parseUpdate()
    throws QueryParseException
  {
    UpdateQuery query = new UpdateQuery(_sql, getMetaData());
    _query = query;

    FromItem fromItem = parseFrom();

    int token = scanToken();
    if (token != SET)
      throw error(L.l("expected 'SET' at {0}", tokenName(token)));

    ArrayList<AmberExpr> fields = new ArrayList<AmberExpr>();
    ArrayList<AmberExpr> values = new ArrayList<AmberExpr>();

    parseSetValues(fromItem, fields, values);

    query.setFieldList(fields);
    query.setValueList(values);

    token = scanToken();
    if (token == WHERE) {
      AmberExpr expr = parseExpr();

      query.setWhere(expr.createBoolean().bindSelect(this));

      token = scanToken();
    }

    if (token >= 0)
      throw error(L.l("'{0}' not expected at end of query.", tokenName(token)));

    if (! query.setArgList(_argList.toArray(new ArgExpr[_argList.size()])))
      throw error(L.l("Unable to parse all query parameters. Make sure named parameters are not mixed with positional parameters"));

    query.init();

    return query;
  }

  private AbstractQuery parseDelete()
    throws QueryParseException
  {
    DeleteQuery query = new DeleteQuery(_sql, getMetaData());
    _query = query;

    int token = peekToken();
    if (token == FROM)
      scanToken();

    FromItem fromItem = parseFrom();

    token = scanToken();
    if (token == WHERE) {
      query.setWhere(parseExpr().createBoolean().bindSelect(this));

      token = scanToken();
    }

    if (token >= 0)
      throw error(L.l("'{0}' not expected at end of query.", tokenName(token)));

    if (! query.setArgList(_argList.toArray(new ArgExpr[_argList.size()])))
      throw error(L.l("Unable to parse all query parameters. Make sure named parameters are not mixed with positional parameters"));

    query.init();

    return query;
  }

  /**
   * Parses the set values.
   */
  private void parseSetValues(FromItem fromItem,
                              ArrayList<AmberExpr> fields,
                              ArrayList<AmberExpr> values)
    throws QueryParseException
  {
    EntityType entity = fromItem.getEntityType();

    int token = -1;

    do {

      token = scanToken();

      AmberExpr expr = null;

      String name = _lexeme.toString();

      IdExpr tableExpr = getIdentifier(name);

      if (tableExpr != null) {
        expr = parsePath(tableExpr);
      }
      else {

        tableExpr = fromItem.getIdExpr();

        AmberExpr next = tableExpr.createField(this, name);

        if (next instanceof PathExpr)
          expr = addPath((PathExpr) next);
        else if (next != null)
          expr = next;
      }

      expr = expr.bindSelect(this);

      fields.add(expr);

      if ((token = peekToken()) != EQ)
        throw error(L.l("expected '=' at {0}", tokenName(token)));

      scanToken();

      // jpa/1222 expr = parseSimpleTerm();
      expr = parseConcatExpr();

      if (expr.hasRelationship())
        throw error(L.l("UPDATE cannot set values with relationships. Unexpected path expression at {0}", expr));

      expr = expr.bindSelect(this);

      values.add(expr);

    } while ((token = scanToken()) == ',');

    _token = token;
  }

  /**
   * Parses the FROM block.  parseFrom's effect is to populate the
   * core identifiers.
   *
   * <pre>
   * from-item ::= schema AS? IDENTIFIER
   * </pre>
   */
  private FromItem parseFrom()
    throws QueryParseException
  {
    SchemaExpr schema = parseSchema();

    String id;

    int token = peekToken();
    if (token == AS) {
      scanToken();
      token = peekToken();
      id = parseIdentifier();
    }
    else if (token == IDENTIFIER)
      id = parseIdentifier();
    else {
      // jpa/116c
      if (schema instanceof OneToManySchemaExpr)
        id = createTableName();
      else
        id = schema.getTailName();
    }

    /*
      AmberEntityHome home = _persistenceUnit.getHomeBySchema(schema);

      if (home == null)
      throw error(L.l("`{0}' is an unknown persistent class.",
      schema));
    */

    FromItem item = schema.addFromItem(this, id);

    if (schema instanceof EmbeddedSchemaExpr) {

      // jpa/0w22

      EmbeddedSchemaExpr embeddedSchema = (EmbeddedSchemaExpr) schema;

      _query.addEmbeddedAlias(id, embeddedSchema.getExpr()); // pathString);
    }

    // jpa/114h
    item.setJoinSemantics(_joinSemantics);

    return item;
  }

  /**
   * Adds a new FromItem.
   */
  public FromItem addFromItem(AmberTable table)
  {
    return addFromItem(null, table, createTableName());
  }

  /**
   * Adds a new FromItem.
   */
  public FromItem addFromItem(EntityType entityType,
                              AmberTable table)
  {
    return addFromItem(entityType, table, createTableName());
  }

  /**
   * Returns a unique table name
   */
  public String createTableName()
  {
    return "caucho" + _unique++;
  }

  /**
   * Adds a new FromItem.
   */
  public FromItem addFromItem(AmberTable table, String id)
  {
    return addFromItem(null, table, id);
  }

  /**
   * Adds a new FromItem.
   */
  public FromItem addFromItem(EntityType entityType,
                              AmberTable table,
                              String id)
  {
    if (id == null)
      id = createTableName();

    FromItem item = _query.createFromItem(entityType, table, id);

    item.setJoinSemantics(_joinSemantics);

    return item;
  }

  /**
   * Adds a new FromItem.
   */
  public FromItem createDependentFromItem(FromItem item,
                                          LinkColumns link)
  {
    item = _query.createDependentFromItem(item, link, createTableName());

    item.setJoinSemantics(_joinSemantics);

    return item;
  }

  /**
   * Adds a new link
   */
  void addLink(AmberExpr expr)
  {
    // _andExpr.add(expr);
    throw new IllegalStateException();