static void test_logical_index_scan()
{
vector<IndexScanIterator::query_range> q_range;
TableDescriptor* table = Catalog::getInstance()->getTable("cj");
IndexScanIterator::query_range q;
int value = 0;
while (true)
{
q_range.clear();
cout << "Input the search sec_code: ";
cin >> value;
q.value_low = malloc(sizeof(int)); //newmalloc
q.value_low = (void*)(&value);
q.comp_low = EQ;
q.value_high = malloc(sizeof(int)); //newmalloc
q.value_high = (void*) (&value);
q.comp_high = EQ;
q.c_type.type = t_int;
q.c_type.operate = new OperateInt();
q_range.push_back(q);
LogicalOperator* index_scan = new LogicalIndexScan(table->getProjectoin(0)->getProjectionID(), table->getAttribute("sec_code"), q_range);
const NodeID collector_node_id = 0;
LogicalOperator* root = new LogicalQueryPlanRoot(collector_node_id, index_scan, LogicalQueryPlanRoot::PRINT);
BlockStreamIteratorBase* executable_query_plan = root->getIteratorTree(1024 * 64);
executable_query_plan->open();
while (executable_query_plan->next(0));
executable_query_plan->close();
executable_query_plan->~BlockStreamIteratorBase();
root->~LogicalOperator();
}
}
static void bulk_test_logical_index_scan()
{
vector<IndexScanIterator::query_range> q_range;
int count = 1022;
ifstream infile("/home/scdong/code/sec_code", ios::in);
ofstream outfile("/home/scdong/code/fail_log.dat", ios::out);
unsigned long int value = 0;
unsigned long int expect_num;
TableDescriptor* table = Catalog::getInstance()->getTable("cj");
IndexScanIterator::query_range q2;
while (count > 0)
{
q_range.clear();
infile >> value >> expect_num;
q2.value_low = malloc(sizeof(int)); //newmalloc
q2.value_low = (void*)(&value);
q2.comp_low = EQ;
q2.value_high = malloc(sizeof(int)); //newmalloc
q2.value_high = (void*) (&value);
q2.comp_high = EQ;
q2.c_type.type = t_int;
q2.c_type.operate = new OperateInt();
q_range.push_back(q2);
LogicalOperator* index_scan = new LogicalIndexScan(table->getProjectoin(0)->getProjectionID(), table->getAttribute("sec_code"), q_range);
const NodeID collector_node_id = 0;
LogicalOperator* root = new LogicalQueryPlanRoot(collector_node_id, index_scan, LogicalQueryPlanRoot::RESULTCOLLECTOR);
BlockStreamIteratorBase* executable_query_plan = root->getIteratorTree(1024 * 64);
executable_query_plan->open();
while (executable_query_plan->next(0));
executable_query_plan->close();
ResultSet* result_set = executable_query_plan->getResultSet();
const unsigned long int number_of_tuples = result_set->getNumberOftuples();
executable_query_plan->~BlockStreamIteratorBase();
root->~LogicalOperator();
cout << 1022-count << ": Sec_code: " << value << "\t Result: " << number_of_tuples << endl;
if(!print_test_name_result(number_of_tuples == expect_num,"Index Scan")){
printf("\tIndex Scan sec_code = %d, Expected:%d actual: %d\n", value, expect_num, number_of_tuples);
outfile << "Index Scan sec_code = " << value << "\tFAIL!\n";
outfile << "\tExcepted: " << expect_num << "\tActual: " << number_of_tuples << endl;
}
count--;
}
}
unsigned long Analyzer::getDistinctCardinality(const AttributeID& attr_id){
LogicalOperator * scan=new LogicalScan(Catalog::getInstance()->getTable(attr_id.table_id)->getProjectoin(0));
std::vector<Attribute> group_by_attributes;
group_by_attributes.push_back(Catalog::getInstance()->getTable(attr_id.table_id)->getAttribute(attr_id.offset));
LogicalOperator* agg=new Aggregation(group_by_attributes,std::vector<Attribute>(),std::vector<BlockStreamAggregationIterator::State::aggregation>(),scan);
std::vector<Attribute> aggregation_attributes;
aggregation_attributes.push_back(Attribute(ATTRIBUTE_ANY));
std::vector<BlockStreamAggregationIterator::State::aggregation> aggregation_function;
aggregation_function.push_back(
BlockStreamAggregationIterator::State::count);
LogicalOperator* count_agg=new Aggregation(std::vector<Attribute>(),aggregation_attributes,aggregation_function,agg);
LogicalOperator* root = new LogicalQueryPlanRoot(0,
count_agg, LogicalQueryPlanRoot::RESULTCOLLECTOR);
BlockStreamIteratorBase* collector = root->getIteratorTree(
1024 * 64 - sizeof(unsigned));
collector->open();
collector->next(0);
collector->close();
ResultSet* resultset = collector->getResultSet();
ResultSet::Iterator it = resultset->createIterator();
BlockStreamBase::BlockStreamTraverseIterator* b_it=it.nextBlock()->createIterator();
const unsigned long distinct_cardinality=*(unsigned long*)b_it->nextTuple();
resultset->destory();
collector->~BlockStreamIteratorBase();
root->~LogicalOperator();
return distinct_cardinality;
}
void Analyzer::compute_table_stat(const TableID& tab_id){
TableDescriptor* table=Catalog::getInstance()->getTable(tab_id);
LogicalOperator * scan=new LogicalScan(table->getProjectoin(0));
std::vector<Attribute> group_by_attributes;
std::vector<Attribute> aggregation_attributes;
aggregation_attributes.push_back(Attribute(ATTRIBUTE_ANY));
std::vector<BlockStreamAggregationIterator::State::aggregation> aggregation_function;
aggregation_function.push_back(
BlockStreamAggregationIterator::State::count);
LogicalOperator* agg=new Aggregation(group_by_attributes,aggregation_attributes,aggregation_function,scan);
LogicalOperator* root = new LogicalQueryPlanRoot(0,
agg, LogicalQueryPlanRoot::RESULTCOLLECTOR);
BlockStreamIteratorBase* collector = root->getIteratorTree(
1024 * 64 - sizeof(unsigned));
collector->open();
collector->next(0);
collector->close();
ResultSet* resultset = collector->getResultSet();
ResultSet::Iterator it = resultset->createIterator();
BlockStreamBase::BlockStreamTraverseIterator* b_it=it.nextBlock()->createIterator();
const unsigned long tuple_count=*(unsigned long*)b_it->nextTuple();
BlockStreamBase* block;
while(block=it.nextBlock()){
BlockStreamBase::BlockStreamTraverseIterator* b_it=block->createIterator();
}
TableStatistic* tab_stat=new TableStatistic();
tab_stat->number_of_tuples_=tuple_count;
printf("Statistics for table %s is gathered!\n",Catalog::getInstance()->getTable(tab_id)->getTableName().c_str());
tab_stat->print();
StatManager::getInstance()->setTableStatistic(tab_id,tab_stat);
resultset->destory();
root->~LogicalOperator();
}
void Analyzer::analyse(const AttributeID &attrID) {
Catalog *catalog = Catalog::getInstance();
TableDescriptor* table = catalog->getTable(attrID.table_id);
ProjectionDescriptor * projection = NULL;
unsigned pidSize = table->getNumberOfProjection();
const Attribute attr = table->getAttribute(attrID.offset);
for (unsigned i = 0; i < pidSize; ++i) {
if (table->getProjectoin(i)->hasAttribute(attr)) {
projection = table->getProjectoin(i);
break;
}
}
std::vector<Attribute> group_by_attributes;
std::vector<Attribute> aggregation_attributes;
group_by_attributes.push_back(attr);
aggregation_attributes.push_back(attr);
std::vector<BlockStreamAggregationIterator::State::aggregation> aggregation_function;
aggregation_function.push_back(
BlockStreamAggregationIterator::State::count);
LogicalOperator* sb_payload_scan = new LogicalScan(projection);
LogicalOperator* aggregation = new Aggregation(group_by_attributes,
aggregation_attributes, aggregation_function, sb_payload_scan);
const NodeID collector_node_id = 0;
LogicalOperator* root = new LogicalQueryPlanRoot(collector_node_id,
aggregation, LogicalQueryPlanRoot::RESULTCOLLECTOR);
BlockStreamIteratorBase* collector = root->getIteratorTree(
1024 * 64 - sizeof(unsigned));
collector->open();
collector->next(0);
collector->close();
ResultSet* resultset = collector->getResultSet();
ResultSet::Iterator it = resultset->createIterator();
BlockStreamBase* block;
void* tuple;
BlockStreamBase::BlockStreamTraverseIterator *block_it;
unsigned long valueCount = resultset->getNumberOftuples();
unsigned long tupleCount = 0;
TuplePtr *list = new TuplePtr[valueCount];
unsigned long i = 0;
while (block = (BlockStreamBase*) it.atomicNextBlock()) {
block_it = block->createIterator();
while (tuple = block_it->nextTuple()) {
list[i++] = tuple;
tupleCount += getFrequency(tuple, attr.attrType);
}
}
int magicNumber = 100;
StatisticOnTable *stat = new StatisticOnTable(magicNumber);
stat->setValueCount(valueCount);
stat->setTupleCount(tupleCount);
qsort_r(list, valueCount, sizeof(void *), compare,
(void *) (attr.attrType->operate));
mcvAnalyse(list, valueCount, attr, (Histogram *) stat);
equiDepthAnalyse(list, valueCount, attr, (Histogram *) stat);
// StatManager::getInstance()->addStat(attrID, stat);
StatManager::getInstance()->getTableStatistic(attrID.table_id);
delete list;
resultset->destory();
}
static void test_index_filter_performance(int value_high)
{
unsigned long long int start=curtick();
vector<IndexScanIterator::query_range> q_range;
q_range.clear();
int value_low = 10107;
// int value_high = 600257;
TableDescriptor* table = Catalog::getInstance()->getTable("cj");
IndexScanIterator::query_range q;
q.value_low = malloc(sizeof(int)); //newmalloc
q.value_low = (void*)(&value_low);
q.comp_low = GEQ;
q.value_high = malloc(sizeof(int)); //newmalloc
q.value_high = (void*) (&value_high);
q.comp_high = L;
q.c_type.type = t_int;
q.c_type.operate = new OperateInt();
q_range.push_back(q);
LogicalOperator* index_scan = new LogicalIndexScan(table->getProjectoin(0)->getProjectionID(), table->getAttribute("sec_code"), q_range);
const NodeID collector_node_id = 0;
LogicalOperator* root = new LogicalQueryPlanRoot(collector_node_id, index_scan, LogicalQueryPlanRoot::PERFORMANCE);
// root->print();
BlockStreamPerformanceMonitorTop* executable_query_plan = (BlockStreamPerformanceMonitorTop*)root->getIteratorTree(1024 * 64);
executable_query_plan->open();
while (executable_query_plan->next(0));
executable_query_plan->close();
// ResultSet* result_set = executable_query_plan->getResultSet();
const unsigned long int number_of_tuples = executable_query_plan->getNumberOfTuples();
executable_query_plan->~BlockStreamIteratorBase();
root->~LogicalOperator();
// cout << "Sec_code: " << value_low << "\t Result: " << number_of_tuples << endl;
printf("execution time: %4.4f seconds.\n",getSecond(start));
if(!print_test_name_result(number_of_tuples == 26820,"Index Scan")){
printf("\tIndex Scan sec_code = %d, Expected:%d actual: %d\n", value_low, 26820, number_of_tuples);
}
}