import org.voltdb.client.ClientResponse; //导入依赖的package包/类
private VoltTable getResult(Client client, String procName) throws Exception 
{
    VoltTable result = null;
    
    Procedure catalog_proc = runner.catalog_db.getProcedures().getIgnoreCase(procName);
    if (catalog_proc == null) {
        throw new Exception("Invalid stored procedure name '" + procName + "'");
    }
    
    //result = client.asynCallProcedure(null, catalog_proc.getName(), null, params);
    ClientResponse response = client.callProcedure(catalog_proc.getName());
    
    if(response.getStatus()==Status.OK)
    {
        result = response.getResults()[0];
    }
    else
        System.out.println("Failed : " + catalog_proc.getName());
    
    return result;
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * testGetNewDestination
 */
public void testGetNewDestination() throws Exception {
    Client client = this.getClient();
    RegressionSuiteUtil.initializeTM1Database(this.getCatalogContext(), client);
    TM1Client.Transaction txn = Transaction.DELETE_CALL_FORWARDING;
    Object params[] = txn.generateParams(NUM_SUBSCRIBERS);
    ClientResponse cresponse = null;
    try {
        cresponse = client.callProcedure(txn.callName, params);
        assertEquals(Status.OK, cresponse.getStatus());
    } catch (ProcCallException ex) {
        cresponse = ex.getClientResponse();
        assertEquals(cresponse.toString(), Status.ABORT_USER, cresponse.getStatus());
    }
    assertNotNull(cresponse);
    assertTrue(cresponse.toString(), cresponse.isSinglePartition());
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
     * testDeleteCallForwarding
     */
    public void testDeleteCallForwarding() throws Exception {
        Client client = this.getClient();
        RegressionSuiteUtil.initializeTM1Database(this.getCatalogContext(), client);
        TM1Client.Transaction txn = Transaction.DELETE_CALL_FORWARDING;
        Object params[] = txn.generateParams(NUM_SUBSCRIBERS);
        
        for (int i = 0; i < 1000; i++) {
            ClientResponse cresponse = null;
            try {
                cresponse = client.callProcedure(txn.callName, params);
                assertEquals(Status.OK, cresponse.getStatus());
            } catch (ProcCallException ex) {
                cresponse = ex.getClientResponse();
//                System.err.println();
                assertEquals(cresponse.toString(), Status.ABORT_USER, cresponse.getStatus());
            }
            assertNotNull(cresponse);
        } // FOR
    }
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * Executes a procedure synchronously and returns the result to the caller. The method
 * internally tracks execution performance.
 *
 * @param procedure
 *            the name of the procedure to call.
 * @param parameters
 *            the list of parameters to pass to the procedure.
 * @return the response sent back by the VoltDB cluster for the procedure execution.
 * @throws IOException
 * @throws NoConnectionsException
 * @throws ProcCallException
 */
public ClientResponse execute(String procedure, long timeout, Object... parameters)
        throws NoConnectionsException, IOException, ProcCallException {
    ClientImpl currentClient = this.getClient();
    try {
        // If connections are lost try reconnecting.
    	ClientResponse response = currentClient.callProcedure(procedure, parameters);
    	if (trace.val) {
    	    LOG.trace(String.format("JDBC client executed qury %s", procedure));
    	}
    	return response;
    }
    catch (ProcCallException pce) {
        throw pce;
    }
    catch (NoConnectionsException e) {
        this.dropClient(currentClient);
        throw e;
    }
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
@Override
public void clientCallbackImpl(ClientResponse clientResponse) {
    if (clientResponse.getStatus() == Status.OK) {
        // We can remove this from our set of full flights because know that there is now a free seat
        BitSet seats = getSeatsBitSet(element.flight_id);
        seats.set(element.seatnum, false);
        
        // And then put it up for a pending insert
        if (rng.nextInt(100) < SEATSConstants.PROB_REQUEUE_DELETED_RESERVATION) {
            Buffer<Reservation> cache = CACHE_RESERVATIONS.get(CacheType.PENDING_INSERTS);
            assert(cache != null) : "Unexpected " + CacheType.PENDING_INSERTS;
            synchronized (cache) {
                cache.add(element);
            } // SYNCH
        }
    } else if (debug.val) {
        LOG.info("DeleteReservation " + clientResponse.getStatus() + ": " + clientResponse.getStatusString(), clientResponse.getException());
        LOG.info("BUSTED ID: " + element.flight_id + " / " + element.flight_id);
    }
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * testInitialize
 */
public void testInitialize() throws Exception {
    Client client = this.getClient();
    RegressionSuiteUtil.initializeTPCCDatabase(this.getCatalogContext(), client);
    
    String procName = VoltSystemProcedure.procCallName(AdHoc.class);
    for (String tableName : TPCCConstants.TABLENAMES) {
        String query = "SELECT COUNT(*) FROM " + tableName;
        ClientResponse cresponse = client.callProcedure(procName, query);
        assertEquals(Status.OK, cresponse.getStatus());
        VoltTable results[] = cresponse.getResults();
        assertEquals(1, results.length);
        long count = results[0].asScalarLong();
        assertTrue(tableName + " -> " + count, count > 0);
        // System.err.println(tableName + "\n" + VoltTableUtil.format(results[0]));
    } // FOR
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * testTupleAccessCountNoIndex
 */
public void testTupleAccessCountNoIndex() throws Exception {
    CatalogContext catalogContext = this.getCatalogContext();
    Client client = this.getClient();
    RegressionSuiteUtil.initializeTPCCDatabase(catalogContext, client);
    
    ClientResponse cresponse = RegressionSuiteUtil.getStats(client, SysProcSelector.TABLE);
    assertNotNull(cresponse);
    assertEquals(Status.OK, cresponse.getStatus());
    this.checkTupleAccessCount(TPCCConstants.TABLENAME_ITEM, cresponse.getResults()[0], 0);
    
    int expected = 20;
    for (int i = 0; i < expected; i++) {
        cresponse = client.callProcedure("GetItemNoIndex");
        assertNotNull(cresponse);
        assertEquals(Status.OK, cresponse.getStatus());
    } // FOR
    
    cresponse = RegressionSuiteUtil.getStats(client, SysProcSelector.TABLE);
    assertNotNull(cresponse);
    assertEquals(Status.OK, cresponse.getStatus());
    this.checkTupleAccessCount(TPCCConstants.TABLENAME_ITEM, cresponse.getResults()[0], expected);
}
 

import org.voltdb.client.ClientResponse; //导入依赖的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.client.ClientResponse; //导入依赖的package包/类
/**
 * testInitialize
 */
public void testInitialize() throws Exception {
    Client client = this.getClient();
    this.initWikipediaDatabase(this.getCatalogContext(), client);
    
    Set<String> allTables = new HashSet<String>();
    
    String procName = VoltSystemProcedure.procCallName(AdHoc.class);
    for (String tableName : allTables) {
        String query = "SELECT COUNT(*) FROM " + tableName;
        ClientResponse cresponse = client.callProcedure(procName, query);
        assertEquals(Status.OK, cresponse.getStatus());
        VoltTable results[] = cresponse.getResults();
        assertEquals(1, results.length);
        long count = results[0].asScalarLong();
        assertTrue(tableName + " -> " + count, count > 0);
        // System.err.println(tableName + "\n" + results[0]);
    } // FOR
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
@Override
public void clientCallback(ClientResponse clientResponse) {
    if (clientResponse.getStatus() != Status.OK){
        System.out.println(clientResponse.getStatusString());
        System.out.println(clientResponse.getException());
        System.exit(-1);
    }
    incrementTransactionCounter(clientResponse, 0);
    final VoltTable vt = clientResponse.getResults()[0];
    if (!vt.advanceRow()) {
        System.err.println("No rows returned by SelectBlob");
        System.exit(-1);
    }
    final byte bytes[] = vt.getStringAsBytes(1);
    if (bytes.length != m_blobSize) {
        System.err.println("Returned blob size was not correct. Expected "
                + m_blobSize + " but got " + bytes.length);
        System.exit(-1);
    }
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
private VoltTable getResult(Client client, String procName) throws Exception 
{
    VoltTable result = null;
    
    Procedure catalog_proc = this.catalog_db.getProcedures().getIgnoreCase(procName);
    if (catalog_proc == null) {
        throw new Exception("Invalid stored procedure name '" + procName + "'");
    }
    
    //result = client.asynCallProcedure(null, catalog_proc.getName(), null, params);
    ClientResponse response = client.callProcedure(catalog_proc.getName());
    
    if(response.getStatus()==Status.OK)
    {
        result = response.getResults()[0];
    }
    else
        System.out.println("Failed : " + catalog_proc.getName());
    
    return result;
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
public void testTABLECOUNTS() throws IOException, ProcCallException {
    Client client = getClient();
    ClientResponse cr = null;
    CatalogContext catalogContext = this.getCatalogContext();
    
    Random rand = this.getRandom();
    int num_tuples = 11;
    for (Table catalog_tbl : catalogContext.database.getTables()) {
        RegressionSuiteUtil.loadRandomData(client, catalog_tbl, rand, num_tuples);
    } // FOR (table)
    
    // Now get the counts for the tables that we just loaded
    cr = client.callProcedure(GetTableCounts.class.getSimpleName());
    // System.err.println(cr);
    assertEquals(Status.OK, cr.getStatus());
    assertEquals(1, cr.getResults().length);
    VoltTable vt = cr.getResults()[0];
    while (vt.advanceRow()) {
        String tableName = vt.getString(0);
        int count = (int)vt.getLong(1);
        assertEquals(tableName, num_tuples, count);
    } // WHILE
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
     * testMultiPartitionTxn
     */
    @Test
    public void testMultiPartitionTxn() throws Exception {
        this.loadData(this.getTable(TM1Constants.TABLENAME_SUBSCRIBER));
        this.loadData(this.getTable(TM1Constants.TABLENAME_CALL_FORWARDING));
        
        // Simple test to check whether we can execute multi-partition txns serially
        Procedure catalog_proc = this.getProcedure(DeleteCallForwarding.class);
        for (int i = 0; i < NUM_TXNS; i++) {
            Object params[] = { Integer.toString(i), 1l, 1l };
            ClientResponse cr = this.client.callProcedure(catalog_proc.getName(), params);
            assertEquals(Status.OK, cr.getStatus());
        }
//        System.err.println(cr);
        this.statusSnapshot();
    }
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * testVoteLimit
 */
public void testVoteLimit() throws Exception {
    Client client = this.getClient();
    this.initializeDatabase(client);
    
    // Make sure that the phone number is only allowed to vote up to
    // the limit and not anymore after that
    ClientResponse cresponse = null;
    for (int i = 0, cnt = (int)(maxVotesPerPhoneNumber*2); i < cnt; i++) {
        long expected = (i < maxVotesPerPhoneNumber ? VoterConstants.VOTE_SUCCESSFUL :
                                                      VoterConstants.ERR_VOTER_OVER_VOTE_LIMIT);
        cresponse = client.callProcedure(Vote.class.getSimpleName(),
                                         voteId++,
                                         phoneNumber,
                                         contestantNumber,
                                         maxVotesPerPhoneNumber);
        assertEquals(Status.OK, cresponse.getStatus());
        VoltTable results[] = cresponse.getResults();
        assertEquals(1, results.length);
        //assertEquals(expected, results[0].asScalarLong());
    } // FOR
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
private boolean hasTuple(String streamName)
{
    boolean result = false;
    
    try{
        
        Client client = ClientFactory.createClient(128, null, false, null);
        String hostname;
        int port;
        hostname = catalog_site.getHost().getIpaddr();
        port = catalog_site.getProc_port();

        client.createConnection(null, hostname, port, "user", "password");
        String query = "select * from " + streamName;
        ClientResponse cresponse = client.callProcedure("@AdHoc", query);
            
        if (cresponse != null) {
            if (cresponse.getStatus() == Status.OK) {
                LOG.info(streamName + " - " + this.formatResult(cresponse));  
                VoltTable results[] = cresponse.getResults();
                if(results[0].getRowCount() != 0)
                    result = true;
            } else {
                System.out.printf("Server Response: %s / %s\n",
                                  cresponse.getStatus(),
                                  cresponse.getStatusString());
            }
        }
        
        client.close();
    }
    catch (Exception ex) {
        ex.printStackTrace();
    }
    
    return result;
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * testUpdateLocation
 */
public void testUpdateLocation() throws Exception {
    Client client = this.getClient();
    RegressionSuiteUtil.initializeTM1Database(this.getCatalogContext(), client);
    TM1Client.Transaction txn = Transaction.UPDATE_LOCATION;
    Object params[] = txn.generateParams(NUM_SUBSCRIBERS);
    ClientResponse cresponse = client.callProcedure(txn.callName, params);
    assertNotNull(cresponse);
    assertEquals(Status.OK, cresponse.getStatus());
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
/**
 * Performs constraint checking on the result set in clientResponse. It does
 * simple sanity checks like if the response code is SUCCESS. If the check
 * transaction flag is set to true by calling setCheckTransaction(), then it
 * will check the result set against constraints.
 *
 * @param procName
 *            The name of the procedure
 * @param clientResponse
 *            The client response
 * @param errorExpected
 *            true if the response is expected to be an error.
 * @return true if it passes all tests, false otherwise
 */
protected boolean checkTransaction(String procName,
                                   ClientResponse clientResponse,
                                   boolean abortExpected,
                                   boolean errorExpected) {
    final Status status = clientResponse.getStatus();
  //  System.out.println(status);
    if (status != Status.OK) {
        if (errorExpected)
            return true;

        if (abortExpected && status == Status.ABORT_USER)
            return true;

        if (status == Status.ABORT_CONNECTION_LOST) {
            return false;
        }
        if (status == Status.ABORT_REJECT) {
            return false;
        }

        if (clientResponse.getException() != null) {
            clientResponse.getException().printStackTrace();
        }
        if (clientResponse.getStatusString() != null) {
            LOG.warn(clientResponse.getStatusString());
        }
        throw new RuntimeException("Invalid " + procName + " response!\n" + clientResponse);
    }

    if (m_checkGenerator.nextFloat() >= m_checkTransaction)
        return true;

    return checkConstraints(procName, clientResponse);
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
@Override
public void clientCallback(ClientResponse clientResponse) {
    final Status status = clientResponse.getStatus();
    if (status != Status.OK) {
        if (status == Status.ABORT_CONNECTION_LOST){
            /*
             * Status of the last transaction involving the tournament
             * is unknown it could have committed. Recovery code would
             * go here.
             */
            return;
        }

        if (clientResponse.getException() != null) {
            clientResponse.getException().printStackTrace();
        }
        if (debug.val && clientResponse.getStatusString() != null) {
            LOG.warn(clientResponse.getStatusString());
        }
        return;
    }
    synchronized (tournaments) {
        tournaments.offer(Tourney.this);
        tournaments.notifyAll();
    }
    incrementTransactionCounter(clientResponse, t.ordinal());
}
 

import org.voltdb.client.ClientResponse; //导入依赖的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());
}
 

import org.voltdb.client.ClientResponse; //导入依赖的package包/类
@Override
public void clientCallback(ClientResponse clientResponse) {
    final Status status = clientResponse.getStatus();
    incrementTransactionCounter(clientResponse, 0);

    if (status != Status.OK) {
        System.err.println("Failed to execute!!!");
        System.err.println(clientResponse.getException());
        System.err.println(clientResponse.getStatusString());
        System.exit(-1);
    } else {
        pClientCallback(clientResponse.getResults());
    }
}