コード例 #1
0
 private void appendScanRow(StringBuilder buf, Bound bound) {
   ScanRanges scanRanges = context.getScanRanges();
   KeyRange minMaxRange = context.getMinMaxRange();
   Iterator<byte[]> minMaxIterator = Iterators.emptyIterator();
   if (minMaxRange != null) {
     RowKeySchema schema = tableRef.getTable().getRowKeySchema();
     if (!minMaxRange.isUnbound(bound)) {
       minMaxIterator = new RowKeyValueIterator(schema, minMaxRange.getRange(bound));
     }
   }
   int nRanges = scanRanges.getRanges().size();
   for (int i = 0, minPos = 0; minPos < nRanges || minMaxIterator.hasNext(); i++) {
     List<KeyRange> ranges = minPos >= nRanges ? EVERYTHING : scanRanges.getRanges().get(minPos++);
     KeyRange range = bound == Bound.LOWER ? ranges.get(0) : ranges.get(ranges.size() - 1);
     byte[] b = range.getRange(bound);
     Boolean isNull =
         KeyRange.IS_NULL_RANGE == range
             ? Boolean.TRUE
             : KeyRange.IS_NOT_NULL_RANGE == range ? Boolean.FALSE : null;
     if (minMaxIterator.hasNext()) {
       byte[] bMinMax = minMaxIterator.next();
       int cmp = Bytes.compareTo(bMinMax, b) * (bound == Bound.LOWER ? 1 : -1);
       if (cmp > 0) {
         minPos = nRanges;
         b = bMinMax;
         isNull = null;
       } else if (cmp < 0) {
         minMaxIterator = Iterators.emptyIterator();
       }
     }
     appendPKColumnValue(buf, b, isNull, i);
     buf.append(',');
   }
 }
コード例 #2
0
ファイル: ScanUtil.java プロジェクト: hzg0102/phoenix
 public static boolean forceRowKeyOrder(StatementContext context) {
   return context
       .getConnection()
       .getQueryServices()
       .getProps()
       .getBoolean(
           QueryServices.FORCE_ROW_KEY_ORDER_ATTRIB,
           QueryServicesOptions.DEFAULT_FORCE_ROW_KEY_ORDER);
 }
コード例 #3
0
 private void appendKeyRanges(StringBuilder buf) {
   ScanRanges scanRanges = context.getScanRanges();
   KeyRange minMaxRange = context.getMinMaxRange();
   if (minMaxRange == null
       && (scanRanges == ScanRanges.EVERYTHING || scanRanges == ScanRanges.NOTHING)) {
     return;
   }
   buf.append(" [");
   StringBuilder buf1 = new StringBuilder();
   appendScanRow(buf1, Bound.LOWER);
   buf.append(buf1);
   buf.setCharAt(buf.length() - 1, ']');
   StringBuilder buf2 = new StringBuilder();
   appendScanRow(buf2, Bound.UPPER);
   if (!StringUtil.equals(buf1, buf2)) {
     buf.append(" - [");
     buf.append(buf2);
   }
   buf.setCharAt(buf.length() - 1, ']');
 }
コード例 #4
0
ファイル: ScanUtil.java プロジェクト: hzg0102/phoenix
 public static boolean isRoundRobinPossible(OrderBy orderBy, StatementContext context)
     throws SQLException {
   int fetchSize = context.getStatement().getFetchSize();
   /*
    * Selecting underlying scanners in a round-robin fashion is possible if there is no ordering of rows needed,
    * not even row key order. Also no point doing round robin of scanners if fetch size
    * is 1.
    */
   return fetchSize > 1
       && !shouldRowsBeInRowKeyOrder(orderBy, context)
       && orderBy.getOrderByExpressions().isEmpty();
 }
コード例 #5
0
 private void appendPKColumnValue(StringBuilder buf, byte[] range, Boolean isNull, int slotIndex) {
   if (Boolean.TRUE.equals(isNull)) {
     buf.append("null");
     return;
   }
   if (Boolean.FALSE.equals(isNull)) {
     buf.append("not null");
     return;
   }
   if (range.length == 0) {
     buf.append('*');
     return;
   }
   ScanRanges scanRanges = context.getScanRanges();
   PDataType type = scanRanges.getSchema().getField(slotIndex).getDataType();
   ColumnModifier modifier = tableRef.getTable().getPKColumns().get(slotIndex).getColumnModifier();
   if (modifier != null) {
     buf.append('~');
     range = modifier.apply(range, 0, new byte[range.length], 0, range.length);
   }
   Format formatter = context.getConnection().getFormatter(type);
   buf.append(type.toStringLiteral(range, formatter));
 }
