Java VoltTableUtil类代码示例

import org.voltdb.utils.VoltTableUtil; //导入依赖的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.utils.VoltTableUtil; //导入依赖的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 results to '" + this.outputPath.getAbsolutePath() + "'");
    return (null);
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
@Override
public String formatFinalResults(BenchmarkResults br) {
    if (this.stop) return (null);
    
    VoltTable vt = new VoltTable(this.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 memory stats to '" + this.outputPath.getAbsolutePath() + "'");
    return (null);
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
private VoltTable evictData() throws Exception {
     VoltTable results[] = this.ee.getStats(SysProcSelector.TABLE, this.locators, false, 0L);
     assertEquals(1, results.length);
     // System.err.println(VoltTableUtil.format(results));
     for (String col : statsFields) {
results[0].advanceRow(); 
         int idx = results[0].getColumnIndex(col);
         assertEquals(0, results[0].getLong(idx));    
     } // FOR
     
     // Now force the EE to evict our boys out
     // We'll tell it to remove 1MB, which is guaranteed to include all of our tuples
     VoltTable evictResult = this.ee.antiCacheEvictBlock(catalog_tbl, 1024 * 1024, 1);

     System.err.println("-------------------------------");
     System.err.println(VoltTableUtil.format(evictResult));
     assertNotNull(evictResult);
     assertEquals(1, evictResult.getRowCount());
     assertNotSame(results[0].getColumnCount(), evictResult.getColumnCount());
     evictResult.resetRowPosition();
     boolean adv = evictResult.advanceRow();
     assertTrue(adv);
     return (evictResult);
 }
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
/**
   * testEvictTuples
   */
  @Test
  public void testEvictTuples() throws Exception {
      this.loadData();
      VoltTable evictResult = this.evictData();
evictResult.advanceRow(); 

      // Our stats should now come back with at least one block evicted
      VoltTable results[] = this.ee.getStats(SysProcSelector.TABLE, this.locators, false, 0L);
      assertEquals(1, results.length);
      System.err.println("-------------------------------");
      System.err.println(VoltTableUtil.format(results));

results[0].advanceRow(); 
      for (String col : statsFields) {
          assertEquals(col, evictResult.getLong(col), results[0].getLong(col));
          if (col == "ANTICACHE_BLOCKS_EVICTED") {
              assertEquals(col, 1, results[0].getLong(col));
          } else {
              assertNotSame(col, 0, results[0].getLong(col));
          }
      } // FOR
  }
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
private VoltTable evictData() throws Exception {
     VoltTable results[] = this.ee.getStats(SysProcSelector.TABLE, this.locators, false, 0L);
     assertEquals(1, results.length);
     // System.err.println(VoltTableUtil.format(results));
     for (String col : statsFields) {
results[0].advanceRow(); 
         int idx = results[0].getColumnIndex(col);
         assertEquals(0, results[0].getLong(idx));    
     } // FOR

     // Now force the EE to evict our boys out
     // We'll tell it to remove 1MB, which is guaranteed to include all of our tuples
     VoltTable evictResult = this.ee.antiCacheEvictBlock(catalog_tbl, 1024 * 500, 1);

     System.err.println("-------------------------------");
     System.err.println(VoltTableUtil.format(evictResult));
     assertNotNull(evictResult);
     assertEquals(1, evictResult.getRowCount());
     //assertNotSame(results[0].getColumnCount(), evictResult.getColumnCount());
     evictResult.resetRowPosition();
     boolean adv = evictResult.advanceRow();
     assertTrue(adv);
       return (evictResult);
 }
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
@Test
  public void testEvictTuples() throws Exception {
      this.loadData();
      VoltTable evictResult = this.evictData();
evictResult.advanceRow(); 

      // Our stats should now come back with at least one block evicted
      VoltTable results[] = this.ee.getStats(SysProcSelector.TABLE, this.locators, false, 0L);
      assertEquals(1, results.length);
      System.err.println("-------------------------------");
      System.err.println(VoltTableUtil.format(results));

results[0].advanceRow(); 
      for (String col : statsFields) {
          assertEquals(col, evictResult.getLong(col), results[0].getLong(col));
          if (col == "BLOCKS_EVICTED") {
              assertEquals(col, 1, results[0].getLong(col));
          } else {
              assertNotSame(col, 0, results[0].getLong(col));
          }
      } // FOR
  }
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
/**
     * testDistributedTxn
     */
    public void testDistributedTxn() throws Exception {
        CatalogContext catalogContext = this.getCatalogContext();
        Client client = this.getClient();
        RegressionSuiteUtil.initializeTPCCDatabase(catalogContext, client);

        // Fire off a distributed neworder txn
        // It should always come back with zero restarts
        String procName = neworder.class.getSimpleName();
        Object params[] = RegressionSuiteUtil.generateNewOrder(catalogContext.numberOfPartitions, true, (short)2);
        
        ClientResponse cresponse = client.callProcedure(procName, params);
        assertEquals(cresponse.toString(), Status.OK, cresponse.getStatus());
        assertFalse(cresponse.toString(), cresponse.isSinglePartition());
        assertEquals(cresponse.toString(), 0, cresponse.getRestartCounter());
//        System.err.println(cresponse);
        
        // Get the MarkovEstimatorProfiler stats
        cresponse = RegressionSuiteUtil.getStats(client, SysProcSelector.MARKOVPROFILER);
        System.err.println(VoltTableUtil.format(cresponse.getResults()[0]));
    }
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
public static void checkBalance(Client client, long acctId, double expected) throws Exception {
    // Make sure that we set it correctly
    String query = String.format("SELECT * FROM %s WHERE custid = %d",
                          SmallBankConstants.TABLENAME_CHECKING, acctId);
    ClientResponse cresponse = client.callProcedure("@AdHoc", query);
    assertEquals(Status.OK, cresponse.getStatus());
    VoltTable results[] = cresponse.getResults();
    assertEquals(1, results.length);
    
    if (results[0].getRowCount() == 0) {
        System.err.println(VoltTableUtil.format(results[0]));
    }
    assertEquals("No rows for acctId "+acctId, 1, results[0].getRowCount());
    assertTrue(results[0].advanceRow());
    assertEquals("Mismatched balance for acctId "+acctId, expected, results[0].getDouble("bal"));
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
/**
 * Store dependency tables for later retrieval by the EE.
 * @param workunit
 */
void trackNewWorkUnit(final Map<Integer, List<VoltTable>> dependencies) {
    for (final Entry<Integer, List<VoltTable>> e : dependencies.entrySet()) {
        // could do this optionally - debug only.
        verifyDependencySanity(e.getKey(), e.getValue());
        // create a new list of references to the workunit's table
        // to avoid any changes to the WorkUnit's list. But do not
        // copy the table data.
        final ArrayDeque<VoltTable> deque = new ArrayDeque<VoltTable>();
        for (VoltTable depTable : e.getValue()) {
            // A joining node will respond with a table that has this status code
            if (depTable.getStatusCode() != VoltTableUtil.NULL_DEPENDENCY_STATUS) {
                deque.add(depTable);
            }
        }
        // intentionally overwrite the previous dependency id.
        // would a lookup and a clear() be faster?
        m_depsById.put(e.getKey(), deque);
    }
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
/**
 * Respond with a dummy fragment response.
 */
private void respondWithDummy()
{
    final FragmentResponseMessage response =
        new FragmentResponseMessage(m_fragmentMsg, m_initiator.getHSId());
    response.m_sourceHSId = m_initiator.getHSId();
    response.setRecovering(true);
    response.setStatus(FragmentResponseMessage.SUCCESS, null);

    // Set the dependencies even if this is a dummy response. This site could be the master
    // on elastic join, so the fragment response message is actually going to the MPI.
    VoltTable depTable = new VoltTable(new VoltTable.ColumnInfo("STATUS", VoltType.TINYINT));
    depTable.setStatusCode(VoltTableUtil.NULL_DEPENDENCY_STATUS);
    for (int frag = 0; frag < m_fragmentMsg.getFragmentCount(); frag++) {
        final int outputDepId = m_fragmentMsg.getOutputDepId(frag);
        response.addDependency(outputDepId, depTable);
    }

    m_initiator.deliver(response);
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
public void handleDuplicates(final String tableName, byte duplicates[]) throws IOException {
    final byte csvBytes[] = VoltTableUtil.toCSV( PrivateVoltTableFactory.createVoltTableFromBuffer(ByteBuffer.wrap(duplicates), true),
                         ',',
                         null,
                         1024 * 512).getSecond();
    es.execute(new Runnable() {
        @Override
        public void run() {
            try {
                handleDuplicatesInternal(tableName, csvBytes);
            } catch (Exception e) {
                VoltDB.crashLocalVoltDB("Error handling duplicate rows during snapshot restore", true, e);
            }
        }
    });
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
/**
 * Round-trip the time, see if it's still the same.
 * @throws IOException
 */
@Test
public void testCSVTimestamp() throws IOException {
    CSVWriter writer = mock(CSVWriter.class);
    ColumnInfo[] columns = new ColumnInfo[] {new ColumnInfo("", VoltType.TIMESTAMP)};
    ArrayList<VoltType> columnTypes = new ArrayList<VoltType>();
    // To make sure we have microseconds we get millisecond from current timestamp
    // and add remainder to ensure we have micros in timestamp.
    TimestampType ts = new TimestampType((System.currentTimeMillis() * 1000) + System.currentTimeMillis() % 1000);
    VoltTable vt = new VoltTable(columns);
    vt.addRow(ts);

    for (ColumnInfo ci : columns) {
        columnTypes.add(ci.type);
    }

    VoltTableUtil.toCSVWriter(writer, vt, columnTypes);

    ArgumentCaptor<String[]> captor = ArgumentCaptor.forClass(String[].class);
    verify(writer).writeNext(captor.capture());
    String[] values = captor.getValue();
    assertEquals(1, values.length);
    TimestampType newTs = new TimestampType(values[0]);
    assertEquals(ts, newTs);
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
private String formatResult(ClientResponse cr) {
    
    final VoltTable results[] = cr.getResults();
    final int num_results = results.length;
    //System.out.println("num of results: " + String.valueOf(num_results));
    StringBuilder sb = new StringBuilder();
    sb.append(VoltTableUtil.format(results));
    
    VoltTable vt = results[0];
    int num_rows = vt.getRowCount();
    //System.out.println("num of rows: " + String.valueOf(num_rows));
    
    return (sb.toString());
}
 

import org.voltdb.utils.VoltTableUtil; //导入依赖的package包/类
private String formatResult(ClientResponse cr) {
    final VoltTable results[] = cr.getResults();
    final int num_results = results.length;
    StringBuilder sb = new StringBuilder();
    
    if (this.enable_debug) {
        sb.append(cr.toString());
    }
    else {
        // MAIN BODY
        if (this.enable_csv) {
            StringWriter out = new StringWriter();
            for (int i = 0; i < num_results; i++) {
                if (i > 0) out.write("\n\n");
                VoltTableUtil.csv(out, results[i], true);
            } // FOR
            sb.append(out.toString());
        } else {
            sb.append(VoltTableUtil.format(results));
        }
        
        // FOOTER
        String footer = "";
        if (this.enable_csv == false) {
            if (num_results == 1) {
                int row_count = results[0].getRowCount(); 
                footer = String.format("%d row%s in set", row_count, (row_count > 1 ? "s" : ""));
            }
            else if (num_results == 0) {
                footer = "No results returned";
            }
            else {
                footer = num_results + " tables returned";
            }
            sb.append(String.format("\n%s (%.2f sec)\n", footer, (cr.getClientRoundtrip() / 1000d)));
        }
    }
    return (sb.toString());
}