Example #1
0
bool Plan::fromFile(const char* fileName) {
   std::ifstream file(fileName);
   if (!file.is_open())
      return false;
   std::string token;
   file >> token;
   root = std::move(buildOperator(token));
   parse(*root, file);
   return true;
}
Example #2
0
//iterate through stringstream from its end and parse operands(simple predicates) and operators(composite logical operations)
Predicate* PredicateBuilder::build(string predicateLine) {
	predicate_stack = new stack<Predicate*>();
	stringstream saver("");
	bool operand = true;
	try {
		for (int i = predicateLine.length() - 1; i >= 0; i--) {

			if (predicateLine[i] == ')') continue;

			if (predicateLine[i] == ',' || predicateLine[i] == '(') {
				string op = saver.str(); /*rotiranje stringa*/
				strRotate(op);
				if (operand) buildOperand(op);
				else buildOperator(op);
				saver.str(""); /*resetujem stream*/
				if (predicateLine[i] == '(') operand = false;
				else operand = true;
				continue;
			}

			if (predicateLine[i] == ' ' && !operand) {
				continue;
			}
			saver << predicateLine[i];
		}

		string op = saver.str();
		strRotate(op);
		if (!operand) buildOperator(op);
		else buildOperand(op);

		root = predicate_stack->top();
		predicate_stack->pop();
	}
	catch (EXCEPTION* e) {
		root = nullptr; 
	}

	delete predicate_stack; // delete memory allocated for stack

	return root; // return pointer to first operator in composite predicate
}
Example #3
0
static void parse(PlanOperator& op, std::ifstream& i) {
   switch (op.getOperatorType()) {
      case OperatorType::TableScan: {
         TableScan& t = static_cast<TableScan&>(op);
         i >> t.name;
         break;
      }
      case OperatorType::MergeJoin: {
         MergeJoin& m = static_cast<MergeJoin&>(op);
         readIntList(m.attributeIdsLeft, i);
         m.cmp = readComparator(i);
         readIntList(m.attributeIdsRight, i);
         std::string opCode;
         i >> opCode;
         std::unique_ptr<PlanOperator> l(std::move(buildOperator(opCode)));
         parse(*l, i);
         m.setLeft(l);
         i >> opCode;
         std::unique_ptr<PlanOperator> r(std::move(buildOperator(opCode)));
         parse(*r, i);
         m.setRight(r);
         break;
      }
      case OperatorType::Select: {
         Select& s = static_cast<Select&>(op);
         readIntList(s.attributeIds, i);
         s.cmp = readComparator(i);
         std::string constant;
         for (unsigned j=0, limit=s.attributeIds.size(); j<limit; ++j) {
            i >> constant;
            s.constants.push_back(constant);
         }
         std::string opCode;
         i >> opCode;
         std::unique_ptr<PlanOperator> c(std::move(buildOperator(opCode)));
         parse(*c, i);
         s.setChild(c);
         break;
      }
      case OperatorType::Project: {
         Project& p = static_cast<Project&>(op);
         readIntList(p.attributeIds, i);
         std::string opCode;
         i >> opCode;
         std::unique_ptr<PlanOperator> c(std::move(buildOperator(opCode)));
         parse(*c, i);
         p.setChild(c);
         break;
      }
      case OperatorType::Sort: {
         Sort& s = static_cast<Sort&>(op);
         readIntList(s.attributeIds, i);
         s.order = readSortOrder(i);
         std::string opCode;
         i >> opCode;
         std::unique_ptr<PlanOperator> c(std::move(buildOperator(opCode)));
         parse(*c, i);
         s.setChild(c);
         break;
      }
      default: throw;
   }
}