Benchmark(unsigned concurrency_, double delay_,
const String & host_, UInt16 port_, const String & default_database_,
const String & user_, const String & password_, const String & stage,
bool randomize_, size_t max_iterations_, double max_time_,
const String & json_path_, const Settings & settings_)
:
concurrency(concurrency_), delay(delay_), queue(concurrency),
connections(concurrency, host_, port_, default_database_, user_, password_),
randomize(randomize_), max_iterations(max_iterations_), max_time(max_time_),
json_path(json_path_), settings(settings_), pool(concurrency)
{
std::cerr << std::fixed << std::setprecision(3);
if (stage == "complete")
query_processing_stage = QueryProcessingStage::Complete;
else if (stage == "fetch_columns")
query_processing_stage = QueryProcessingStage::FetchColumns;
else if (stage == "with_mergeable_state")
query_processing_stage = QueryProcessingStage::WithMergeableState;
else
throw Exception("Unknown query processing stage: " + stage, ErrorCodes::BAD_ARGUMENTS);
if (!json_path.empty() && Poco::File(json_path).exists()) /// Clear file with previous results
{
Poco::File(json_path).remove();
}
readQueries();
run();
}
int CSearch::doCase()
{
resetData();
readEngines();
readQueries();
return findSwitches();
}
int main(int argc, char* argv[]) {
try {
parseArgs(argc, argv);
std::vector<std::string*> queries;
std::string connectStr=qsOptionValues["connectStr"];
std::string schema=qsOptionValues["schema"];
std::string queryList=qsOptionValues["query"];
std::string planList=qsOptionValues["plan"];
std::string api=qsOptionValues["api"];
std::string type_str=qsOptionValues["type"];
std::string logLevel=qsOptionValues["logLevel"];
std::string testCancel=qsOptionValues["testCancel"];
Drill::QueryType type;
if(!validate(type_str, queryList, planList)){
exit(1);
}
Drill::logLevel_t l=getLogLevel(logLevel.c_str());
std::vector<std::string> queryInputs;
if(type_str=="sql" ){
readQueries(queryList, queryInputs);
type=Drill::SQL;
}else if(type_str=="physical" ){
readPlans(planList, queryInputs);
type=Drill::PHYSICAL;
}else if(type_str == "logical"){
readPlans(planList, queryInputs);
type=Drill::LOGICAL;
}else{
readQueries(queryList, queryInputs);
type=Drill::SQL;
}
bTestCancel = !strcmp(testCancel.c_str(), "true")?true:false;
std::vector<std::string>::iterator queryInpIter;
std::vector<Drill::RecordIterator*> recordIterators;
std::vector<Drill::RecordIterator*>::iterator recordIterIter;
std::vector<Drill::QueryHandle_t*> queryHandles;
std::vector<Drill::QueryHandle_t*>::iterator queryHandleIter;
Drill::DrillClient client;
// To log to file
//DrillClient::initLogging("/var/log/drill/", l);
// To log to stderr
Drill::DrillClient::initLogging(NULL, l);
Drill::DrillClientConfig::setBufferLimit(2*1024*1024); // 2MB. Allows us to hold at least two record batches.
if(client.connect(connectStr.c_str(), schema.c_str())!=Drill::CONN_SUCCESS){
std::cerr<< "Failed to connect with error: "<< client.getError() << " (Using:"<<connectStr<<")"<<std::endl;
return -1;
}
std::cout<< "Connected!\n" << std::endl;
if(api=="sync"){
Drill::DrillClientError* err=NULL;
Drill::status_t ret;
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::RecordIterator* pRecIter = client.submitQuery(type, *queryInpIter, err);
if(pRecIter!=NULL){
recordIterators.push_back(pRecIter);
}
}
size_t row=0;
for(recordIterIter = recordIterators.begin(); recordIterIter != recordIterators.end(); recordIterIter++) {
// get fields.
row=0;
Drill::RecordIterator* pRecIter=*recordIterIter;
Drill::FieldDefPtr fields= pRecIter->getColDefs();
while((ret=pRecIter->next()), ret==Drill::QRY_SUCCESS || ret==Drill::QRY_SUCCESS_WITH_INFO){
fields = pRecIter->getColDefs();
row++;
if( (ret==Drill::QRY_SUCCESS_WITH_INFO && pRecIter->hasSchemaChanged() )|| ( row%100==1)){
for(size_t i=0; i<fields->size(); i++){
std::string name= fields->at(i)->getName();
printf("%s\t", name.c_str());
}
printf("\n");
}
printf("ROW: %ld\t", row);
for(size_t i=0; i<fields->size(); i++){
void* pBuf; size_t sz;
pRecIter->getCol(i, &pBuf, &sz);
print(fields->at(i), pBuf, sz);
}
printf("\n");
if(bTestCancel && row%100==1){
pRecIter->cancel();
printf("Application canceled the query.\n");
}
}
if(ret!=Drill::QRY_NO_MORE_DATA && ret!=Drill::QRY_CANCEL){
std::cerr<< pRecIter->getError() << std::endl;
}
client.freeQueryIterator(&pRecIter);
}
}else{
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::QueryHandle_t* qryHandle = new Drill::QueryHandle_t;
client.submitQuery(type, *queryInpIter, QueryResultsListener, NULL, qryHandle);
client.registerSchemaChangeListener(qryHandle, SchemaListener);
queryHandles.push_back(qryHandle);
}
client.waitForResults();
for(queryHandleIter = queryHandles.begin(); queryHandleIter != queryHandles.end(); queryHandleIter++) {
client.freeQueryResources(*queryHandleIter);
delete *queryHandleIter;
}
}
client.close();
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
int main(int argc, char ** argv) {
char * fileName;
TGraph *index;
int totalres = 0;
char * gotqueryFile = NULL;
FILE * gotFile = NULL;
ifstream f;
unsigned int * gotreslist;
uint gotres = 0;
if (argc < 3) {
printf("Usage: %s <graphfile> <queryfile> [<gotqueryfile>]\n", argv[0]);
exit(1);
}
if (argc == 4) {
savegotFile = 1;
gotqueryFile = argv[3];
}
fileName = argv[1];
f.open(fileName, ios::binary);
index = TGraph::load(f);
f.close();
gotreslist = (uint*)malloc(sizeof(unsigned int)*BUFFER);
int nqueries = 0;
TimeQuery * queries = readQueries(argv[2], &nqueries);
int i;
#ifndef EXPERIMENTS
printf("We are checking the results... Experiments mode off.\n");
#endif
startClockTime();
for (i = 0; i < nqueries; i++) {
fprintf(stderr, "Processing %d/%d\r", i, nqueries);
TimeQuery query = queries[i];
//cleaning vector of results
switch(query.type) {
case EDGE: {
gotres = index->edge_point(query.row, query.column, query.time);
//gotres = findEdge(tree, query.row, query.column, query.time);
*gotreslist = gotres;
break;
}
case EDGE_NEXT: {
//gotres = findEdgeInterval(tree, query.row, query.column, query.initime, query.endtime, 1);
gotres = index->edge_next(query.row, query.column, query.time);
*gotreslist = gotres;
break;
}
case EDGE_WEAK: {
//gotres = findEdgeInterval(tree, query.row, query.column, query.initime, query.endtime, 0);
gotres = index->edge_weak(query.row, query.column, query.initime, query.endtime);
*gotreslist = gotres;
break;
}
case EDGE_STRONG: {
//gotres = findEdgeInterval(tree, query.row, query.column, query.initime, query.endtime, 1);
gotres = index->edge_strong(query.row, query.column, query.initime, query.endtime);
*gotreslist = gotres;
break;
}
case DIRECT_NEIGHBORS: {
//get_neighbors_point(gotreslist, &index, query.row, query.time);
index->direct_point(query.row, query.time, gotreslist);
break;
}
case REVERSE_NEIGHBORS: {
// get_reverse_point(gotreslist, &index, query.row, query.time);
index->reverse_point(query.row, query.time, gotreslist);
break;
}
case DIRECT_NEIGHBORS_WEAK: {
//get_neighbors_weak(gotreslist, &index, query.row, query.initime, query.endtime);
index->direct_weak(query.row, query.initime, query.endtime, gotreslist);
break;
}
case REVERSE_NEIGHBORS_WEAK: {
//get_reverse_weak(gotreslist, &index, query.row, query.initime, query.endtime);
index->reverse_weak(query.row, query.initime, query.endtime, gotreslist);
break;
}
case DIRECT_NEIGHBORS_STRONG: {
//get_neighbors_strong(gotreslist, &index, query.row, query.initime, query.endtime);
index->direct_strong(query.row, query.initime, query.endtime, gotreslist);
break;
}
case REVERSE_NEIGHBORS_STRONG: {
// get_reverse_strong(gotreslist, &index, query.row, query.initime, query.endtime);
index->reverse_strong(query.row, query.initime, query.endtime, gotreslist);
break;
}
case SNAPSHOT: {
gotres = index->snapshot(query.time);
*gotreslist = gotres;
// gotres = findRange(tree, 0, tree->nNodesReal, 0, tree->nNodesReal, time)[0][0];
break;
}
case CHANGE_POINT: {
gotres = index->change_point(query.time);
*gotreslist = gotres;
break;
}
case CHANGE_INTERVAL: {
gotres = index->change_interval(query.initime, query.endtime);
*gotreslist = gotres;
break;
}
case ACTIVED_POINT: {
gotres = index->actived_point(query.time);
*gotreslist = gotres;
break;
}
case ACTIVED_INTERVAL: {
gotres = index->actived_interval(query.initime, query.endtime);
*gotreslist = gotres;
break;
}
case DEACTIVED_POINT: {
gotres = index->deactived_point(query.time);
*gotreslist = gotres;
break;
}
case DEACTIVED_INTERVAL: {
gotres = index->deactived_interval(query.initime, query.endtime);
*gotreslist = gotres;
break;
}
}
#ifndef EXPERIMENTS
// //Comentar para medir tiempos:
if (CHECK_RESULTS) {
if (savegotFile) {
gotFile = fopen(gotqueryFile, "a");
switch(query.type) {
case EDGE: case EDGE_NEXT: {
fprintf(gotFile, "%d %d %d\n", query.row, query.column, query.time);
break;
}
case EDGE_WEAK: case EDGE_STRONG: {
fprintf(gotFile, "%d %d %d %d\n", query.row, query.column, query.initime, query.endtime);
break;
}
case DIRECT_NEIGHBORS: case REVERSE_NEIGHBORS: {
fprintf(gotFile, "%d %d\n", query.row, query.time);
break;
}
case DIRECT_NEIGHBORS_WEAK: case DIRECT_NEIGHBORS_STRONG:
case REVERSE_NEIGHBORS_WEAK: case REVERSE_NEIGHBORS_STRONG: {
fprintf(gotFile, "%d %d %d\n", query.row, query.initime, query.endtime);
break;
}
case SNAPSHOT: case CHANGE_POINT: case ACTIVED_POINT: case DEACTIVED_POINT:
fprintf(gotFile, "%d\n", query.time);
break;
}
if (query.type == EDGE || query.type == EDGE_NEXT || query.type == EDGE_WEAK || query.type == EDGE_STRONG || query.type == SNAPSHOT ||
query.type == CHANGE_POINT || query.type == CHANGE_INTERVAL || query.type == ACTIVED_POINT || query.type == ACTIVED_INTERVAL ||
query.type == DEACTIVED_POINT || query.type == DEACTIVED_INTERVAL) {
fprintf(gotFile,"%d\n", gotres);
} else {
uint j;
fprintf(gotFile, "%d", gotreslist[0]);
for (j = 1; j <= gotreslist[0]; j++) {
fprintf(gotFile, " %d", gotreslist[j]);
}
fprintf(gotFile, "\n");
}
fclose(gotFile);
}
int failcompare = 0;
if (query.type == EDGE || query.type == EDGE_NEXT || query.type == EDGE_WEAK || query.type == EDGE_STRONG || query.type == SNAPSHOT ||
query.type == CHANGE_POINT || query.type == CHANGE_INTERVAL || query.type == ACTIVED_POINT || query.type == ACTIVED_INTERVAL ||
query.type == DEACTIVED_POINT || query.type == DEACTIVED_INTERVAL) {
failcompare = (gotres != query.expectednres);
} else {
failcompare = compareRes(gotreslist, query.expectedres);
gotres = gotreslist[0];
}
if (failcompare) {
printf("query queryType=%d, row=%d, column=%d, time=%d, initime=%d, endtime=%d, expectedres=%d\n", query.type, query.row, query.column, query.time, query.initime, query.endtime, query.expectednres);
printf("count: got %d expected %d\n", gotres, query.expectednres);
if ( ! (query.type == EDGE || query.type == EDGE_NEXT || query.type == EDGE_WEAK || query.type == EDGE_STRONG || query.type == SNAPSHOT ||
query.type == CHANGE_POINT || query.type == CHANGE_INTERVAL || query.type == ACTIVED_POINT || query.type == ACTIVED_INTERVAL ||
query.type == DEACTIVED_POINT || query.type == DEACTIVED_INTERVAL) ) {
printf("expected: "); print_arraysort(query.expectedres);
printf("got : "); print_arraysort(gotreslist);
}
exit(1);
}
totalres += gotres;
}
#else
totalres += *gotreslist;
#endif
}
unsigned long microsecs = endClockTime()/1000; //to microsecs
// printf("time = (%lf), %d queries, %lf micros/query, %lf micros/arista\n",
// difftime, nqueries,
// difftime/nqueries, difftime/totalres);
//printf("time = %lf (%ld) (%lf), %d queries, %lf micros/query, %lf micros/arista\n",
// timeFromBegin(), realTimeFromBegin(), difftime, nqueries,
// difftime/nqueries, difftime/totalres);
// datasets.structura query_input num_queries totaloutput timeperquery timeperoutput
printf("%s\t%s\t%ld\t%d\t%d\t%lf\t%lf\n", argv[1], argv[2],
microsecs, nqueries, totalres, (double)microsecs/nqueries, (double)microsecs/totalres);
//destroyK2Tree(tree);
exit(0);
}
int main(int argc, char* argv[]) {
try {
parseArgs(argc, argv);
std::vector<std::string*> queries;
std::string connectStr=qsOptionValues["connectStr"];
std::string schema=qsOptionValues["schema"];
std::string queryList=qsOptionValues["query"];
std::string planList=qsOptionValues["plan"];
std::string api=qsOptionValues["api"];
std::string type_str=qsOptionValues["type"];
std::string logLevel=qsOptionValues["logLevel"];
std::string testCancel=qsOptionValues["testCancel"];
std::string syncSend=qsOptionValues["syncSend"];
std::string hshakeTimeout=qsOptionValues["hshakeTimeout"];
std::string queryTimeout=qsOptionValues["queryTimeout"];
std::string heartbeatFrequency=qsOptionValues["heartbeatFrequency"];
std::string user=qsOptionValues["user"];
std::string password=qsOptionValues["password"];
std::string saslPluginPath=qsOptionValues["saslPluginPath"];
std::string sasl_encrypt=qsOptionValues["sasl_encrypt"];
std::string serviceHost=qsOptionValues["service_host"];
std::string serviceName=qsOptionValues["service_name"];
std::string auth=qsOptionValues["auth"];
std::string enableSSL=qsOptionValues["enableSSL"];
std::string tlsProtocol=qsOptionValues["TLSProtocol"];
std::string certFilePath=qsOptionValues["certFilePath"];
std::string disableHostnameVerification=qsOptionValues["disableHostnameVerification"];
std::string disableCertVerification=qsOptionValues["disableCertVerification"];
std::string useSystemTrustStore = qsOptionValues["useSystemTrustStore"];
Drill::QueryType type;
if(!validate(type_str, queryList, planList)){
exit(1);
}
Drill::logLevel_t l=getLogLevel(logLevel.c_str());
std::vector<std::string> queryInputs;
if(type_str=="sql" ){
readQueries(queryList, queryInputs);
type=Drill::SQL;
}else if(type_str=="physical" ){
readPlans(planList, queryInputs);
type=Drill::PHYSICAL;
}else if(type_str == "logical"){
readPlans(planList, queryInputs);
type=Drill::LOGICAL;
}else{
readQueries(queryList, queryInputs);
type=Drill::SQL;
}
bTestCancel = !strcmp(testCancel.c_str(), "true")?true:false;
bSyncSend = !strcmp(syncSend.c_str(), "true")?true:false;
std::vector<std::string>::iterator queryInpIter;
std::vector<Drill::RecordIterator*> recordIterators;
std::vector<Drill::RecordIterator*>::iterator recordIterIter;
std::vector<Drill::QueryHandle_t> queryHandles;
std::vector<Drill::QueryHandle_t>::iterator queryHandleIter;
Drill::DrillClient client;
#if defined _WIN32 || defined _WIN64
TCHAR tempPath[MAX_PATH];
GetTempPath(MAX_PATH, tempPath);
char logpathPrefix[MAX_PATH + 128];
strcpy(logpathPrefix,tempPath);
strcat(logpathPrefix, "\\drillclient");
#else
const char* logpathPrefix = "/var/log/drill/drillclient";
#endif
// To log to file
Drill::DrillClient::initLogging(logpathPrefix, l);
// To log to stderr
//Drill::DrillClient::initLogging(NULL, l);
int nQueries=queryInputs.size();
Drill::DrillClientConfig::setBufferLimit(nQueries*2*1024*1024); // 2MB per query. The size of a record batch may vary, but is unlikely to exceed the 256 MB which is the default.
if(!hshakeTimeout.empty()){
Drill::DrillClientConfig::setHandshakeTimeout(atoi(hshakeTimeout.c_str()));
}
if (!queryTimeout.empty()){
Drill::DrillClientConfig::setQueryTimeout(atoi(queryTimeout.c_str()));
}
if(!heartbeatFrequency.empty()) {
Drill::DrillClientConfig::setHeartbeatFrequency(atoi(heartbeatFrequency.c_str()));
}
if (!saslPluginPath.empty()){
Drill::DrillClientConfig::setSaslPluginPath(saslPluginPath.c_str());
}
Drill::DrillUserProperties props;
if(schema.length()>0){
props.setProperty(USERPROP_SCHEMA, schema);
}
if(user.length()>0){
props.setProperty(USERPROP_USERNAME, user);
}
if(password.length()>0){
props.setProperty(USERPROP_PASSWORD, password);
}
if(sasl_encrypt.length()>0){
props.setProperty(USERPROP_SASL_ENCRYPT, sasl_encrypt);
}
if(serviceHost.length()>0){
props.setProperty(USERPROP_SERVICE_HOST, serviceHost);
}
if(serviceName.length()>0){
props.setProperty(USERPROP_SERVICE_NAME, serviceName);
}
if(auth.length()>0){
props.setProperty(USERPROP_AUTH_MECHANISM, auth);
}
if(enableSSL.length()>0){
props.setProperty(USERPROP_USESSL, enableSSL);
if (enableSSL == "true" && certFilePath.length() <= 0 && useSystemTrustStore.length() <= 0){
std::cerr<< "SSL is enabled but no certificate or truststore provided. " << std::endl;
return -1;
}
props.setProperty(USERPROP_TLSPROTOCOL, tlsProtocol);
props.setProperty(USERPROP_CERTFILEPATH, certFilePath);
props.setProperty(USERPROP_DISABLE_HOSTVERIFICATION, disableHostnameVerification);
props.setProperty(USERPROP_DISABLE_CERTVERIFICATION, disableCertVerification);
if (useSystemTrustStore.length() > 0){
props.setProperty(USERPROP_USESYSTEMTRUSTSTORE, useSystemTrustStore);
}
}
if(client.connect(connectStr.c_str(), &props)!=Drill::CONN_SUCCESS){
std::cerr<< "Failed to connect with error: "<< client.getError() << " (Using:"<<connectStr<<")"<<std::endl;
return -1;
}
std::cout<< "Connected!\n" << std::endl;
if(api=="meta") {
Drill::Metadata* metadata = client.getMetadata();
if (metadata) {
std::cout << "Connector:" << std::endl;
std::cout << "\tname:" << metadata->getConnectorName() << std::endl;
std::cout << "\tversion:" << metadata->getConnectorVersion() << std::endl;
std::cout << std::endl;
std::cout << "Server:" << std::endl;
std::cout << "\tname:" << metadata->getServerName() << std::endl;
std::cout << "\tversion:" << metadata->getServerVersion() << std::endl;
std::cout << std::endl;
std::cout << "Metadata:" << std::endl;
std::cout << "\tall tables are selectable: " << metadata->areAllTableSelectable() << std::endl;
std::cout << "\tcatalog separator: " << metadata->getCatalogSeparator() << std::endl;
std::cout << "\tcatalog term: " << metadata->getCatalogTerm() << std::endl;
std::cout << "\tCOLLATE support: " << metadata->getCollateSupport() << std::endl;
std::cout << "\tcorrelation names: " << metadata->getCorrelationNames() << std::endl;
std::cout << "\tdate time functions: " << boost::algorithm::join(metadata->getDateTimeFunctions(), ", ") << std::endl;
std::cout << "\tdate time literals support: " << metadata->getDateTimeLiteralsSupport() << std::endl;
std::cout << "\tGROUP BY support: " << metadata->getGroupBySupport() << std::endl;
std::cout << "\tidentifier case: " << metadata->getIdentifierCase() << std::endl;
std::cout << "\tidentifier quote string: " << metadata->getIdentifierQuoteString() << std::endl;
std::cout << "\tmax binary literal length: " << metadata->getMaxBinaryLiteralLength() << std::endl;
std::cout << "\tmax catalog name length: " << metadata->getMaxCatalogNameLength() << std::endl;
std::cout << "\tmax char literal length: " << metadata->getMaxCharLiteralLength() << std::endl;
std::cout << "\tmax column name length: " << metadata->getMaxColumnNameLength() << std::endl;
std::cout << "\tmax columns in GROUP BY: " << metadata->getMaxColumnsInGroupBy() << std::endl;
std::cout << "\tmax columns in ORDER BY: " << metadata->getMaxColumnsInOrderBy() << std::endl;
std::cout << "\tmax columns in SELECT: " << metadata->getMaxColumnsInSelect() << std::endl;
std::cout << "\tmax cursor name length: " << metadata->getMaxCursorNameLength() << std::endl;
std::cout << "\tmax logical lob size: " << metadata->getMaxLogicalLobSize() << std::endl;
std::cout << "\tmax row size: " << metadata->getMaxRowSize() << std::endl;
std::cout << "\tmax schema name length: " << metadata->getMaxSchemaNameLength() << std::endl;
std::cout << "\tmax statement length: " << metadata->getMaxStatementLength() << std::endl;
std::cout << "\tmax statements: " << metadata->getMaxStatements() << std::endl;
std::cout << "\tmax table name length: " << metadata->getMaxTableNameLength() << std::endl;
std::cout << "\tmax tables in SELECT: " << metadata->getMaxTablesInSelect() << std::endl;
std::cout << "\tmax user name length: " << metadata->getMaxUserNameLength() << std::endl;
std::cout << "\tNULL collation: " << metadata->getNullCollation() << std::endl;
std::cout << "\tnumeric functions: " << boost::algorithm::join(metadata->getNumericFunctions(), ", ") << std::endl;
std::cout << "\tOUTER JOIN support: " << metadata->getOuterJoinSupport() << std::endl;
std::cout << "\tquoted identifier case: " << metadata->getQuotedIdentifierCase() << std::endl;
std::cout << "\tSQL keywords: " << boost::algorithm::join(metadata->getSQLKeywords(), ",") << std::endl;
std::cout << "\tschema term: " << metadata->getSchemaTerm() << std::endl;
std::cout << "\tsearch escape string: " << metadata->getSearchEscapeString() << std::endl;
std::cout << "\tspecial characters: " << metadata->getSpecialCharacters() << std::endl;
std::cout << "\tstring functions: " << boost::algorithm::join(metadata->getStringFunctions(), ",") << std::endl;
std::cout << "\tsub query support: " << metadata->getSubQuerySupport() << std::endl;
std::cout << "\tsystem functions: " << boost::algorithm::join(metadata->getSystemFunctions(), ",") << std::endl;
std::cout << "\ttable term: " << metadata->getTableTerm() << std::endl;
std::cout << "\tUNION support: " << metadata->getUnionSupport() << std::endl;
std::cout << "\tBLOB included in max row size: " << metadata->isBlobIncludedInMaxRowSize() << std::endl;
std::cout << "\tcatalog at start: " << metadata->isCatalogAtStart() << std::endl;
std::cout << "\tcolumn aliasing supported: " << metadata->isColumnAliasingSupported() << std::endl;
std::cout << "\tLIKE escape clause supported: " << metadata->isLikeEscapeClauseSupported() << std::endl;
std::cout << "\tNULL plus non NULL equals to NULL: " << metadata->isNullPlusNonNullNull() << std::endl;
std::cout << "\tread-only: " << metadata->isReadOnly() << std::endl;
std::cout << "\tSELECT FOR UPDATE supported: " << metadata->isSelectForUpdateSupported() << std::endl;
std::cout << "\ttransaction supported: " << metadata->isTransactionSupported() << std::endl;
std::cout << "\tunrelated columns in ORDER BY supported: " << metadata->isUnrelatedColumnsInOrderBySupported() << std::endl;
client.freeMetadata(&metadata);
} else {
std::cerr << "Cannot get metadata:" << client.getError() << std::endl;
}
} else if(api=="sync"){
Drill::DrillClientError* err=NULL;
Drill::status_t ret;
int nQueries=0;
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::RecordIterator* pRecIter = client.submitQuery(type, *queryInpIter, err);
if(pRecIter!=NULL){
recordIterators.push_back(pRecIter);
nQueries++;
}
}
Drill::DrillClientConfig::setBufferLimit(nQueries*2*1024*1024); // 2MB per query. Allows us to hold at least two record batches.
size_t row=0;
for(recordIterIter = recordIterators.begin(); recordIterIter != recordIterators.end(); recordIterIter++) {
// get fields.
row=0;
Drill::RecordIterator* pRecIter=*recordIterIter;
Drill::FieldDefPtr fields= pRecIter->getColDefs();
while((ret=pRecIter->next()), (ret==Drill::QRY_SUCCESS || ret==Drill::QRY_SUCCESS_WITH_INFO) && !pRecIter->hasError()){
fields = pRecIter->getColDefs();
row++;
if( (ret==Drill::QRY_SUCCESS_WITH_INFO && pRecIter->hasSchemaChanged() )|| ( row%100==1)){
for(size_t i=0; i<fields->size(); i++){
std::string name= fields->at(i)->getName();
printf("%s\t", name.c_str());
}
printf("\n");
}
printf("ROW: %ld\t", row);
for(size_t i=0; i<fields->size(); i++){
void* pBuf; size_t sz;
pRecIter->getCol(i, &pBuf, &sz);
print(fields->at(i), pBuf, sz);
}
printf("\n");
if(bTestCancel && row%100==1){
pRecIter->cancel();
printf("Application cancelled the query.\n");
}
}
if(ret!=Drill::QRY_NO_MORE_DATA && ret!=Drill::QRY_CANCEL){
std::cerr<< pRecIter->getError() << std::endl;
}
client.freeQueryIterator(&pRecIter);
}
client.waitForResults();
}else{
if(bSyncSend){
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::QueryHandle_t qryHandle;
client.submitQuery(type, *queryInpIter, QueryResultsListener, NULL, &qryHandle);
client.registerSchemaChangeListener(&qryHandle, SchemaListener);
if(bTestCancel) {
// Send cancellation request after 5seconds
boost::this_thread::sleep(boost::posix_time::milliseconds(1000));
std::cout<< "\n Cancelling query: " << *queryInpIter << "\n" << std::endl;
client.cancelQuery(qryHandle);
} else {
client.waitForResults();
}
client.freeQueryResources(&qryHandle);
}
}else{
for(queryInpIter = queryInputs.begin(); queryInpIter != queryInputs.end(); queryInpIter++) {
Drill::QueryHandle_t qryHandle;
client.submitQuery(type, *queryInpIter, QueryResultsListener, NULL, &qryHandle);
client.registerSchemaChangeListener(&qryHandle, SchemaListener);
queryHandles.push_back(qryHandle);
}
client.waitForResults();
for(queryHandleIter = queryHandles.begin(); queryHandleIter != queryHandles.end(); queryHandleIter++) {
client.freeQueryResources(&*queryHandleIter);
}
}
}
client.close();
} catch (std::exception& e) {
std::cerr << e.what() << std::endl;
}
return 0;
}
int main(int argc, char * * argv)
{
//Verify that the correct number of arguments is given
if(argc != 3)
FATAL("Invalid number of command line arguments!");
//Open the map file for reading
FILE * map = fopen(argv[1], "r");
//Read the number of vertices in the file
int numVertices = readNumberFromFile(map);
//Read the number of edges in the file
int numEdges = readNumberFromFile(map);
//Read vertice data and assign it to nodal linked list "vertex"
int nodenum = readNumberFromFile(map);
int nodexcoord = readNumberFromFile(map);
int nodeycoord = readNumberFromFile(map);
Node * vertex = nodeConstructor(nodenum, nodexcoord, nodeycoord);
int i;
Node * tmpitr = vertex;
for(i = 1; i < numVertices; ++i) {
nodenum = readNumberFromFile(map);
nodexcoord = readNumberFromFile(map);
nodeycoord = readNumberFromFile(map);
tmpitr->next = nodeConstructor(nodenum, nodexcoord, nodeycoord);
tmpitr = tmpitr->next;
}
//Read edge data from the file and assign it to respective lists
for(i = 0; i < numEdges; ++i) {
int firstnode = readNumberFromFile(map);
int secondnode = readNumberFromFile(map);
insertConnection(vertex, firstnode, secondnode);
}
fclose(map);
//NOTE: At this point, the graph is complete, so begin algorithm
//Open the query file for reading
FILE * query = fopen(argv[2], "r");
//Read the number of queries
int numQueries = readNumberFromFile(query);
//Read query data and store it for reference
int * queryArr = readQueries(query, numQueries);
//Store origin node in list
Node * origin = vertex;
//Loop through the queries
for(i = 0; i < (numQueries * 2); i += 2) {
//Find the starting point of the query
int startVal = queryArr[i];
int endVal = queryArr[i+1];
//If they're the same, avoid trying to do anything else
if(startVal == endVal) {
printf("0\n");
printf("%d %d\n", startVal, endVal);
}
else {
Node * start = findVertexByValue(startVal, origin);
Node * end = findVertexByValue(endVal, origin);
start->weight = 0;
while(areAllNotRemoved(origin)) {
//Set the weight check to find minimum node
Node * itrNode = findLowestNode(origin);
//Make sure we're not done
if(itrNode->value == endVal)
break;
//Update weights for adjacent nodes
updateAdjacentWeights(itrNode, origin);
}
if(end->weight == PSEUDOINF)
FATAL("Final node weight was not updated... possibly unconnected?");
//Produce the result list
ResultList * results = reslistConstructor(end->value, end->weight);
Node * before = findVertexByValue(end->prev, origin);
while(before->value != startVal) {
ResultList * pinonfront = reslistConstructor(before->value, before->weight);
pinonfront->next = results;
results = pinonfront;
before = findVertexByValue(before->prev, origin);
}
//Make sure the first number in the list is origin
if(results->value != startVal) {
ResultList * pinonfront2 = reslistConstructor(startVal, start->weight);
pinonfront2->next = results;
results = pinonfront2;
}
//Verify weights and assign the end weight
//end->weight = verifyWeightsAndAssign(results, origin);
//Print the final results
printf("%ld\n", end->weight);
ResultList * printitr = results;
while(printitr != NULL) {
printf("%d ", printitr->value);
printitr = printitr->next;
}
printf("\n");
reslistDestroy(results);
resetGraph(origin);
}
}
//Free used memory
fclose(query);
free(queryArr);
nodeDestroy(origin);
return EXIT_SUCCESS;
}
