ResultSet* Executing::run_sql(std::string sql,std::string& error){ /* * should call ExecuteLogicalQueryPlan. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! by yukai * */ // char * test="select row_id,count(*) from cj where cj.row_id=1 group by cj.row_id;"; ResultSet* resultset=0; Node* node=getparsetreeroot(sql.c_str()); if(node==0){ error="sql parser error!"; return resultset; } LogicalOperator* plan=parsetree2logicalplan(node); if(plan==0){ error="query optimization error!"; return resultset; } plan->Print(); LogicalOperator* root=new LogicalQueryPlanRoot(0,plan,LogicalQueryPlanRoot::kResultCollector); // unsigned long long int timer_start=curtick(); PhysicalOperatorBase* collector = root->GetPhysicalPlan( 1024 * 64 - sizeof(unsigned)); collector->Print(); collector->Open(); collector->Next(0); collector->Close(); resultset = collector->GetResultSet(); root->~LogicalOperator();; return resultset; }
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 LogicalAggregation( group_by_attributes, std::vector<Attribute>(), std::vector<PhysicalAggregation::State::Aggregation>(), scan); std::vector<Attribute> aggregation_attributes; aggregation_attributes.push_back(Attribute(ATTRIBUTE_ANY)); std::vector<PhysicalAggregation::State::Aggregation> aggregation_function; aggregation_function.push_back(PhysicalAggregation::State::kCount); LogicalOperator* count_agg = new LogicalAggregation(std::vector<Attribute>(), aggregation_attributes, aggregation_function, agg); LogicalOperator* root = new LogicalQueryPlanRoot( 0, count_agg, LogicalQueryPlanRoot::kResultCollector); PhysicalOperatorBase* collector = root->GetPhysicalPlan(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->~PhysicalOperatorBase(); 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<PhysicalAggregation::State::Aggregation> aggregation_function; aggregation_function.push_back(PhysicalAggregation::State::kCount); LogicalOperator* agg = new LogicalAggregation( group_by_attributes, aggregation_attributes, aggregation_function, scan); LogicalOperator* root = new LogicalQueryPlanRoot(0, agg, LogicalQueryPlanRoot::kResultCollector); PhysicalOperatorBase* collector = root->GetPhysicalPlan(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<PhysicalAggregation::State::Aggregation> aggregation_function; aggregation_function.push_back(PhysicalAggregation::State::kCount); LogicalOperator* sb_payload_scan = new LogicalScan(projection); LogicalOperator* aggregation = new LogicalAggregation(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::kResultCollector); PhysicalOperatorBase* collector = root->GetPhysicalPlan(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(); }