import org.voltdb.VoltTable; //导入依赖的package包/类
public VoltTable run(long id)
{
    // Get a deterministic date and a non-deterministic date and
    // verify they're within ten seconds of each other as a basic
    // sanity check
    long nonDeterDate = new Date().getTime();
    long deterDate = getTransactionTime().getTime();
    long diffInMS = nonDeterDate - deterDate;
    if (diffInMS > 10000) {
        String msg = "VoltProcedure time is to far from real time: " + String.valueOf(diffInMS) + " ms";
        throw new VoltAbortException(msg);
    }

    // Get a deterministically-generated random number
    Random rand = getSeededRandomNumberGenerator();
    long randNo = rand.nextLong();

    // Return the deterministic values.
    // Replication should check to make sure they're the same
    // from all replicas.
    VoltTable retval = new VoltTable(
            new ColumnInfo("date", VoltType.BIGINT),
            new ColumnInfo("rand", VoltType.BIGINT));
    retval.addRow(deterDate, randNo);
    return retval;
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
private void makeCustomerName(VoltTable table) {
    // Customer Name! Booyah! Shaq Attaq!
    VoltTable batch = new VoltTable(table);
    if (debug.val)
        LOG.debug(String.format("Loading replicated CUSTOMER_NAME table [tuples=%d]", table.getRowCount()));
    try {
        for (int i = 0, cnt = table.getRowCount(); i < cnt; i++) {
            if (this.stop) return;
            batch.add(table.fetchRow(i));
            if (batch.getRowCount() == replicated_batch_size) {
                if (debug.val)
                    LOG.debug(String.format("Loading replicated CUSTOMER_NAME table [tuples=%d/%d]", i, cnt));
                loadVoltTable("CUSTOMER_NAME", batch);
                batch.clearRowData();
            }
        } // FOR
        if (batch.getRowCount() > 0) {
            loadVoltTable("CUSTOMER_NAME", batch);
            batch.clearRowData();
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    } finally {
        table.clearRowData();
    }
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
protected final void saveProfile(AuctionMarkLoader baseClient) {
    Database catalog_db = baseClient.getCatalogContext().database;
    
 // CONFIG_PROFILE
    Table catalog_tbl = catalog_db.getTables().get(AuctionMarkConstants.TABLENAME_CONFIG_PROFILE);
    VoltTable vt = CatalogUtil.getVoltTable(catalog_tbl);
    assert(vt != null);
    vt.addRow(
        this.scale_factor,                  // CFP_SCALE_FACTOR
        this.benchmarkStartTime,            // CFP_BENCHMARK_START
        this.users_per_item_count.toJSONString() // CFP_USER_ITEM_HISTOGRAM
    );
    if (debug.val)
        LOG.debug("Saving profile information into " + catalog_tbl);
    baseClient.loadVoltTable(catalog_tbl.getName(), vt);
    
    return;
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
/**
 * Combine multiple VoltTables into a single table
 * 
 * @param vts
 * @return
 */
public static VoltTable combineTables(final VoltTable... vts) {
    assert (vts.length > 0);
    ColumnInfo cols[] = new ColumnInfo[vts[0].getColumnCount()];
    for (int i = 0; i < cols.length; i++) {
        cols[i] = new ColumnInfo(vts[0].getColumnName(i), vts[0].getColumnType(i));
    } // FOR

    VoltTable ret = new VoltTable(cols);
    for (VoltTable vt : vts) {
        assert (vt.getColumnCount() == ret.getColumnCount());
        vt.resetRowPosition();
        while (vt.advanceRow()) {
            ret.add(vt.cloneRow());
        } // WHILE
    } // FOR
    return (ret);
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public void testMultiPartitionTxnAfterFailure()
throws IOException, ProcCallException
{
    Client client = getClient();
    VoltTable[] results = client.callProcedure("InsertMultiPart", 1,
                                               "desc", 100, 14.5).getResults();
    assertEquals(1, results[0].asScalarLong());
    results = client.callProcedure("SelectMultiPart").getResults();
    System.out.println(results[0].toString());
    assertEquals(1, results[0].getRowCount());
    LocalCluster config = (LocalCluster) m_config;
    config.shutDownSingleHost(0);
    for (int i = 0; i < 100; i++)
    {
        results = client.callProcedure("SelectMultiPart").getResults();
        assertEquals(1, results[0].getRowCount());
    }
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public void testTicket232() throws IOException, ProcCallException
{
    System.err.println(StringUtil.bold(ClassUtil.getCurrentMethodName()));
    String[] tables = {"P1", "R1", "P2", "R2"};
    Client client = getClient();
    for (String table : tables)
    {
        client.callProcedure("Insert", table, 1, "desc", 100, 14.5);
        client.callProcedure("Insert", table, 2, "desc", 100, 14.5);
        client.callProcedure("Insert", table, 3, "desc", 200, 14.5);
        client.callProcedure("Insert", table, 6, "desc", 200, 14.5);
        client.callProcedure("Insert", table, 7, "desc", 300, 14.5);
        client.callProcedure("Insert", table, 8, "desc", 300, 14.5);
        String query =
            String.format("select %s.NUM from %s group by %s.NUM order by %s.NUM",
                          table, table, table, table);
        VoltTable[] results = client.callProcedure("@AdHoc", query).getResults();
        assertEquals(3, results[0].getRowCount());
    }
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public VoltTable[] run(long id, String fields[]) {
      assert(fields.length == YCSBConstants.NUM_COLUMNS);
voltQueueSQL(updateAllStmt,
             fields[0], // FIELD1
             fields[1], // FIELD2
             fields[2], // FIELD3
             fields[3], // FIELD4
             fields[4], // FIELD5
             fields[5], // FIELD6
             fields[6], // FIELD7
             fields[7], // FIELD8
             fields[8], // FIELD9
             fields[9], // FIELD10
             id
      );
      return (voltExecuteSQL(true));
  }
 

import org.voltdb.VoltTable; //导入依赖的package包/类
private final void loadConfigHistograms(VoltTable vt) {
    while (vt.advanceRow()) {
        int col = 0;
        String name = vt.getString(col++);
        ObjectHistogram<String> h = JSONUtil.fromJSONString(new ObjectHistogram<String>(), vt.getString(col++));
        boolean is_airline = (vt.getLong(col++) == 1);
        
        if (is_airline) {
            this.airport_histograms.put(name, h);
            if (trace.val) 
                LOG.trace(String.format("Loaded %d records for %s airport histogram", h.getValueCount(), name));
        } else {
            this.histograms.put(name, h);
            if (trace.val)
                LOG.trace(String.format("Loaded %d records for %s histogram", h.getValueCount(), name));
        }
    } // WHILE
    if (debug.val)
        LOG.debug(String.format("Loaded %s data", SEATSConstants.TABLENAME_CONFIG_HISTOGRAMS));
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
/**
 * distributed sums of a view
 * select sum(V.SUM_V1), sum(V.SUM_V2), sum(V.SUM_V3) from V
 * @throws InterruptedException
 */
public void testDistributedSum_View() throws IOException, ProcCallException, InterruptedException {
    VoltTable vt;
    Client client = getClient();
    loadF(client, 0);

    // FIXME String qs = "select sum(V.SUM_v1), sum(V.SUM_V2), sum(V.SUM_V3) from V";
    String qs = "select sum(V.SUM_v1), sum(V.SUM_V2) from V";

    vt = client.callProcedure("@AdHoc", qs).getResults()[0];
    System.out.println("testDistributedSum_View result: " + vt);
    assertTrue(vt.getRowCount() == 1);
    while (vt.advanceRow()) {
        Integer sum1 = (Integer) vt.get(0, VoltType.INTEGER);
        assertEquals(2000, sum1.intValue());
        Integer sum2 = (Integer) vt.get(1, VoltType.INTEGER);
        assertEquals(4995000, sum2.intValue());
        // FIXME Integer sum3 = (Integer) vt.get(2, VoltType.INTEGER);
        // FIXME assertEquals(500, sum3.intValue());
    }
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
private final VoltTable[] performSnapshotDigestScanWork(String path) {
    SynthesizedPlanFragment[] pfs = new SynthesizedPlanFragment[2];

    pfs[0] = new SynthesizedPlanFragment();
    pfs[0].fragmentId = SysProcFragmentId.PF_snapshotDigestScan;
    pfs[0].outputDependencyIds = new int[] { DEP_snapshotDigestScan };
    pfs[0].multipartition = true;
    ParameterSet params = new ParameterSet();
    params.setParameters(path);
    pfs[0].parameters = params;

    pfs[1] = new SynthesizedPlanFragment();
    pfs[1].fragmentId = SysProcFragmentId.PF_snapshotDigestScanResults;
    pfs[1].outputDependencyIds = new int[] { DEP_snapshotDigestScanResults };
    pfs[1].inputDependencyIds = new int[] { DEP_snapshotDigestScan };
    pfs[1].multipartition = false;
    pfs[1].parameters = new ParameterSet();

    VoltTable[] results;
    results = executeSysProcPlanFragments(pfs, DEP_snapshotDigestScanResults);
    return results;
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
@Override
public ResultSet getIndexInfo(String catalog, String schema, String table, boolean unique, boolean approximate) throws SQLException
{
    assert(table != null && !table.isEmpty());
    checkClosed();
    this.sysCatalog.setString(1, "INDEXINFO");
    JDBC4ResultSet res = (JDBC4ResultSet) this.sysCatalog.executeQuery();
    VoltTable vtable = res.getVoltTable().clone(0);

   
    // Filter the indexes by table name
    while (res.next()) {
    	 
        if (res.getString("TABLE_NAME").equals(table.toUpperCase())) {
            if (!unique || res.getShort("NON_UNIQUE") == 0) {
                vtable.addRow(res.getRowData());
            }
        }
    }

    return new JDBC4ResultSet(sysCatalog, vtable);
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
/**
 * Store
 * 
 * @param map
 * @param vt
 */
public static void storeTableInMap(final Map<String, Object[]> map, final VoltTable vt) {
    assert (vt != null);
    assert (map != null);

    int num_rows = vt.getRowCount();
    while (vt.advanceRow()) {
        int row_idx = vt.getActiveRowIndex();
        for (int i = 0, cnt = vt.getColumnCount(); i < cnt; i++) {
            String col_name = vt.getColumnName(i);
            VoltType vtype = vt.getColumnType(i);
            if (row_idx == 0) {
                map.put(col_name, new Object[num_rows]);
            }
            map.get(col_name)[row_idx] = vt.get(col_name, vtype);
        } // FOR
    } // WHILE
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public void testTicket511_ViolateUniquenessWithLargeString() throws Exception {
    Client client = getClient();
    System.out.println("STARTING testTicket511_ViolateUniquenessWithLargeString");
    byte stringData[] = new byte[60000];
    java.util.Arrays.fill(stringData, (byte)'a');

    client.callProcedure("InsertBigString", 0, new String(stringData, "UTF-8"));

    java.util.Arrays.fill(stringData, (byte)'b');
    boolean threwException = false;
    try {
        client.callProcedure("InsertBigString", 0, new String(stringData, "UTF-8"));
    } catch (ProcCallException e) {
        threwException = true;
        assertTrue(e.getMessage().contains("CONSTRAINT VIOLATION"));
        assertTrue(e.getCause().getMessage().toUpperCase().contains("UNIQUE"));
        if (!isHSQL()) {
            VoltTable table = ((ConstraintFailureException)e.getCause()).getTuples();
            table.resetRowPosition();
            assertTrue(table.advanceRow());
            assertTrue(java.util.Arrays.equals(stringData, table.getStringAsBytes(2)));
        }
    }
    assertTrue(threwException);
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public void testNumericExpressionConversion() throws IOException, ProcCallException
{
    System.err.println(StringUtil.bold(ClassUtil.getCurrentMethodName()));
    VoltTable[] results;
    Client client = getClient();

    String sql = "INSERT INTO R1_DECIMAL VALUES " +
       "(26, 307473.174514, 289429.605067, 9.71903320295135486617e-01)";
    results = client.callProcedure("@AdHoc", sql).getResults();
    assertEquals(1, results.length);
    assertEquals(1, results[0].asScalarLong());

    sql = "UPDATE R1_DECIMAL SET CASH = CASH * 5 WHERE " +
        "R1_DECIMAL.CASH != 88687.224073";
    results = client.callProcedure("@AdHoc", sql).getResults();
    assertEquals(1, results.length);
    assertEquals(1, results[0].asScalarLong());

    sql = "UPDATE R1_DECIMAL SET CASH = CASH + 5.5 WHERE " +
        "R1_DECIMAL.CASH != 88687.224073";
    results = client.callProcedure("@AdHoc", sql).getResults();
    assertEquals(1, results.length);
    assertEquals(1, results[0].asScalarLong());
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
@Override
public void runLoop() throws NoConnectionsException
{
    Map<String, VoltTable> memory = new HashMap<String, VoltTable>();
    for (AbstractTable at : getAllTables())
    {
        String sTblName = at.getName();
        VoltTable vt = TableEnv.initVoltTable(at.getName());

        String sLinkPath = at.getCsvLinkPath();
        if (sLinkPath != CodeGenerator.NO_CSV_PATH)
        {
            loadTableFromCsv(sTblName, sLinkPath, vt, memory);
        }
        else
        {
            loadTableByRandom(at, vt, memory);
        }

        System.err.println(sTblName + ": loading final " + vt.getRowCount() + " rows. ");
    }
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
/**
 * Populate FLIGHTS per benchmark spec
 */
void generateFlights() {
    int fid = 0;
    VoltTable flightTbl = initializeFlightDataTable();
    Object row[] = new Object[flightTbl.getColumnCount()];

    while (fid < kMaxFlights / m_scalefactor) {
        int col = 0;
        row[col++] = new Integer(fid++);
        for (int j=0; j < 30; ++j) {
            row[col++] = number(0, 1<<30);
        }
        assert (col == flightTbl.getColumnCount());
        flightTbl.addRow(row);

        if (flightTbl.getRowCount() >= kFlightBatchSize) {
            System.err.printf("FLIGHTS: loading %d rows (fid %d of %d)\n",
                              flightTbl.getRowCount(), fid, (kMaxFlights / m_scalefactor));
            loadTable("FLIGHTS", flightTbl);
            flightTbl.clearRowData();
        }
    }
    System.err.println("FLIGHTS: loading final " + flightTbl.getRowCount() + " rows.");
    loadTable("FLIGHTS", flightTbl);
    flightTbl.clearRowData();
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
@Override
public String formatFinalResults(BenchmarkResults br) {
    if (this.stop) return (null);
    
    VoltTable vt = new VoltTable(COLUMNS);
    for (Object row[] : this.results) {
        vt.addRow(row);
    }
    
    try {
        FileWriter writer = new FileWriter(this.outputPath);
        VoltTableUtil.csv(writer, vt, true);
        writer.close();
    } catch (IOException ex) {
        throw new RuntimeException(ex);
    }
    LOG.info("Wrote CSV table stats periodically to '" + this.outputPath.getAbsolutePath() + "'");
    return (null);
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public VoltTable[] run() {
    // Blast that mofo and get the catalog for the client
    final SynthesizedPlanFragment pfs[] = new SynthesizedPlanFragment[1];
    final ParameterSet params = new ParameterSet();
    pfs[0] = new SynthesizedPlanFragment();
    pfs[0].fragmentId = SysProcFragmentId.PF_getCatalog;
    pfs[0].inputDependencyIds = new int[] { };
    pfs[0].outputDependencyIds = new int[] { SysProcFragmentId.PF_getCatalog };
    pfs[0].multipartition = false;
    pfs[0].nonExecSites = false;
    pfs[0].destPartitionId = this.partitionId;
    pfs[0].parameters = params;
    pfs[0].last_task = true;
    
    return executeSysProcPlanFragments(pfs, SysProcFragmentId.PF_getCatalog);
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
public void testSeqScanFailedPredicateDoesntCountAgainstLimit()
throws IOException, ProcCallException
{
    System.err.println(StringUtil.bold(ClassUtil.getCurrentMethodName()));
    String[] tables = {"P1", "R1"};
    for (String table : tables)
    {
        Client client = getClient();
        // our predicate is going to be ID < NUM.
        // Insert one row where this is false
        client.callProcedure("Insert", table, 1, "desc", -1, 14.5);
        // And two where it is true
        client.callProcedure("Insert", table, 2, "desc", 100, 14.5);
        client.callProcedure("Insert", table, 3, "desc", 100, 14.5);
        String query = "select * from " + table + " where " +
            table + ".ID < " + table +".NUM limit 2";
        VoltTable[] results = client.callProcedure("@AdHoc", query).getResults();
        // we should get 2 rows but this bug would result in only 1 returned
        assertEquals(2, results[0].getRowCount());
    }
}
 

import org.voltdb.VoltTable; //导入依赖的package包/类
private void checkTable(Client client, String tableName, String orderByCol, int expectedRows) {
    if (expectedRows > 200000) {
        System.out.println("Table too large to retrieve with select *");
        System.out.println("Skipping integrity check");
    }
    VoltTable result = null;
    try {
        result = client.callProcedure("SaveRestoreSelect", tableName).getResults()[0];

    } catch (Exception e) {
        e.printStackTrace();
    }
    final int rowCount = result.getRowCount();
    assertEquals(expectedRows, rowCount);

    // System.out.println("Check table :: \n"+result);

    int i = 0;
    while (result.advanceRow()) {
        assertEquals(i, result.getLong(0));
        assertEquals("name_" + i, result.getString(1));
        assertEquals(i, result.getLong(2));
        assertEquals(new Double(i), result.getDouble(3));
        ++i;
    }
}