コード例 #1
0
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();
	}
}
コード例 #2
0
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::kResultCollector);
    PhysicalOperatorBase* executable_query_plan =
        root->GetPhysicalPlan(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->~PhysicalOperatorBase();
    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--;
  }
}
コード例 #3
0
static LogicalOperator *solve_insubquery(Node *exprnode,
                                         LogicalOperator *input) {
  switch (exprnode->type) {
    case t_expr_cal: {
      Expr_cal *node = (Expr_cal *)exprnode;
      if (strcmp(node->sign, "INS") == 0) {
        if (node->rnext->type == t_query_stmt) {
          LogicalOperator *sublogicalplan = parsetree2logicalplan(
              node->rnext);  // 1.获得原子查询的logicalplan
          Query_stmt *subquery = (Query_stmt *)(node->rnext);
          vector<Attribute> group_by_attributes;
          vector<Attribute> aggregation_attributes;
          for (Node *p = subquery->select_list;
               p != NULL;)  // 2.1获得groupby的属性
          {
            Select_list *selectlist = (Select_list *)p;
            Select_expr *sexpr = (Select_expr *)selectlist->args;
            group_by_attributes.push_back(
                sublogicalplan->GetPlanContext().GetAttribute(
                    sexpr->ascolname));  ///????
            p = selectlist->next;
          }  // 2.2在1中的logicalplan上做groupby
          LogicalOperator *aggrection_sublogicalplan = new LogicalAggregation(
              group_by_attributes, std::vector<Attribute>(),
              std::vector<PhysicalAggregation::State::Aggregation>(),
              sublogicalplan);
          vector<LogicalEqualJoin::JoinPair> join_pair_list;
          Node *lp, *sp;
          for (lp = node->lnext, sp = ((Query_stmt *)node->rnext)->select_list;
               lp != NULL;)  // 3.1获得equaljoin的左右属性
          {
            Expr_list *lpexpr = (Expr_list *)lp;
            Columns *lcol = (Columns *)lpexpr->data;
            Select_list *spexpr = (Select_list *)sp;
            Columns *rcol = (Columns *)spexpr->args;
            join_pair_list.push_back(LogicalEqualJoin::JoinPair(
                input->GetPlanContext().GetAttribute(lcol->parameter2),
                sublogicalplan->GetPlanContext().GetAttribute(
                    rcol->parameter2)));
            lp = lpexpr->next;
            sp = spexpr->next;
          }
          LogicalOperator *join_logicalplan = new LogicalEqualJoin(
              join_pair_list, input, aggrection_sublogicalplan);
          return join_logicalplan;
        }
      }
    } break;
    default: {}
  }

  return NULL;
}
コード例 #4
0
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();

  PerformanceMonitor* executable_query_plan =
      (PerformanceMonitor*)root->GetPhysicalPlan(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();
  delete executable_query_plan;
  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);
  }
}
コード例 #5
0
ファイル: Analyzer.cpp プロジェクト: yestodaylee/CLAIMS
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;
}
コード例 #6
0
ファイル: Analyzer.cpp プロジェクト: yestodaylee/CLAIMS
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();
}
コード例 #7
0
static void test_logical_index_building() {
  TableDescriptor* table = Catalog::getInstance()->getTable("cj");
  LogicalOperator* csb_building =
      new LogicalCSBIndexBuilding(table->getProjectoin(0)->getProjectionID(),
                                  table->getAttribute(3), "sec_code_index");
  const NodeID collector_node_id = 0;
  LogicalOperator* root = new LogicalQueryPlanRoot(
      collector_node_id, csb_building, LogicalQueryPlanRoot::kResultCollector);
  root->Print();
  PhysicalOperatorBase* executable_query_plan =
      root->GetPhysicalPlan(1024 * 64);
  executable_query_plan->Open();
  while (executable_query_plan->Next(0))
    ;
  executable_query_plan->Close();

  //	ResultSet* result_set = executable_query_plan->getResultSet();

  executable_query_plan->~PhysicalOperatorBase();
  root->~LogicalOperator();
  cout << "index building finished!\n";
}
コード例 #8
0
static void test_scan_filter_performance(int value) {
  unsigned long long int start = curtick();
  TableDescriptor* table = Catalog::getInstance()->getTable("cj");
  LogicalOperator* cj_scan = new LogicalScan(table->getProjectoin(0));

  LogicalFilter::Condition filter_condition_1;
  filter_condition_1.add(table->getAttribute(3), AttributeComparator::GEQ,
                         std::string("10107"));
  filter_condition_1.add(table->getAttribute(3), AttributeComparator::L,
                         (void*)&value);
  LogicalOperator* filter_1 = new LogicalFilter(filter_condition_1, cj_scan);

  const NodeID collector_node_id = 0;
  LogicalOperator* root = new LogicalQueryPlanRoot(
      collector_node_id, filter_1, LogicalQueryPlanRoot::PERFORMANCE);

  PerformanceMonitor* executable_query_plan =
      (PerformanceMonitor*)root->GetPhysicalPlan(1024 * 64);
  //	executable_query_plan->print();
  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();
  printf("execution time: %4.4f seconds.\n", getSecond(start));
  if (!print_test_name_result(number_of_tuples == 26820,
                              "Low selectivity filter")) {
    printf("\tExpected:26695 actual: %d\n", number_of_tuples);
  }
  //	result_set->~ResultSet();
  delete executable_query_plan;
  root->~LogicalOperator();
}
コード例 #9
0
ファイル: issue27.cpp プロジェクト: JolyZhang/CLAIMS
static void query_select_aggregation() {
  /*
   * select sum(a+1)+count(a),b
   * from T
   * group by b
   *
   * notation: p a p s
   * */
  unsigned long long int start = curtick();
  TableDescriptor* table =
      Environment::getInstance()->getCatalog()->getTable("LINEITEM");
  //===========================scan===========================
  LogicalOperator* scan = new LogicalScan(table->getProjectoin(0));

  //==========================project=========================
  vector<vector<ExpressionItem> > expr_list1;

  vector<ExpressionItem> expr1;
  vector<ExpressionItem> expr2;
  vector<ExpressionItem> expr3;
  vector<ExpressionItem> expr4;
  vector<ExpressionItem> expr5;
  vector<ExpressionItem> expr6;
  vector<ExpressionItem> expr7;
  vector<ExpressionItem> expr8;
  vector<ExpressionItem> expr9;
  vector<ExpressionItem> expr10;
  vector<ExpressionItem> expr11;
  vector<ExpressionItem> expr12;
  vector<ExpressionItem> expr13;
  vector<ExpressionItem> expr14;
  vector<ExpressionItem> expr15;
  vector<ExpressionItem> expr16;
  vector<ExpressionItem> expr17;

  ExpressionItem ei1;
  ExpressionItem ei1_1;
  ExpressionItem ei1_2;
  ExpressionItem ei1_3;
  ExpressionItem ei1_4;
  ExpressionItem ei1_5;
  ExpressionItem ei1_6;
  ExpressionItem ei1_7;
  ExpressionItem ei1_8;
  ExpressionItem ei1_9;
  ExpressionItem ei2;
  ExpressionItem ei3;
  ExpressionItem ei4;
  ExpressionItem ei5;
  ExpressionItem ei6;
  ExpressionItem ei7;
  ExpressionItem ei8;
  ExpressionItem ei9;
  ExpressionItem ei10;
  ExpressionItem ei11;
  ExpressionItem ei12;
  ExpressionItem ei13;
  ExpressionItem ei14;
  ExpressionItem ei15;
  ExpressionItem ei16;
  ExpressionItem ei17;

  ei1_1.setVariable("LINEITEM", "L_EXTENDEDPRICE");
  ei1_2.setIntValue("1");
  ei1_3.setVariable("LINEITEM", "L_DISCOUNT");
  ei1_4.setOperator("-");
  ei1_5.setOperator("*");
  ei1_6.setIntValue("1");
  ei1_7.setVariable("LINEITEM", "L_TEX");
  ei1_8.setOperator("+");
  ei1_9.setOperator("*");

  ei1.setVariable("LINEITEM", "row_id");
  ei2.setVariable("LINEITEM", "L_ORDERKEY");
  ei3.setVariable("LINEITEM", "L_PARTKEY");
  ei4.setVariable("LINEITEM", "L_SUPPKEY");
  ei5.setVariable("LINEITEM", "L_LINENUMBER");
  ei6.setVariable("LINEITEM", "L_QUANTITY");
  ei7.setVariable("LINEITEM", "L_EXTENDEDPRICE");
  ei8.setVariable("LINEITEM", "L_DISCOUNT");
  ei9.setVariable("LINEITEM", "L_TEX");
  ei10.setVariable("LINEITEM", "L_RETURNFLAG");
  //	ei10.size=1;
  ei11.setVariable("LINEITEM", "L_LINESTATUS");
  //	ei11.size=1;
  ei12.setVariable("LINEITEM", "L_SHIPDATE");
  ei13.setVariable("LINEITEM", "L_COMMITDATE");
  ei14.setVariable("LINEITEM", "L_RECEIPTDATE");
  ei15.setVariable("LINEITEM", "L_SHIPINSTRUCT");
  //	ei15.size=25;
  ei16.setVariable("LINEITEM", "L_SHIPMODE");
  //	ei16.size=10;
  ei17.setVariable("LINEITEM", "L_COMMENT");
  //	ei17.size=44;

  expr1.push_back(ei1_1);
  expr1.push_back(ei1_2);
  expr1.push_back(ei1_3);
  expr1.push_back(ei1_4);
  expr1.push_back(ei1_5);

  //	expr1.push_back(ei1_6);
  //	expr1.push_back(ei1_7);
  //	expr1.push_back(ei1_8);
  //	expr1.push_back(ei1_9);
  //	expr1.push_back(ei1);

  expr2.push_back(ei1_1);
  expr2.push_back(ei1_2);
  expr2.push_back(ei1_3);
  expr2.push_back(ei1_4);
  expr2.push_back(ei1_5);
  expr2.push_back(ei1_6);
  expr2.push_back(ei1_7);
  expr2.push_back(ei1_8);
  expr2.push_back(ei1_9);

  expr3.push_back(ei1_2);
  expr3.push_back(ei1_3);
  expr3.push_back(ei1_4);

  //	expr3.push_back(ei3);
  expr4.push_back(ei4);
  expr5.push_back(ei5);
  expr6.push_back(ei6);
  expr7.push_back(ei7);
  expr8.push_back(ei8);
  expr9.push_back(ei9);
  expr10.push_back(ei10);
  expr11.push_back(ei11);
  expr12.push_back(ei12);
  expr13.push_back(ei13);
  expr14.push_back(ei14);
  expr15.push_back(ei15);
  expr16.push_back(ei16);
  expr17.push_back(ei17);

  expr_list1.push_back(expr10);
  expr_list1.push_back(expr11);
  expr_list1.push_back(expr6);
  expr_list1.push_back(expr7);
  expr_list1.push_back(expr1);
  expr_list1.push_back(expr2);
  expr_list1.push_back(expr8);
  expr_list1.push_back(expr3);
  expr_list1.push_back(expr10);
  expr_list1.push_back(expr11);

  //	expr_list1.push_back(expr3);
  //	expr_list1.push_back(expr4);
  //	expr_list1.push_back(expr5);
  //	expr_list1.push_back(expr8);
  //	expr_list1.push_back(expr9);
  //	expr_list1.push_back(expr12);
  //	expr_list1.push_back(expr13);
  //	expr_list1.push_back(expr14);
  //	expr_list1.push_back(expr15);
  //	expr_list1.push_back(expr16);
  //	expr_list1.push_back(expr17);

  LogicalOperator* project1 = new LogicalProject(scan, expr_list1);

  //========================aggregation=======================
  std::vector<Attribute> group_by_attributes;
  group_by_attributes.push_back(table->getAttribute("L_RETURNFLAG"));
  group_by_attributes.push_back(table->getAttribute("L_LINESTATUS"));
  std::vector<Attribute> aggregation_attributes;
  aggregation_attributes.push_back(table->getAttribute("L_QUANTITY"));
  aggregation_attributes.push_back(table->getAttribute("L_EXTENDEDPRICE"));
  aggregation_attributes.push_back(table->getAttribute("L_DISCOUNT"));
  aggregation_attributes.push_back(Attribute(ATTRIBUTE_ANY));
  std::vector<BlockStreamAggregationIterator::State::aggregation>
      aggregation_function;

  aggregation_function.push_back(BlockStreamAggregationIterator::State::sum);
  aggregation_function.push_back(BlockStreamAggregationIterator::State::sum);
  aggregation_function.push_back(BlockStreamAggregationIterator::State::sum);
  aggregation_function.push_back(BlockStreamAggregationIterator::State::count);
  LogicalOperator* aggregation =
      new LogicalAggregation(group_by_attributes, aggregation_attributes,
                             aggregation_function, project1);

  //==========================project=========================
  vector<vector<ExpressionItem> > expr_list2;
  LogicalOperator* project2 = new LogicalProject(aggregation, expr_list2);
  //===========================root===========================
  LogicalOperator* root =
      new LogicalQueryPlanRoot(0, project1, LogicalQueryPlanRoot::PERFORMANCE);

  cout << "performance is ok!" << endl;
  PhysicalOperatorBase* physical_iterator_tree =
      root->GetPhysicalPlan(64 * 1024);
  //	physical_iterator_tree->print();
  physical_iterator_tree->Open();
  while (physical_iterator_tree->Next(0))
    ;
  physical_iterator_tree->Close();
  printf("Q1: execution time: %4.4f second.\n", getSecond(start));
}
コード例 #10
0
ファイル: Analyzer.cpp プロジェクト: egraldlo/CLAIMS
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();
}
コード例 #11
0
ファイル: PhysicalSlice.cpp プロジェクト: cerbo/scidb
 /// Get the stringified AutochunkFixer so we can fix up the intervals in execute().
 /// @see LogicalSlice::getInspectable()
 void inspectLogicalOp(LogicalOperator const& lop) override
 {
     setControlCookie(lop.getInspectable());
 }
