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); } }