Пример #1
0
    public void run() {

      try {
        for (int i = sessionList.size() - 1; i >= 0; i--) {
          Session session = (Session) sessionList.get(i);

          if (session.isClosed()) {
            synchronized (this) {
              sessionList.remove(i);
            }

            continue;
          }

          boolean result = session.timeoutManager.checkTimeout();
          /*
                              if (result) {
                                  synchronized (this) {
                                      sessionList.remove(i);
                                  }
                              }
          */
        }
      } catch (Throwable e) {

        // ignore exceptions
        // may be InterruptedException or IOException
      }
    }
  public OrderedHashSet getSubqueries() {

    OrderedHashSet set = null;

    if (joinCondition != null) {
      set = joinCondition.collectAllSubqueries(set);
    }

    if (rangeTable instanceof TableDerived) {
      QueryExpression queryExpression = ((TableDerived) rangeTable).getQueryExpression();

      if (queryExpression == null) {
        Expression dataExpression = ((TableDerived) rangeTable).getDataExpression();

        if (dataExpression != null) {
          if (set == null) {
            set = new OrderedHashSet();
          }

          OrderedHashSet.addAll(set, dataExpression.getSubqueries());
        }
      } else {
        OrderedHashSet temp = queryExpression.getSubqueries();

        set = OrderedHashSet.addAll(set, temp);
        set = OrderedHashSet.add(set, rangeTable);
      }
    }

    return set;
  }
  private Result getExplainResult(Session session) {

    Result result = Result.newSingleColumnStringResult("OPERATION", describe(session));
    OrderedHashSet set = getReferences();

    result.navigator.add(new Object[] {"Object References"});

    for (int i = 0; i < set.size(); i++) {
      HsqlName name = (HsqlName) set.get(i);

      result.navigator.add(new Object[] {name.getSchemaQualifiedStatementName()});
    }

    result.navigator.add(new Object[] {"Read Locks"});

    for (int i = 0; i < readTableNames.length; i++) {
      HsqlName name = readTableNames[i];

      result.navigator.add(new Object[] {name.getSchemaQualifiedStatementName()});
    }

    result.navigator.add(new Object[] {"WriteLocks"});

    for (int i = 0; i < writeTableNames.length; i++) {
      HsqlName name = writeTableNames[i];

      result.navigator.add(new Object[] {name.getSchemaQualifiedStatementName()});
    }

    return result;
  }
  OrderedHashSet getSubqueries() {

    OrderedHashSet set = null;

    if (joinCondition != null) {
      set = joinCondition.collectAllSubqueries(set);
    }

    if (rangeTable instanceof TableDerived) {
      QueryExpression baseQueryExpression = ((TableDerived) rangeTable).getQueryExpression();

      if (((TableDerived) rangeTable).view != null) {
        if (set == null) {
          set = new OrderedHashSet();
        }

        set.addAll(((TableDerived) rangeTable).view.getSubqueries());
      } else if (baseQueryExpression == null) {
        set = OrderedHashSet.add(set, rangeTable.getSubQuery());
      } else {
        OrderedHashSet temp = baseQueryExpression.getSubqueries();

        set = OrderedHashSet.addAll(set, temp);
        set = OrderedHashSet.add(set, rangeTable.getSubQuery());
      }
    }

    return set;
  }
Пример #5
0
  public OrderedHashSet getComponents() {

    OrderedHashSet set = new OrderedHashSet();

    set.addAll(routines);

    return set;
  }
Пример #6
0
  public OrderedHashSet getReferences() {

    OrderedHashSet set = new OrderedHashSet();

    for (int i = 0; i < routines.length; i++) {
      set.addAll(routines[i].getReferences());
    }

    return set;
  }
  /** Add all columns to a list of expressions */
  public void addTableColumns(HsqlArrayList exprList) {

    if (namedJoinColumns != null) {
      int count = exprList.size();
      int position = 0;

      for (int i = 0; i < count; i++) {
        Expression e = (Expression) exprList.get(i);
        String columnName = e.getColumnName();

        if (namedJoinColumns.contains(columnName)) {
          if (position != i) {
            exprList.remove(i);
            exprList.add(position, e);
          }

          e = getColumnExpression(columnName);

          exprList.set(position, e);

          position++;
        }
      }
    }

    addTableColumns(exprList, exprList.size(), namedJoinColumns);
  }
Пример #8
0
  public OrderedHashSet getReferences() {

    switch (constType) {
      case Constraint.CHECK:
        return schemaObjectNames;

      case Constraint.FOREIGN_KEY:
        OrderedHashSet set = new OrderedHashSet();

        set.add(core.uniqueName);

        return set;
    }

    return null;
  }
  protected void addTableColumns(Expression expression, int start, int count, HashSet exclude) {

    Table table = getTable();
    HsqlArrayList list = new HsqlArrayList();

    for (int i = start; i < start + count; i++) {
      ColumnSchema column = table.getColumn(i);
      String columnName =
          columnAliases == null ? column.getName().name : (String) columnAliases.get(i);

      if (exclude != null && exclude.contains(columnName)) {
        continue;
      }

      Expression e = new ExpressionColumn(this, i);

      list.add(e);
    }

    Expression[] nodes = new Expression[list.size()];

    list.toArray(nodes);

    expression.nodes = nodes;
  }