コード例 #12
0
ファイル: issue27ing.cpp プロジェクト: JolyZhang/CLAIMS
static void query_select_fzh() {
  /*
   * select sum(a+1)+count(a),b
   * from T
   * group by b
   *
   * notation: p a p s
   * */
  unsigned long long int start = curtick();
  TableDescriptor* table =
      Environment::getInstance()->getCatalog()->getTable("LINEITEM");
  //===========================scan===========================
  LogicalOperator* scan = new LogicalScan(table->getProjectoin(0));

  //==========================project=========================
  vector<vector<ExpressionItem> > expr_list1;

  vector<ExpressionItem> expr1;
  vector<ExpressionItem> expr2;
  vector<ExpressionItem> expr3;
  vector<ExpressionItem> expr4;
  vector<ExpressionItem> expr5;
  vector<ExpressionItem> expr6;
  vector<ExpressionItem> expr7;
  vector<ExpressionItem> expr8;
  vector<ExpressionItem> expr9;
  vector<ExpressionItem> expr10;
  vector<ExpressionItem> expr11;
  vector<ExpressionItem> expr12;
  vector<ExpressionItem> expr13;
  vector<ExpressionItem> expr14;
  vector<ExpressionItem> expr15;
  vector<ExpressionItem> expr16;
  vector<ExpressionItem> expr17;

  ExpressionItem ei1;
  ExpressionItem ei1_1;
  ExpressionItem ei1_2;
  ExpressionItem ei1_3;
  ExpressionItem ei1_4;
  ExpressionItem ei1_5;
  ExpressionItem ei1_6;
  ExpressionItem ei1_7;
  ExpressionItem ei1_8;
  ExpressionItem ei1_9;
  ExpressionItem ei2;
  ExpressionItem ei3;
  ExpressionItem ei4;
  ExpressionItem ei5;
  ExpressionItem ei6;
  ExpressionItem ei7;
  ExpressionItem ei8;
  ExpressionItem ei9;
  ExpressionItem ei10;
  ExpressionItem ei11;
  ExpressionItem ei12;
  ExpressionItem ei13;
  ExpressionItem ei14;
  ExpressionItem ei15;
  ExpressionItem ei16;
  ExpressionItem ei17;

  ei1_1.setVariable("LINEITEM.row_id");
  //	ei1_2.setVariable("LINEITEM.L_ORDERKEY");
  ei1_2.setIntValue("1");
  ei1_3.setOperator("+");

  expr1.push_back(ei1_1);
  expr1.push_back(ei1_2);
  expr1.push_back(ei1_3);

  expr_list1.push_back(expr1);

  LogicalOperator* project1 = new LogicalProject(scan, expr_list1);

  //========================aggregation=======================
  std::vector<Attribute> group_by_attributes;
  group_by_attributes.push_back(table->getAttribute("L_RETURNFLAG"));
  group_by_attributes.push_back(table->getAttribute("L_LINESTATUS"));
  std::vector<Attribute> aggregation_attributes;
  aggregation_attributes.push_back(table->getAttribute("L_QUANTITY"));
  aggregation_attributes.push_back(table->getAttribute("L_EXTENDEDPRICE"));
  aggregation_attributes.push_back(table->getAttribute("L_DISCOUNT"));
  aggregation_attributes.push_back(Attribute(ATTRIBUTE_ANY));

  std::vector<PhysicalAggregation::State::Aggregation> aggregation_function;

  aggregation_function.push_back(PhysicalAggregation::State::kSum);
  aggregation_function.push_back(PhysicalAggregation::State::kSum);
  aggregation_function.push_back(PhysicalAggregation::State::kSum);
  aggregation_function.push_back(PhysicalAggregation::State::kCount);
  LogicalOperator* aggregation =
      new LogicalAggregation(group_by_attributes, aggregation_attributes,
                             aggregation_function, project1);

  //==========================project=========================
  vector<vector<ExpressionItem> > expr_list2;

  ExpressionItem ei21_1;
  ei21_1.setVariable("LINEITEM.row_id+1");
  vector<ExpressionItem> expr21;
  expr21.push_back(ei21_1);
  expr_list2.push_back(expr21);
  LogicalOperator* project2 = new LogicalProject(project1, expr_list2);
  //===========================root===========================
  LogicalOperator* root =
      new LogicalQueryPlanRoot(0, project2, LogicalQueryPlanRoot::PRINT);

  cout << "performance is ok!" << endl;
  PhysicalOperatorBase* physical_iterator_tree =
      root->GetPhysicalPlan(64 * 1024);
  //	physical_iterator_tree->print();
  physical_iterator_tree->Open();
  while (physical_iterator_tree->Next(0))
    ;
  physical_iterator_tree->Close();
  printf("Q1: execution time: %4.4f second.\n", getSecond(start));
}
コード例 #13
0
static LogicalOperator *where_from2logicalplan(
    Node *
        parsetree)  //实现where_from_parsetree(即将where转换到from_list后的)到logicalplan的转换
{
  if (parsetree == NULL) {
    return NULL;
  }
  switch (parsetree->type) {
    case t_table:  // table节点获得scan 和在该节点上condition的filter
    {
      Table *node = (Table *)parsetree;
      LogicalOperator *tablescan;
      if (node->issubquery == 0) {
        tablescan = new LogicalScan(Environment::getInstance()
                                        ->getCatalog()
                                        ->getTable(std::string(node->tablename))
                                        ->getProjectoin(0));  // todo

        //				// change for selecting best projection
        //				tablescan=new
        // LogicalScan(Environment::getInstance()->getCatalog()->getTable(std::string(node->tablename))->get_table_id());//
      } else  // need to modify the output_schema_attrname from the subquery to
              // the form of subquery's alias.attrname
      {
        tablescan = parsetree2logicalplan(node->subquery);
        vector<Attribute> output_attribute =
            tablescan->GetPlanContext().attribute_list_;
        vector<QNode *> exprTree;
        string subquery_alias = string(node->astablename);
        for (int i = 0; i < output_attribute.size(); i++) {
          string attrname = output_attribute[i].attrName;
          int pos;
          for (pos = 0; pos < attrname.size() && attrname[pos] != '.'; pos++)
            ;
          if (pos < attrname.size()) {
            attrname = attrname.substr(pos + 1, attrname.size() - pos - 1);
          }
          exprTree.push_back(
              new QColcumns(subquery_alias.c_str(), attrname.c_str(),
                            output_attribute[i].attrType->type,
                            string(subquery_alias + "." + attrname).c_str()));
          //					cout<<"The "<<i<<"
          //"<<subquery_alias+"."+attrname<<endl;
        }
        tablescan = new LogicalProject(tablescan, exprTree);
      }
      Expr_list_header *whcdn = (Expr_list_header *)node->whcdn;
      if (whcdn->header != NULL) {
        assert(tablescan != NULL);
        Node *p;
        bool hasin = false;
        vector<QNode *> v_qual;
        for (p = whcdn->header; p != NULL; p = ((Expr_list *)p)->next) {
          QNode *qual =
              transformqual((Node *)((Expr_list *)p)->data, tablescan);
          v_qual.push_back(qual);
        }
        LogicalOperator *filter = new LogicalFilter(tablescan, v_qual);
        if (hasin == true) {
          for (p = whcdn->header; p != NULL; p = ((Expr_list *)p)->next) {
            filter = solve_insubquery(((Expr_list *)p)->data, filter);
          }
        }
        return filter;
      } else {
        return tablescan;
      }

    } break;
    case t_from_list:  //由from_list递归进入args/next,并获得在其上的equaljoin
    {
      From_list *node = (From_list *)parsetree;
      LogicalOperator *filter_1 = where_from2logicalplan(node->args);
      LogicalOperator *filter_2 =
          where_from2logicalplan(node->next);  // maybe NULL
      LogicalOperator *lopfrom = NULL;
      if (filter_2 == NULL)  // a join b on c where a.a>0;
      {
        Expr_list_header *whcdn = (Expr_list_header *)node->whcdn;
        if (whcdn->header != NULL) {
          Node *p;
          vector<QNode *> v_qual;
          for (
              p = whcdn->header; p != NULL;
              p = ((Expr_list *)
                   p)->next)  //应该根据getdataflow的信息确定joinpair跟filter1/2是否一致
          {
            QNode *qual =
                transformqual((Node *)((Expr_list *)p)->data, filter_1);
            v_qual.push_back(qual);
          }
          if (v_qual.size() > 0) {
            lopfrom = new LogicalFilter(filter_1, v_qual);
          } else {
            lopfrom = filter_1;
          }
          return lopfrom;
        } else {
          return filter_1;
        }
      }
      Expr_list_header *whcdn = (Expr_list_header *)node->whcdn;
      if (whcdn->header != NULL) {
        vector<LogicalEqualJoin::JoinPair> join_pair_list;
        Node *p;
        vector<QNode *> v_qual;
        vector<Node *> raw_qual;
        for (p = whcdn->header; p != NULL; p = ((Expr_list *)p)->next) {
          int fg = getjoinpairlist((Node *)((Expr_list *)p)->data,
                                   join_pair_list, filter_1, filter_2);
          if (fg == 0)  // get raw qualification from whcdn
          {
            raw_qual.push_back((Node *)((Expr_list *)p)->data);
          }
        }
        if (join_pair_list.size() > 0) {
          lopfrom = new LogicalEqualJoin(join_pair_list, filter_1, filter_2);
        } else  // other join
        {
          lopfrom = new LogicalCrossJoin(filter_1, filter_2);
        }
        for (int i = 0; i < raw_qual.size(); i++) {
          v_qual.push_back(transformqual(raw_qual[i], lopfrom));
        }
        if (v_qual.size() > 0) {
          lopfrom = new LogicalFilter(lopfrom, v_qual);
        }
        return lopfrom;
      } else  // other to crossjoin
      {
        lopfrom = new LogicalCrossJoin(filter_1, filter_2);
        return lopfrom;
      }

    } break;
    case t_join: {
      Join *node = (Join *)parsetree;
      LogicalOperator *filter_1 = where_from2logicalplan(node->lnext);
      LogicalOperator *filter_2 = where_from2logicalplan(node->rnext);
      if (node->condition != NULL) {
        vector<LogicalEqualJoin::JoinPair> join_pair_list;
        Node *p;
        vector<QNode *> v_qual;
        vector<Node *> raw_qual;
        for (p = node->condition; p != NULL; p = ((Expr_list *)p)->next) {
          int fg = getjoinpairlist((Node *)((Expr_list *)p)->data,
                                   join_pair_list, filter_1, filter_2);
          if (fg == 0)  // get raw qualification from whcdn
          {
            raw_qual.push_back((Node *)((Expr_list *)p)->data);
          }
        }

        LogicalOperator *join;
        if (join_pair_list.size() > 0) {
          join = new LogicalEqualJoin(join_pair_list, filter_1, filter_2);
        } else  // other join
        {
          join = new LogicalCrossJoin(filter_1, filter_2);
        }
        for (int i = 0; i < raw_qual.size(); i++) {
          v_qual.push_back(transformqual(raw_qual[i], join));
        }
        if (v_qual.size() > 0) {
          join = new LogicalFilter(join, v_qual);
        }
        return join;
      } else  // other to crossjoin
      {
        LogicalOperator *join = new LogicalCrossJoin(filter_1, filter_2);
        return join;
      }

    } break;
    default: {
      SQLParse_elog("parsetree2logicalplan type error");
      return NULL;
    }
  }
  return NULL;
}
コード例 #14
0
ファイル: Analyzer.cpp プロジェクト: yestodaylee/CLAIMS
Histogram* Analyzer::computeHistogram(const AttributeID& attr_id,
                                      const unsigned nbuckets) {
  printf("Compute for histogram for attribute %s (%d buckets)\n",
         Catalog::getInstance()
             ->getTable(attr_id.table_id)
             ->getAttribute(attr_id.offset)
             .attrName.c_str(),
         nbuckets);
  Catalog* catalog = Catalog::getInstance();

  TableDescriptor* table = catalog->getTable(attr_id.table_id);
  ProjectionDescriptor* projection = NULL;

  unsigned pidSize = table->getNumberOfProjection();
  const Attribute attr = table->getAttribute(attr_id.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);
    }
  }

  Histogram* stat = new Histogram(nbuckets);

  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();
  return stat;
}