コード例 #6
0
 public DegenerateQueryPlan(
     StatementContext context, FilterableStatement statement, TableRef table) {
   super(
       context,
       statement,
       table,
       RowProjector.EMPTY_PROJECTOR,
       PhoenixParameterMetaData.EMPTY_PARAMETER_META_DATA,
       null,
       OrderBy.EMPTY_ORDER_BY,
       GroupBy.EMPTY_GROUP_BY,
       null);
   context.setScanRanges(ScanRanges.NOTHING);
 }
コード例 #7
0
 public SortMergeJoinPlan(
     StatementContext context,
     FilterableStatement statement,
     TableRef table,
     JoinType type,
     QueryPlan lhsPlan,
     QueryPlan rhsPlan,
     List<Expression> lhsKeyExpressions,
     List<Expression> rhsKeyExpressions,
     PTable joinedTable,
     PTable lhsTable,
     PTable rhsTable,
     int rhsFieldPosition,
     boolean isSingleValueOnly) {
   if (type == JoinType.Right)
     throw new IllegalArgumentException("JoinType should not be " + type);
   this.context = context;
   this.statement = statement;
   this.table = table;
   this.type = type;
   this.lhsPlan = lhsPlan;
   this.rhsPlan = rhsPlan;
   this.lhsKeyExpressions = lhsKeyExpressions;
   this.rhsKeyExpressions = rhsKeyExpressions;
   this.joinedSchema = buildSchema(joinedTable);
   this.lhsSchema = buildSchema(lhsTable);
   this.rhsSchema = buildSchema(rhsTable);
   this.rhsFieldPosition = rhsFieldPosition;
   this.isSingleValueOnly = isSingleValueOnly;
   this.tableRefs =
       Sets.newHashSetWithExpectedSize(
           lhsPlan.getSourceRefs().size() + rhsPlan.getSourceRefs().size());
   this.tableRefs.addAll(lhsPlan.getSourceRefs());
   this.tableRefs.addAll(rhsPlan.getSourceRefs());
   this.thresholdBytes =
       context
           .getConnection()
           .getQueryServices()
           .getProps()
           .getInt(
               QueryServices.SPOOL_THRESHOLD_BYTES_ATTRIB,
               QueryServicesOptions.DEFAULT_SPOOL_THRESHOLD_BYTES);
 }
コード例 #8
0
 private boolean explainSkipScan(StringBuilder buf) {
   ScanRanges scanRanges = context.getScanRanges();
   if (scanRanges.isPointLookup()) {
     int keyCount = scanRanges.getPointLookupCount();
     buf.append("POINT LOOKUP ON " + keyCount + " KEY" + (keyCount > 1 ? "S " : " "));
   } else if (scanRanges.useSkipScanFilter()) {
     buf.append("SKIP SCAN ");
     int count = 1;
     boolean hasRanges = false;
     for (List<KeyRange> ranges : scanRanges.getRanges()) {
       count *= ranges.size();
       for (KeyRange range : ranges) {
         hasRanges |= !range.isSingleKey();
       }
     }
     buf.append("ON ");
     buf.append(count);
     buf.append(hasRanges ? " RANGE" : " KEY");
     buf.append(count > 1 ? "S " : " ");
   } else {
     buf.append("RANGE SCAN ");
   }
   return scanRanges.useSkipScanFilter();
 }
コード例 #9
0
  protected void explain(String prefix, List<String> planSteps) {
    StringBuilder buf = new StringBuilder(prefix);
    ScanRanges scanRanges = context.getScanRanges();
    boolean hasSkipScanFilter = false;
    if (scanRanges.isEverything()) {
      buf.append("FULL SCAN ");
    } else {
      hasSkipScanFilter = explainSkipScan(buf);
    }
    buf.append("OVER " + tableRef.getTable().getName().getString());
    if (!scanRanges.isPointLookup()) {
      appendKeyRanges(buf);
    }
    planSteps.add(buf.toString());

    Scan scan = context.getScan();
    Filter filter = scan.getFilter();
    PageFilter pageFilter = null;
    if (filter != null) {
      int offset = 0;
      boolean hasFirstKeyOnlyFilter = false;
      String filterDesc = "";
      if (hasSkipScanFilter) {
        if (filter instanceof FilterList) {
          List<Filter> filterList = ((FilterList) filter).getFilters();
          if (filterList.get(0) instanceof FirstKeyOnlyFilter) {
            hasFirstKeyOnlyFilter = true;
            offset = 1;
          }
          if (filterList.size() > offset + 1) {
            filterDesc = filterList.get(offset + 1).toString();
            if (filterList.size() > offset + 2) {
              pageFilter = (PageFilter) filterList.get(offset + 2);
            }
          }
        }
      } else if (filter instanceof FilterList) {
        List<Filter> filterList = ((FilterList) filter).getFilters();
        if (filterList.get(0) instanceof FirstKeyOnlyFilter) {
          hasFirstKeyOnlyFilter = true;
          offset = 1;
        }
        if (filterList.size() > offset) {
          filterDesc = filterList.get(offset).toString();
          if (filterList.size() > offset + 1) {
            pageFilter = (PageFilter) filterList.get(offset + 1);
          }
        }
      } else {
        if (filter instanceof FirstKeyOnlyFilter) {
          hasFirstKeyOnlyFilter = true;
        } else {
          filterDesc = filter.toString();
        }
      }
      if (filterDesc.length() > 0) {
        planSteps.add(
            "    SERVER FILTER BY "
                + (hasFirstKeyOnlyFilter ? "FIRST KEY ONLY AND " : "")
                + filterDesc);
      } else if (hasFirstKeyOnlyFilter) {
        planSteps.add("    SERVER FILTER BY FIRST KEY ONLY");
      }
      if (pageFilter != null) {
        planSteps.add("    SERVER " + pageFilter.getPageSize() + " ROW LIMIT");
      }
    }
    groupBy.explain(planSteps);
  }