Пример #10
0
    public void addSession(Session session) {

      synchronized (this) {
        if (timerTask == null) {
          start();
        }

        sessionList.add(session);
      }
    }
  /**
   * Retruns index for column
   *
   * @param columnName name of column
   * @return int index or -1 if not found
   */
  private int findColumn(String columnName) {

    if (variables != null) {
      return variables.getIndex(columnName);
    } else if (columnAliases != null) {
      return columnAliases.getIndex(columnName);
    } else {
      return rangeTable.findColumn(columnName);
    }
  }
  public OrderedHashSet getUniqueColumnNameSet() {

    OrderedHashSet set = new OrderedHashSet();

    if (columnAliases != null) {
      set.addAll(columnAliases);

      return set;
    }

    for (int i = 0; i < rangeTable.columnList.size(); i++) {
      String name = rangeTable.getColumn(i).getName().name;
      boolean added = set.add(name);

      if (!added) {
        throw Error.error(ErrorCode.X_42578, name);
      }
    }

    return set;
  }
  /**
   * Retruns index for column
   *
   * @param columnName name of column
   * @return int index or -1 if not found
   */
  public int findColumn(String columnName) {

    if (namedJoinColumnExpressions != null && namedJoinColumnExpressions.containsKey(columnName)) {
      return -1;
    }

    if (variables != null) {
      return variables.getIndex(columnName);
    } else if (columnAliases != null) {
      return columnAliases.getIndex(columnName);
    } else {
      return rangeTable.findColumn(columnName);
    }
  }
Пример #14
0
    public void stop() {

      synchronized (this) {
        if (timerTask == null) {
          return;
        }

        HsqlTimer.cancel(timerTask);
        sessionList.clear();

        timerTask = null;
        sessionList = null;
      }
    }
  void setDatabseObjects(Session session, CompileContext compileContext) {

    parameters = compileContext.getParameters();

    setParameters();
    setParameterMetaData();

    subqueries = getSubqueries(session);
    rangeIteratorCount = compileContext.getRangeVarCount();
    rangeVariables = compileContext.getRangeVariables();
    sequences = compileContext.getSequences();
    routines = compileContext.getRoutines();

    OrderedHashSet set = new OrderedHashSet();

    collectTableNamesForWrite(set);

    if (set.size() > 0) {
      writeTableNames = new HsqlName[set.size()];

      set.toArray(writeTableNames);
      set.clear();
    }

    collectTableNamesForRead(set);
    set.removeAll(writeTableNames);

    if (set.size() > 0) {
      readTableNames = new HsqlName[set.size()];

      set.toArray(readTableNames);
    }

    references = compileContext.getSchemaObjectNames();

    if (targetTable != null) {
      references.add(targetTable.getName());
    }
  }
  public Object getSequenceValue(NumberSequence sequence) throws HsqlException {

    if (sequenceMap == null) {
      sequenceMap = new HashMap();
      sequenceUpdateSet = new OrderedHashSet();
    }

    HsqlName key = sequence.getName();
    Object value = sequenceMap.get(key);

    if (value == null) {
      value = sequence.getValueObject();

      sequenceMap.put(key, value);
      sequenceUpdateSet.add(sequence);
    }

    return value;
  }
Пример #17
0
  public OrderedHashSet getUnkeyedColumns(OrderedHashSet unresolvedSet) {

    for (int i = 0; i < nodes.length; i++) {
      if (nodes[i] == null) {
        continue;
      }

      unresolvedSet = nodes[i].getUnkeyedColumns(unresolvedSet);
    }

    if (opType == OpTypes.COLUMN && !rangeVariable.hasKeyedColumnInGroupBy) {
      if (unresolvedSet == null) {
        unresolvedSet = new OrderedHashSet();
      }

      unresolvedSet.add(this);
    }

    return unresolvedSet;
  }
  /** Add all columns to a list of expressions */
  public int addTableColumns(HsqlArrayList exprList, int position, HashSet exclude) {

    Table table = getTable();
    int count = table.getColumnCount();

    for (int i = 0; i < count; i++) {
      ColumnSchema column = table.getColumn(i);
      String columnName =
          columnAliases == null ? column.getName().name : (String) columnAliases.get(i);

      if (exclude != null && exclude.contains(columnName)) {
        continue;
      }

      Expression e = new ExpressionColumn(this, i);

      exprList.add(position++, e);
    }

    return position;
  }
  SubQuery[] getSubqueries(Session session) {

    OrderedHashSet subQueries = null;

    for (int i = 0; i < targetRangeVariables.length; i++) {
      if (targetRangeVariables[i] == null) {
        continue;
      }

      OrderedHashSet set = targetRangeVariables[i].getSubqueries();

      subQueries = OrderedHashSet.addAll(subQueries, set);
    }

    for (int i = 0; i < updateExpressions.length; i++) {
      subQueries = updateExpressions[i].collectAllSubqueries(subQueries);
    }

    if (insertExpression != null) {
      subQueries = insertExpression.collectAllSubqueries(subQueries);
    }

    if (condition != null) {
      subQueries = condition.collectAllSubqueries(subQueries);
    }

    if (queryExpression != null) {
      OrderedHashSet set = queryExpression.getSubqueries();

      subQueries = OrderedHashSet.addAll(subQueries, set);
    }

    if (subQueries == null || subQueries.size() == 0) {
      return SubQuery.emptySubqueryArray;
    }

    SubQuery[] subQueryArray = new SubQuery[subQueries.size()];

    subQueries.toArray(subQueryArray);
    ArraySort.sort(subQueryArray, 0, subQueryArray.length, subQueryArray[0]);

    for (int i = 0; i < subQueryArray.length; i++) {
      subQueryArray[i].prepareTable(session);
    }

    return subQueryArray;
  }
  // this fk references -> other  :  other read lock
  void collectTableNamesForRead(OrderedHashSet set) {

    for (int i = 0; i < rangeVariables.length; i++) {
      Table rangeTable = rangeVariables[i].rangeTable;
      HsqlName name = rangeTable.getName();

      if (rangeTable.isReadOnly() || rangeTable.isTemp()) {
        continue;
      }

      if (name.schema == SqlInvariants.SYSTEM_SCHEMA_HSQLNAME) {
        continue;
      }

      set.add(name);
    }

    for (int i = 0; i < subqueries.length; i++) {
      if (subqueries[i].queryExpression != null) {
        subqueries[i].queryExpression.getBaseTableNames(set);
      }
    }
  }
