Java VoltTable.ColumnInfo方法代码示例

import org.voltdb.VoltTable; //导入方法依赖的package包/类
VoltTable initializeReservationDataTable() {
   VoltTable tbl = new VoltTable(
           new VoltTable.ColumnInfo("RID", VoltType.INTEGER),
           new VoltTable.ColumnInfo("CID", VoltType.INTEGER),
           new VoltTable.ColumnInfo("FID", VoltType.INTEGER),
           new VoltTable.ColumnInfo("SEAT", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR00", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR01", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR02", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR03", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR04", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR05", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR06", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR07", VoltType.INTEGER),
           new VoltTable.ColumnInfo("IATTR08", VoltType.INTEGER)
   );
   return tbl;
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
public void testDelivery() throws IOException {
    VoltTable orders = new VoltTable(
            new VoltTable.ColumnInfo("", VoltType.BIGINT)
    );
    for (int i = 0; i < TPCCConstants.DISTRICTS_PER_WAREHOUSE; ++i) {
        orders.addRow((long) i);
    }
    mockClient.nextResult = new VoltTable[]{ orders };
    client.m_tpccSim.doDelivery();
    assertEquals("delivery", mockClient.calledName);
    assertEquals(3, mockClient.calledParameters.length);
    //assertEquals(1L, mockClient.calledParameters[0]);
    assertEquals((long) TPCCConstants.MIN_CARRIER_ID, mockClient.calledParameters[1]);
    assertEquals(Clock.Mock.NOW, mockClient.calledParameters[2]);

    generator.minimum = false;
    client.m_tpccSim.doDelivery();
    assertEquals("delivery", mockClient.calledName);
    assertEquals(3, mockClient.calledParameters.length);
    //assertEquals(WAREHOUSES, mockClient.calledParameters[0]);
    assertEquals((long) TPCCConstants.MAX_CARRIER_ID, mockClient.calledParameters[1]);
    assertEquals(Clock.Mock.NOW, mockClient.calledParameters[2]);
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
public VoltTable run(int contestantNumber, int max)
{
    ArrayList<Result> results = new ArrayList<Result>();
    voltQueueSQL(resultStmt);
    VoltTable summary = voltExecuteSQL()[0];
    String state = "";
    while(summary.advanceRow()) {
        if (!summary.getString(1).equals(state)) {
            state = summary.getString(1);
            if (summary.getLong(0) == contestantNumber)
                results.add(new Result(state, summary.getLong(2)));
        }
    }
    Result[] resultArray = (Result[])results.toArray();
    Arrays.sort(resultArray, new OrderByVotesDesc());
    VoltTable result = new VoltTable(
						 new VoltTable.ColumnInfo("state",VoltType.STRING),
						 new VoltTable.ColumnInfo("num_votes",VoltType.BIGINT));
    for(int i=0;i<Math.min(resultArray.length,max);i++)
        result.addRow(new Object[] {
resultArray[i].state,
resultArray[i].votes });
    return result;
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
@Override
public void handleMessage(ByteBuffer message, Connection c) {
    try {
        FastDeserializer fds = new FastDeserializer(message);
        StoredProcedureInvocation spi = fds.readObject(StoredProcedureInvocation.class);

        VoltTable vt[] = new VoltTable[1];
        vt[0] = new VoltTable(new VoltTable.ColumnInfo("Foo", VoltType.BIGINT));
        vt[0].addRow(1);
        ClientResponseImpl response =
            new ClientResponseImpl(-1, spi.getClientHandle(), -1, Status.OK, vt, "Extra String");
        c.writeStream().enqueue(response);
        roundTrips.incrementAndGet();
        System.err.println("Sending response.");
    }
    catch (Exception ex) {
        ex.printStackTrace();
    }
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
public void testStockLevel() throws IOException {
    VoltTable t = new VoltTable(new VoltTable.ColumnInfo("foo", VoltType.BIGINT));
    t.addRow(0);
    mockClient.nextResult = new VoltTable[]{ t };
    client.m_tpccSim.doStockLevel();
    assertEquals(TPCCConstants.STOCK_LEVEL, mockClient.calledName);
    assertEquals(3, mockClient.calledParameters.length);
    assertEquals(1L, mockClient.calledParameters[0]);  // w_id
    assertEquals(1L, mockClient.calledParameters[1]);  // d_id
    // threshold
    assertEquals((long) TPCCConstants.MIN_STOCK_LEVEL_THRESHOLD, mockClient.calledParameters[2]);

    generator.minimum = false;
    client.m_tpccSim.doStockLevel();
    assertEquals(TPCCConstants.STOCK_LEVEL, mockClient.calledName);
    assertEquals(3, mockClient.calledParameters.length);
    //assertEquals(WAREHOUSES, mockClient.calledParameters[0]);
    assertEquals((long) TPCCConstants.DISTRICTS_PER_WAREHOUSE, mockClient.calledParameters[1]);
    assertEquals((long) TPCCConstants.MAX_STOCK_LEVEL_THRESHOLD, mockClient.calledParameters[2]);
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
public VoltTable[] run(long id)
{

    VoltTable empty1 = new VoltTable(new VoltTable.ColumnInfo("column1",VoltType.BIGINT),
                                      new VoltTable.ColumnInfo("column2",VoltType.BIGINT),
                                      new VoltTable.ColumnInfo("column3",VoltType.BIGINT),
                                      new VoltTable.ColumnInfo("column4",VoltType.BIGINT),
                                      new VoltTable.ColumnInfo("checktime",VoltType.BIGINT));

    VoltTable empty2 = new VoltTable(new VoltTable.ColumnInfo("called_time_milliseconds",VoltType.BIGINT));
    final VoltTable[] vtReturn = {empty1, empty2};
    return vtReturn;
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
@Override
public VoltTable.ColumnInfo[] getMapOutputSchema() {
    return new VoltTable.ColumnInfo[]{
            new VoltTable.ColumnInfo("ol_number", VoltType.BIGINT),
            new VoltTable.ColumnInfo("ol_quantity", VoltType.BIGINT),
            new VoltTable.ColumnInfo("ol_amount", VoltType.FLOAT),
            new VoltTable.ColumnInfo("i_price", VoltType.FLOAT),
            new VoltTable.ColumnInfo("count_order", VoltType.BIGINT),
    };
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
/**
 *
 * @param catalogTable
 * @return An empty table with the same schema as a given catalog table.
 */
 public static VoltTable getVoltTable(Collection<Column> catalogColumns) {
    VoltTable.ColumnInfo[] columns = new VoltTable.ColumnInfo[catalogColumns.size()];
    int i = 0;
    for (Column catCol : catalogColumns) {
        columns[i++] = new VoltTable.ColumnInfo(catCol.getTypeName(), VoltType.get((byte)catCol.getType()));
    }
    return new VoltTable(columns);
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
@Override
public VoltTable.ColumnInfo[] getReduceOutputSchema() {
    return new VoltTable.ColumnInfo[]{
            new VoltTable.ColumnInfo("ol_number", VoltType.BIGINT),
            new VoltTable.ColumnInfo("revenue", VoltType.BIGINT),
    };
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
@Override
public VoltTable.ColumnInfo[] getReduceOutputSchema() {
    return new VoltTable.ColumnInfo[]{
            new VoltTable.ColumnInfo("ol_number", VoltType.BIGINT),
            new VoltTable.ColumnInfo("sum_qty", VoltType.BIGINT),
            new VoltTable.ColumnInfo("sum_amount", VoltType.FLOAT),
            new VoltTable.ColumnInfo("sum_price", VoltType.FLOAT),
            new VoltTable.ColumnInfo("avg_qty", VoltType.BIGINT),
            new VoltTable.ColumnInfo("avg_amount", VoltType.FLOAT),
            new VoltTable.ColumnInfo("avg_price", VoltType.FLOAT),
            new VoltTable.ColumnInfo("count_order", VoltType.BIGINT),
    };
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
@Override
public VoltTable.ColumnInfo[] getReduceOutputSchema() {
    return new VoltTable.ColumnInfo[]{
            new VoltTable.ColumnInfo("ol_o_id", VoltType.BIGINT),
            new VoltTable.ColumnInfo("ol_w_id", VoltType.BIGINT),
            new VoltTable.ColumnInfo("ol_d_id", VoltType.BIGINT),
            new VoltTable.ColumnInfo("revenue", VoltType.FLOAT),
            new VoltTable.ColumnInfo("o_entry_d", VoltType.TIMESTAMP),
    };
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
/**
     * testNewReservationCallback
     */
    @Test
    public void testNewReservationCallback() throws Exception {
        int seatnum = rand.nextInt(SEATSConstants.FLIGHTS_NUM_SEATS);
        
        BitSet seats = client.getSeatsBitSet(this.flight_id);
        assertNotNull(seats);
        assertFalse(seats.toString(), client.isFlightFull(seats));
        assertFalse(seats.get(seatnum));
//        System.err.println(seats);
        
        // Fake a ClientResponse from a NewReservation txn
        VoltTable results[] = new VoltTable[] {
            new VoltTable(new VoltTable.ColumnInfo("id", VoltType.BIGINT)),
            new VoltTable(new VoltTable.ColumnInfo("id", VoltType.BIGINT))
        };
        results[0].addRow(new Long(1));
        ClientResponseImpl cresponse = new ClientResponseImpl(TXN_ID, CLIENT_HANDLE,
                                                              0, Status.OK,
                                                              results, "");
        
        Reservation r = new Reservation(RESERVATION_ID, this.flight_id, customer_id, seatnum);
        assertNotNull(r);
        NewReservationCallback callback = this.client.new NewReservationCallback(r);
        callback.clientCallback(cresponse);
        
        // Check to make sure that our seat is now reserved
        assertFalse("Flight is incorrectly marked as full\n" + seats, client.isFlightFull(seats));
        // FIXME assertTrue("Failed to mark seat as reserved?", seats.get(seatnum));
    }
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
public VoltTable run() {
    ArrayList<Result> results = new ArrayList<Result>();
    voltQueueSQL(resultStmt);
    VoltTable summary = voltExecuteSQL()[0];
    String state = "";
		
    while(summary.advanceRow()) {
        if (!summary.getString(1).equals(state)) {
            state = summary.getString(1);
            results.add(new Result(state, (int)summary.getLong(0), summary.getLong(2), (byte)1));
        }
        else {
            results.add(new Result(state, (int)summary.getLong(0), summary.getLong(2), (byte)0));
        }
    }
		
    Object[] resultArray = results.toArray();
    VoltTable result = new VoltTable(
						 new VoltTable.ColumnInfo("state",VoltType.STRING),
						 new VoltTable.ColumnInfo("contestant_number",VoltType.INTEGER),
						 new VoltTable.ColumnInfo("num_votes",VoltType.BIGINT),
						 new VoltTable.ColumnInfo("is_winning",VoltType.TINYINT));
		
    for(int i=0;i<resultArray.length;i++) {
        result.addRow(new Object[] {
((Result)resultArray[i]).state,
((Result)resultArray[i]).contestantNumber,
((Result)resultArray[i]).votes,
((Result)resultArray[i]).isWinning });
    }
    return result;
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
@Override
public VoltTable.ColumnInfo[] getMapOutputSchema() {
    return new VoltTable.ColumnInfo[]{
            new VoltTable.ColumnInfo("ol_number", VoltType.BIGINT),
            new VoltTable.ColumnInfo("ol_quantity", VoltType.BIGINT),
            new VoltTable.ColumnInfo("ol_amount", VoltType.FLOAT),
            new VoltTable.ColumnInfo("count_order", VoltType.BIGINT),
    };
}
 

import org.voltdb.VoltTable; //导入方法依赖的package包/类
/** generate replicated tables, ITEM and CUSTOMER_NAME. */
public void makeItems(int itemStart, int itemFinish) {
    // create ITEMS here to reduce memory consumption
    VoltTable items = new VoltTable(new VoltTable.ColumnInfo("I_ID", VoltType.INTEGER),
                                    new VoltTable.ColumnInfo("I_IM_ID", VoltType.INTEGER),
                                    new VoltTable.ColumnInfo("I_NAME", VoltType.STRING),
                                    new VoltTable.ColumnInfo("I_PRICE", VoltType.FLOAT),
                                    new VoltTable.ColumnInfo("I_DATA", VoltType.STRING));
    
    
    
    // items.ensureRowCapacity(parameters.items);
    // items.ensureStringCapacity(parameters.items * 96);
    // Select 10% of the rows to be marked "original"
    if (debug.val)
        LOG.debug(String.format("Loading replicated ITEM table [tuples=%d]", m_parameters.num_items));
    HashSet<Integer> originalRows = selectUniqueIds(m_parameters.num_items / 10, 1, m_parameters.num_items);
    for (int i = itemStart; i < itemFinish; ++i) {
        // if we're on a 10% boundary, print out some nice status info
        // if (i % (m_parameters.items / 10) == 0)
        // System.err.printf("   %d%%\n", (i * 100) /
        // m_parameters.items);

        boolean original = originalRows.contains(i);
        generateItem(items, i, original);
        
        // Items! Sail yo ho!
        if (items.getRowCount() == replicated_batch_size) {
            if (debug.val)
                LOG.debug(String.format("Loading replicated ITEM table [tuples=%d/%d]", i, m_parameters.num_items));
            loadVoltTable("ITEM", items);
            items.clearRowData();
        }
        if (this.stop) return;
    } // FOR
    if (items.getRowCount() > 0) {
        String extra = "";
        if (items.getRowCount() < m_parameters.num_items) extra = String.format(" [tuples=%d/%d]", m_parameters.num_items-items.getRowCount(), m_parameters.num_items);
        if (debug.val)
            LOG.debug("Loading replicated ITEM table" + extra);
        loadVoltTable("ITEM", items);
        items.clearRowData();
    }
    items = null;
}