コード例 #10
0
  private static List<KeyRange> getSplits(
      final TableRef tableRef,
      final Scan scan,
      final List<HRegionLocation> regions,
      final ScanRanges scanRanges)
      throws SQLException {
    final List<TableRef> tableRefs = Collections.singletonList(tableRef);
    ColumnResolver resolver =
        new ColumnResolver() {

          @Override
          public List<PFunction> getFunctions() {
            return Collections.emptyList();
          }

          @Override
          public List<TableRef> getTables() {
            return tableRefs;
          }

          @Override
          public TableRef resolveTable(String schemaName, String tableName) throws SQLException {
            throw new UnsupportedOperationException();
          }

          @Override
          public ColumnRef resolveColumn(String schemaName, String tableName, String colName)
              throws SQLException {
            throw new UnsupportedOperationException();
          }

          @Override
          public PFunction resolveFunction(String functionName) throws SQLException {
            throw new UnsupportedOperationException();
          }

          @Override
          public boolean hasUDFs() {
            return false;
          }
        };
    PhoenixConnection connection =
        DriverManager.getConnection(getUrl(), PropertiesUtil.deepCopy(TEST_PROPERTIES))
            .unwrap(PhoenixConnection.class);
    final PhoenixStatement statement = new PhoenixStatement(connection);
    final StatementContext context =
        new StatementContext(statement, resolver, scan, new SequenceManager(statement));
    context.setScanRanges(scanRanges);
    ParallelIterators parallelIterators =
        new ParallelIterators(
            new QueryPlan() {

              @Override
              public StatementContext getContext() {
                return context;
              }

              @Override
              public ParameterMetaData getParameterMetaData() {
                return PhoenixParameterMetaData.EMPTY_PARAMETER_META_DATA;
              }

              @Override
              public ExplainPlan getExplainPlan() throws SQLException {
                return ExplainPlan.EMPTY_PLAN;
              }

              @Override
              public ResultIterator iterator(ParallelScanGrouper scanGrouper) throws SQLException {
                return ResultIterator.EMPTY_ITERATOR;
              }

              @Override
              public ResultIterator iterator() throws SQLException {
                return ResultIterator.EMPTY_ITERATOR;
              }

              @Override
              public long getEstimatedSize() {
                return 0;
              }

              @Override
              public TableRef getTableRef() {
                return tableRef;
              }

              @Override
              public RowProjector getProjector() {
                return RowProjector.EMPTY_PROJECTOR;
              }

              @Override
              public Integer getLimit() {
                return null;
              }

              @Override
              public OrderBy getOrderBy() {
                return OrderBy.EMPTY_ORDER_BY;
              }

              @Override
              public GroupBy getGroupBy() {
                return GroupBy.EMPTY_GROUP_BY;
              }

              @Override
              public List<KeyRange> getSplits() {
                return null;
              }

              @Override
              public FilterableStatement getStatement() {
                return SelectStatement.SELECT_ONE;
              }

              @Override
              public boolean isDegenerate() {
                return false;
              }

              @Override
              public boolean isRowKeyOrdered() {
                return true;
              }

              @Override
              public List<List<Scan>> getScans() {
                return null;
              }

              @Override
              public boolean useRoundRobinIterator() {
                return false;
              }
            },
            null,
            new SpoolingResultIterator.SpoolingResultIteratorFactory(
                context.getConnection().getQueryServices()));
    List<KeyRange> keyRanges = parallelIterators.getSplits();
    return keyRanges;
  }