Пример #21
0
 public OrderedHashSet getReferences() {
   switch (this.constType) {
     case 3:
       OrderedHashSet localOrderedHashSet1 = new OrderedHashSet();
       this.check.collectObjectNames(localOrderedHashSet1);
       for (int i = localOrderedHashSet1.size() - 1; i >= 0; i--) {
         HsqlNameManager.HsqlName localHsqlName =
             (HsqlNameManager.HsqlName) localOrderedHashSet1.get(i);
         if ((localHsqlName.type == 9) || (localHsqlName.type == 3))
           localOrderedHashSet1.remove(i);
       }
       return localOrderedHashSet1;
     case 0:
       OrderedHashSet localOrderedHashSet2 = new OrderedHashSet();
       localOrderedHashSet2.add(this.core.uniqueName);
       return localOrderedHashSet2;
   }
   return new OrderedHashSet();
 }
  void moveConditionsToInner(Session session, RangeVariable[] ranges) {

    Expression[] colExpr;
    int exclude;
    HsqlArrayList conditionsList;
    Expression condition = null;

    if (whereConditions.length > 1) {
      return;
    }

    if (joinConditions.length > 1) {
      return;
    }

    for (int i = 0; i < ranges.length; i++) {
      if (ranges[i].isLeftJoin || ranges[i].isRightJoin) {
        return;
      }
    }

    exclude = ArrayUtil.find(ranges, this);
    conditionsList = new HsqlArrayList();

    addConditionsToList(conditionsList, joinConditions[0].indexCond);

    if (joinConditions[0].indexCond != null
        && joinConditions[0].indexCond[0] != joinConditions[0].indexEndCond[0]) {
      addConditionsToList(conditionsList, joinConditions[0].indexEndCond);
    }

    addConditionsToList(conditionsList, whereConditions[0].indexCond);
    addConditionsToList(conditionsList, whereConditions[0].indexEndCond);
    RangeVariableResolver.decomposeAndConditions(
        session, joinConditions[0].nonIndexCondition, conditionsList);
    RangeVariableResolver.decomposeAndConditions(
        session, whereConditions[0].nonIndexCondition, conditionsList);

    for (int i = conditionsList.size() - 1; i >= 0; i--) {
      Expression e = (Expression) conditionsList.get(i);

      if (e == null || e.isTrue() || e.hasReference(ranges, exclude)) {
        conditionsList.remove(i);

        continue;
      }
    }

    if (conditionsList.size() == 0) {
      if (rangeTable.isView()) {
        ((TableDerived) rangeTable).resetToView();
      }

      return;
    }

    QueryExpression queryExpression = rangeTable.getQueryExpression();

    colExpr = ((QuerySpecification) queryExpression).exprColumns;

    for (int i = 0; i < conditionsList.size(); i++) {
      Expression e = (Expression) conditionsList.get(i);
      OrderedHashSet set = e.collectRangeVariables(null);

      e = e.duplicate();
      e = e.replaceColumnReferences(this, colExpr);

      if (e.collectAllSubqueries(null) != null) {
        return;
      }

      if (set != null) {
        for (int j = 0; j < set.size(); j++) {
          RangeVariable range = (RangeVariable) set.get(j);

          if (this != range && range.rangeType == RangeVariable.TABLE_RANGE) {
            queryExpression.setCorrelated();
          }
        }
      }

      condition = ExpressionLogical.andExpressions(condition, e);
    }

    queryExpression.addExtraConditions(condition);
  }