Esempio n. 1
0
 private void queryFlat(int columnCount, ResultTarget result, long limitRows) {
   // limitRows must be long, otherwise we get an int overflow
   // if limitRows is at or near Integer.MAX_VALUE
   // limitRows is never 0 here
   if (limitRows > 0 && offsetExpr != null) {
     int offset = offsetExpr.getValue(session).getInt();
     if (offset > 0) {
       limitRows += offset;
     }
   }
   int rowNumber = 0;
   setCurrentRowNumber(0);
   ArrayList<Row> forUpdateRows = null;
   if (isForUpdateMvcc) {
     forUpdateRows = New.arrayList();
   }
   while (topTableFilter.next()) {
     setCurrentRowNumber(rowNumber + 1);
     if (condition == null || Boolean.TRUE.equals(condition.getBooleanValue(session))) {
       Value[] row = new Value[columnCount];
       for (int i = 0; i < columnCount; i++) {
         Expression expr = expressions.get(i);
         row[i] = expr.getValue(session);
       }
       if (isForUpdateMvcc) {
         topTableFilter.lockRowAdd(forUpdateRows);
       }
       result.addRow(row);
       rowNumber++;
       if ((sort == null || sortUsingIndex)
           && limitRows > 0
           && result.getRowCount() >= limitRows) {
         break;
       }
       if (sampleSize > 0 && rowNumber >= sampleSize) {
         break;
       }
     }
   }
   if (isForUpdateMvcc) {
     topTableFilter.lockRows(forUpdateRows);
   }
 }
Esempio n. 2
0
  private void queryGroupSorted(int columnCount, ResultTarget result) {
    int rowNumber = 0;
    setCurrentRowNumber(0);
    Value[] previousKeyValues = null;
    while (topTableFilter.next()) {
      setCurrentRowNumber(rowNumber + 1);
      if (condition == null || Boolean.TRUE.equals(condition.getBooleanValue(session))) {
        rowNumber++;
        Value[] keyValues = new Value[groupIndex.length];
        // update group
        for (int i = 0; i < groupIndex.length; i++) {
          int idx = groupIndex[i];
          Expression expr = expressions.get(idx);
          keyValues[i] = expr.getValue(session);
        }

        if (previousKeyValues == null) {
          previousKeyValues = keyValues;
          currentGroup = New.hashMap();
        } else if (!Arrays.equals(previousKeyValues, keyValues)) {
          addGroupSortedRow(previousKeyValues, columnCount, result);
          previousKeyValues = keyValues;
          currentGroup = New.hashMap();
        }
        currentGroupRowId++;

        for (int i = 0; i < columnCount; i++) {
          if (groupByExpression == null || !groupByExpression[i]) {
            Expression expr = expressions.get(i);
            expr.updateAggregate(session);
          }
        }
      }
    }
    if (previousKeyValues != null) {
      addGroupSortedRow(previousKeyValues, columnCount, result);
    }
  }
Esempio n. 3
0
 @Override
 public int update() {
   tableFilter.startQuery(session);
   tableFilter.reset();
   Table table = tableFilter.getTable();
   session.getUser().checkRight(table, Right.DELETE);
   table.fire(session, Trigger.DELETE, true);
   // 直到事务commit或rollback时才解琐,见org.h2.engine.Session.unlockAll()
   table.lock(session, true, false);
   RowList rows = new RowList(session);
   int limitRows = -1;
   if (limitExpr != null) {
     Value v = limitExpr.getValue(session);
     if (v != ValueNull.INSTANCE) {
       limitRows = v.getInt();
     }
   }
   try {
     setCurrentRowNumber(0);
     int count = 0;
     // 比如delete from DeleteTest limit 0,
     // 此时limitRows为0,不删除任何行
     while (limitRows != 0 && tableFilter.next()) {
       setCurrentRowNumber(rows.size() + 1);
       // condition.getBooleanValue(session)内部会取当前行与之比较,
       // 比如,如果是ExpressionColumn,那么就由它对应的列,取得列id,
       // 然后在从当前行中按列id取当前行value数组中对应元素
       if (condition == null || Boolean.TRUE.equals(condition.getBooleanValue(session))) {
         Row row = tableFilter.get();
         boolean done = false;
         if (table.fireRow()) {
           done = table.fireBeforeRow(session, row, null);
         }
         if (!done) {
           rows.add(row);
         }
         count++;
         if (limitRows >= 0 && count >= limitRows) {
           break;
         }
       }
     }
     int rowScanCount = 0;
     for (rows.reset(); rows.hasNext(); ) {
       if ((++rowScanCount & 127) == 0) {
         checkCanceled();
       }
       Row row = rows.next();
       table.removeRow(session, row);
       session.log(table, UndoLogRecord.DELETE, row);
     }
     if (table.fireRow()) {
       for (rows.reset(); rows.hasNext(); ) {
         Row row = rows.next();
         table.fireAfterRow(session, row, null, false);
       }
     }
     table.fire(session, Trigger.DELETE, false);
     return count;
   } finally {
     rows.close();
   }
 }
Esempio n. 4
0
 private void queryGroup(int columnCount, LocalResult result) {
   ValueHashMap<HashMap<Expression, Object>> groups = ValueHashMap.newInstance();
   int rowNumber = 0;
   setCurrentRowNumber(0);
   ValueArray defaultGroup = ValueArray.get(new Value[0]);
   while (topTableFilter.next()) {
     setCurrentRowNumber(rowNumber + 1);
     if (condition == null || Boolean.TRUE.equals(condition.getBooleanValue(session))) {
       Value key;
       rowNumber++;
       if (groupIndex == null) {
         key = defaultGroup;
       } else {
         Value[] keyValues = new Value[groupIndex.length];
         // update group
         for (int i = 0; i < groupIndex.length; i++) {
           int idx = groupIndex[i];
           Expression expr = expressions.get(idx);
           keyValues[i] = expr.getValue(session);
         }
         key = ValueArray.get(keyValues);
       }
       HashMap<Expression, Object> values = groups.get(key);
       if (values == null) {
         values = new HashMap<Expression, Object>();
         groups.put(key, values);
       }
       currentGroup = values;
       currentGroupRowId++;
       int len = columnCount;
       for (int i = 0; i < len; i++) {
         if (groupByExpression == null || !groupByExpression[i]) {
           Expression expr = expressions.get(i);
           expr.updateAggregate(session);
         }
       }
       if (sampleSize > 0 && rowNumber >= sampleSize) {
         break;
       }
     }
   }
   if (groupIndex == null && groups.size() == 0) {
     groups.put(defaultGroup, new HashMap<Expression, Object>());
   }
   ArrayList<Value> keys = groups.keys();
   for (Value v : keys) {
     ValueArray key = (ValueArray) v;
     currentGroup = groups.get(key);
     Value[] keyValues = key.getList();
     Value[] row = new Value[columnCount];
     for (int j = 0; groupIndex != null && j < groupIndex.length; j++) {
       row[groupIndex[j]] = keyValues[j];
     }
     for (int j = 0; j < columnCount; j++) {
       if (groupByExpression != null && groupByExpression[j]) {
         continue;
       }
       Expression expr = expressions.get(j);
       row[j] = expr.getValue(session);
     }
     if (isHavingNullOrFalse(row)) {
       continue;
     }
     row = keepOnlyDistinct(row, columnCount);
     result.addRow(row);
   }
 }