import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
@Override
public TableRow next() {
	if (nextLine == null) {
		throw new NoSuchElementException();
	}
	String result = nextLine;
	List<TableCell> cellList = new ArrayList<TableCell>();
	Matcher matcher = CVS_ELEMENT_PATTERN.matcher(result);
	while (matcher.find()) {
		TableCell resultCell = new TableCell();
		resultCell.setV(matcher.group());
		cellList.add(resultCell);
	}
	TableRow resultRow = new TableRow();
	resultRow.setF(cellList);
	// For next
	fetch();
	return resultRow;
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
private QueryResponse createResponseContainingTestData() {
  TableCell field1 = new TableCell();
  field1.setV("abc");
  TableCell field2 = new TableCell();
  field2.setV("2");
  TableCell field3 = new TableCell();
  field3.setV("testing BigQuery matcher.");
  TableRow row = new TableRow();
  row.setF(Lists.newArrayList(field1, field2, field3));

  QueryResponse response = new QueryResponse();
  response.setJobComplete(true);
  response.setRows(Lists.newArrayList(row));
  response.setTotalRows(BigInteger.ONE);
  return response;
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
public static String printRows(final GetQueryResultsResponse response) {
  StringBuilder msg = null;
  msg = new StringBuilder();
  try {
    for (TableFieldSchema schem: response.getSchema().getFields()) {
      msg.append(schem.getName());
      msg.append(TAB);
    }      
    msg.append(NEWLINE);
    for (TableRow row : response.getRows()) {
      for (TableCell field : row.getF()) {
        msg.append(field.getV().toString());
        msg.append(TAB);
      }
      msg.append(NEWLINE);
    }
    return msg.toString();
  } catch ( NullPointerException ex ) {
    throw new NullPointerException("SQL Execution returned an error!");
  }
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
private TableRow rawRow(Object...args) {
  List<TableCell> cells = new LinkedList<>();
  for (Object a : args) {
    cells.add(new TableCell().setV(a));
  }
  return new TableRow().setF(cells);
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
private String generateHash(@Nonnull List<TableRow> rows) {
  List<HashCode> rowHashes = Lists.newArrayList();
  for (TableRow row : rows) {
    List<String> cellsInOneRow = Lists.newArrayList();
    for (TableCell cell : row.getF()) {
      cellsInOneRow.add(Objects.toString(cell.getV()));
      Collections.sort(cellsInOneRow);
    }
    rowHashes.add(
        Hashing.sha1().hashString(cellsInOneRow.toString(), StandardCharsets.UTF_8));
  }
  return Hashing.combineUnordered(rowHashes).toString();
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
private String formatRows(int totalNumRows) {
  StringBuilder samples = new StringBuilder();
  List<TableRow> rows = response.getRows();
  for (int i = 0; i < totalNumRows && i < rows.size(); i++) {
    samples.append(String.format("%n\t\t"));
    for (TableCell field : rows.get(i).getF()) {
      samples.append(String.format("%-10s", field.getV()));
    }
  }
  if (rows.size() > totalNumRows) {
    samples.append(String.format("%n\t\t..."));
  }
  return samples.toString();
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
/**
 * Returns the query results for the given job as an ImmutableTable, row-keyed by row number
 * (indexed from 1), column-keyed by the TableFieldSchema for that field, and with the value
 * object as the cell value.  Note that null values will not actually be null (since we're using
 * ImmutableTable) but they can be checked for using Data.isNull().
 *
 * <p>This table is fully materialized in memory (not lazily loaded), so it should not be used
 * with queries expected to return large results.
 */
private ImmutableTable<Integer, TableFieldSchema, Object> getQueryResults(Job job) {
  try {
    ImmutableTable.Builder<Integer, TableFieldSchema, Object> builder =
        new ImmutableTable.Builder<>();
    String pageToken = null;
    int rowNumber = 1;
    while (true) {
      GetQueryResultsResponse queryResults = bigquery.jobs()
            .getQueryResults(getProjectId(), job.getJobReference().getJobId())
            .setPageToken(pageToken)
            .execute();
      // If the job isn't complete yet, retry; getQueryResults() waits for up to 10 seconds on
      // each invocation so this will effectively poll for completion.
      if (queryResults.getJobComplete()) {
        List<TableFieldSchema> schemaFields = queryResults.getSchema().getFields();
        for (TableRow row : queryResults.getRows()) {
          Iterator<TableFieldSchema> fieldIterator = schemaFields.iterator();
          Iterator<TableCell> cellIterator = row.getF().iterator();
          while (fieldIterator.hasNext() && cellIterator.hasNext()) {
            builder.put(rowNumber, fieldIterator.next(), cellIterator.next().getV());
          }
          rowNumber++;
        }
        pageToken = queryResults.getPageToken();
        if (pageToken == null) {
          break;
        }
      }
    }
    return builder.build();
  } catch (IOException e) {
    throw BigqueryJobFailureException.create(e);
  }
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
public static void printRows(List<TableRow> rows, PrintStream out){
  for (TableRow row : rows) {
    for (TableCell field : row.getF()) {
      out.printf("%-50s", field.getV());
     }
    out.println();
  }
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public Object getObject(int columnIndex) throws SQLException {
    // to make the logfiles smaller!
    //logger.debug("Function call getObject columnIndex is: " + String.valueOf(columnIndex));
    this.closestrm();
    if (this.isClosed()) {
        throw new BQSQLException("This Resultset is Closed");
    }
    this.ThrowCursorNotValidExeption();
    if (this.RowsofResult == null) {
        throw new BQSQLException("There are no rows in this Resultset");
    }
    if (this.getMetaData().getColumnCount() < columnIndex
            || columnIndex < 1) {
        throw new BQSQLException("ColumnIndex is not valid");
    }
    String Columntype = this.Result.getSchema().getFields()
            .get(columnIndex - 1).getType();

    TableCell field = ((TableRow) this.RowsofResult[this.Cursor]).getF().get(columnIndex - 1);

    if (Data.isNull(field.getV())) {
        this.wasnull = true;
        return null;
    } else {
        String result = field.getV().toString();
        this.wasnull = false;
        try {
            if (Columntype.equals("STRING")) {
                //removing the excess byte by the setmaxFiledSize
                if (maxFieldSize == 0 || maxFieldSize == Integer.MAX_VALUE) {
                    return result;
                } else {
                    try { //lets try to remove the excess bytes
                        return result.substring(0, maxFieldSize);
                    } catch (IndexOutOfBoundsException iout) {
                        //we don't need to remove any excess byte
                        return result;
                    }
                }
            }
            if (Columntype.equals("FLOAT")) {
                return Float.parseFloat(result);
            }
            if (Columntype.equals("BOOLEAN")) {
                return Boolean.parseBoolean(result);
            }
            if (Columntype.equals("INTEGER")) {
                return Long.parseLong(result);
            }
            if (Columntype.equals("TIMESTAMP")) {
                long val = new BigDecimal(result).longValue() * 1000;
                return new Timestamp(val);
            }
            throw new BQSQLException("Unsupported Type (" + Columntype + ")");
        } catch (NumberFormatException e) {
            throw new BQSQLException(e);
        }
    }
}
 

import com.google.api.services.bigquery.model.TableCell; //导入依赖的package包/类
/** {@inheritDoc} */
@Override
public Object getObject(int columnIndex) throws SQLException {
    // to make the logfiles smaller!
    //logger.debug("Function call getObject columnIndex is: " + String.valueOf(columnIndex));
    this.closestrm();
    if (this.isClosed()) {
        throw new BQSQLException("This Resultset is Closed");
    }
    this.ThrowCursorNotValidExeption();
    if (this.RowsofResult == null) {
        throw new BQSQLException("There are no rows in this Resultset");
    }
    if (this.getMetaData().getColumnCount() < columnIndex
            || columnIndex < 1) {
        throw new BQSQLException("ColumnIndex is not valid");
    }
    String Columntype = this.Result.getSchema().getFields()
            .get(columnIndex - 1).getType();

    TableCell field = ((TableRow) this.RowsofResult[this.Cursor]).getF().get(columnIndex - 1);

    if (Data.isNull(field.getV())) {
        this.wasnull = true;
        return null;
    } else {
        String result = field.getV().toString();
        this.wasnull = false;
        try {
            if (Columntype.equals("STRING")) {
                //removing the excess byte by the setmaxFiledSize
                if (maxFieldSize == 0 || maxFieldSize == Integer.MAX_VALUE) {
                    return result;
                } else {
                    try { //lets try to remove the excess bytes
                        return result.substring(0, maxFieldSize);
                    } catch (IndexOutOfBoundsException iout) {
                        //we don't need to remove any excess byte
                        return result;
                    }
                }
            }
            if (Columntype.equals("FLOAT")) {
                return Float.parseFloat(result);
            }
            if (Columntype.equals("BOOLEAN")) {
                return Boolean.parseBoolean(result);
            }
            if (Columntype.equals("INTEGER")) {
                return Long.parseLong(result);
            }
            if (Columntype.equals("TIMESTAMP")) {
                long val = new BigDecimal(result).longValue() * 1000;
                return new Timestamp(val);
            }
            throw new BQSQLException("Unsupported Type");
        } catch (NumberFormatException e) {
            throw new BQSQLException(e);
        }
    }
}