How to use

addScanner

method

in

org.apache.hadoop.hbase.thrift.ThriftServerRunner$HBaseHandler

@Override
public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow,
  List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
 try {
  HTable table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow));
  addAttributes(scan, attributes);
  if(columns != null && columns.size() != 0) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = KeyValue.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan));
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw new IOError(e.getMessage());
 }
}

@Override
public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow,
  List<ByteBuffer> columns, long timestamp,
  Map<ByteBuffer, ByteBuffer> attributes) throws IOError, TException {
 try {
  HTable table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow));
  addAttributes(scan, attributes);
  scan.setTimeRange(Long.MIN_VALUE, timestamp);
  if (columns != null && columns.size() != 0) {
   for (ByteBuffer column : columns) {
    byte [][] famQf = KeyValue.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan));
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw new IOError(e.getMessage());
 }
}

@Override
public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow,
  ByteBuffer stopRow, List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 try {
  HTable table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow), getBytes(stopRow));
  addAttributes(scan, attributes);
  if(columns != null && columns.size() != 0) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = KeyValue.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan));
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw new IOError(e.getMessage());
 }
}

  scan.setCacheBlocks(tScan.isCacheBlocks());
 return addScanner(table.getScanner(scan), tScan.sortColumns);
} catch (IOException e) {
 LOG.warn(e.getMessage(), e);

  scan.setCacheBlocks(tScan.isCacheBlocks());
 return addScanner(table.getScanner(scan), tScan.sortColumns);
} catch (IOException e) {
 LOG.warn(e.getMessage(), e);

    parseFilter.parseFilterString(tScan.getFilterString()));
 return addScanner(table.getScanner(scan));
} catch (IOException e) {
 LOG.warn(e.getMessage(), e);

 return addScanner(table.getScanner(scan), false);
} catch (IOException e) {
 LOG.warn(e.getMessage(), e);

 return addScanner(table.getScanner(scan), false);
} catch (IOException e) {
 LOG.warn(e.getMessage(), e);

@Override
public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow,
  ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow), getBytes(stopRow));
  addAttributes(scan, attributes);
  scan.setTimeRange(0, timestamp);
  if (columns != null && !columns.isEmpty()) {
   for (ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  scan.setTimeRange(0, timestamp);
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow,
  ByteBuffer stopRow, List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow), getBytes(stopRow));
  addAttributes(scan, attributes);
  if(columns != null && columns.size() != 0) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpenWithStop(ByteBuffer tableName, ByteBuffer startRow,
  ByteBuffer stopRow, List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow), getBytes(stopRow));
  addAttributes(scan, attributes);
  if(columns != null && !columns.isEmpty()) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow,
  ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow), getBytes(stopRow));
  addAttributes(scan, attributes);
  scan.setTimeRange(0, timestamp);
  if (columns != null && columns.size() != 0) {
   for (ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  scan.setTimeRange(0, timestamp);
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow,
  List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow));
  addAttributes(scan, attributes);
  if(columns != null && !columns.isEmpty()) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow,
  List<ByteBuffer> columns, long timestamp,
  Map<ByteBuffer, ByteBuffer> attributes) throws IOError, TException {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow));
  addAttributes(scan, attributes);
  scan.setTimeRange(0, timestamp);
  if (columns != null && columns.size() != 0) {
   for (ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpen(ByteBuffer tableName, ByteBuffer startRow,
  List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes) throws IOError {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow));
  addAttributes(scan, attributes);
  if(columns != null && columns.size() != 0) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}

@Override
public int scannerOpenWithStopTs(ByteBuffer tableName, ByteBuffer startRow,
  ByteBuffer stopRow, List<ByteBuffer> columns, long timestamp,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 try {
  HTable table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow), getBytes(stopRow));
  addAttributes(scan, attributes);
  scan.setTimeRange(Long.MIN_VALUE, timestamp);
  if (columns != null && columns.size() != 0) {
   for (ByteBuffer column : columns) {
    byte [][] famQf = KeyValue.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  scan.setTimeRange(Long.MIN_VALUE, timestamp);
  return addScanner(table.getScanner(scan));
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw new IOError(e.getMessage());
 }
}

@Override
public int scannerOpenWithPrefix(ByteBuffer tableName,
                 ByteBuffer startAndPrefix,
                 List<ByteBuffer> columns,
  Map<ByteBuffer, ByteBuffer> attributes)
  throws IOError, TException {
 try {
  HTable table = getTable(tableName);
  Scan scan = new Scan(getBytes(startAndPrefix));
  addAttributes(scan, attributes);
  Filter f = new WhileMatchFilter(
    new PrefixFilter(getBytes(startAndPrefix)));
  scan.setFilter(f);
  if (columns != null && columns.size() != 0) {
   for(ByteBuffer column : columns) {
    byte [][] famQf = KeyValue.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan));
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw new IOError(e.getMessage());
 }
}

@Override
public int scannerOpenTs(ByteBuffer tableName, ByteBuffer startRow,
  List<ByteBuffer> columns, long timestamp,
  Map<ByteBuffer, ByteBuffer> attributes) throws IOError, TException {
 Table table = null;
 try {
  table = getTable(tableName);
  Scan scan = new Scan(getBytes(startRow));
  addAttributes(scan, attributes);
  scan.setTimeRange(0, timestamp);
  if (columns != null && !columns.isEmpty()) {
   for (ByteBuffer column : columns) {
    byte [][] famQf = CellUtil.parseColumn(getBytes(column));
    if(famQf.length == 1) {
     scan.addFamily(famQf[0]);
    } else {
     scan.addColumn(famQf[0], famQf[1]);
    }
   }
  }
  return addScanner(table.getScanner(scan), false);
 } catch (IOException e) {
  LOG.warn(e.getMessage(), e);
  throw getIOError(e);
 } finally{
  closeTable(table);
 }
}