format lookup

src/graph/context/ast/QueryAstContext.h

@@ -113,6 +113,9 @@ struct LookupContext final : public AstContext {
  int32_t schemaId{-1};
  int32_t limit{-1};
  Expression* filter{nullptr};
+ YieldColumns* yieldExpr{nullptr};
+ std::vector<std::string> idxReturnCols;
+ std::vector<std::string> idxColNames;
  // order by
 };
 

src/graph/planner/ngql/LookupPlanner.cpp

@@ -6,30 +6,17 @@
 
 #include "graph/planner/ngql/LookupPlanner.h"
 
-#include <algorithm>
-#include <tuple>
 
 #include "common/base/Base.h"
-#include "common/base/Status.h"
-#include "common/expression/Expression.h"
-#include "common/expression/LabelAttributeExpression.h"
-#include "common/expression/PropertyExpression.h"
 #include "graph/context/ast/QueryAstContext.h"
 #include "graph/planner/Planner.h"
 #include "graph/planner/plan/Scan.h"
-#include "graph/visitor/FindVisitor.h"
 #include "parser/Clauses.h"
 #include "parser/TraverseSentences.h"
 
 namespace nebula {
 namespace graph {
 
-static std::tuple<const char*, const char*> kEdgeKeys[3] = {
- {kSrcVID, kSrc},
- {kDstVID, kDst},
- {kRanking, kRank},
-};
-
 std::unique_ptr<Planner> LookupPlanner::make() {
  return std::unique_ptr<LookupPlanner>(new LookupPlanner());
 }
@@ -40,7 +27,6 @@ bool LookupPlanner::match(AstContext* astCtx) {
 
 StatusOr<SubPlan> LookupPlanner::transform(AstContext* astCtx) {
  auto lookupCtx = static_cast<LookupContext*>(astCtx);
- auto yieldCols = prepareReturnCols(lookupCtx);
  auto qctx = lookupCtx->qctx;
  auto from = static_cast<const LookupSentence*>(lookupCtx->sentence)->from();
  SubPlan plan;
@@ -50,7 +36,7 @@ StatusOr<SubPlan> LookupPlanner::transform(AstContext* astCtx) {
  from,
  lookupCtx->space.id,
  {},
- returnCols_,
+ lookupCtx->idxReturnCols,
  lookupCtx->schemaId,
  lookupCtx->isEmptyResultSet);
  } else {
@@ -59,90 +45,21 @@ StatusOr<SubPlan> LookupPlanner::transform(AstContext* astCtx) {
  from,
  lookupCtx->space.id,
  {},
- returnCols_,
+ lookupCtx->idxReturnCols,
  lookupCtx->schemaId,
  lookupCtx->isEmptyResultSet);
  }
- plan.tail->setColNames(colNames_);
+ plan.tail->setColNames(lookupCtx->idxColNames);
 
  plan.root = plan.tail;
 
  if (lookupCtx->filter) {
  plan.root = Filter::make(qctx, plan.root, lookupCtx->filter);
  }
 
- plan.root = Project::make(qctx, plan.root, yieldCols);
+ plan.root = Project::make(qctx, plan.root, lookupCtx->yieldExpr);
  return plan;
 }
 
-YieldColumns* LookupPlanner::prepareReturnCols(LookupContext* lookupCtx) {
- auto pool = lookupCtx->qctx->objPool();
- auto columns = pool->makeAndAdd<YieldColumns>();
- auto addColumn = [this, pool, columns](const auto& tup) {
- std::string name(std::get<0>(tup));
- auto expr = InputPropertyExpression::make(pool, name);
- columns->addColumn(new YieldColumn(expr, name));
- addLookupColumns(std::get<1>(tup), name);
- };
- if (lookupCtx->isEdge) {
- for (auto& key : kEdgeKeys) {
- addColumn(key);
- }
- } else {
- addColumn(std::make_tuple(kVertexID, kVid));
- }
- extractUsedColumns(lookupCtx->filter);
- appendColumns(lookupCtx, columns);
- return columns;
-}
-
-void LookupPlanner::appendColumns(LookupContext* lookupCtx, YieldColumns* columns) {
- auto sentence = static_cast<LookupSentence*>(lookupCtx->sentence);
- auto yieldClause = sentence->yieldClause();
- if (yieldClause == nullptr) return;
- auto pool = lookupCtx->qctx->objPool();
- for (auto col : yieldClause->columns()) {
- auto expr = col->expr();
- DCHECK(expr->kind() == Expression::Kind::kLabelAttribute);
- auto laExpr = static_cast<LabelAttributeExpression*>(expr);
- const auto& schemaName = laExpr->left()->name();
- const auto& colName = laExpr->right()->value().getStr();
- Expression* propExpr = nullptr;
- if (lookupCtx->isEdge) {
- propExpr = EdgePropertyExpression::make(pool, schemaName, colName);
- } else {
- propExpr = TagPropertyExpression::make(pool, schemaName, colName);
- }
- columns->addColumn(new YieldColumn(propExpr, col->alias()));
- addLookupColumns(colName, propExpr->toString());
- }
-}
-
-void LookupPlanner::extractUsedColumns(Expression* filter) {
- if (filter == nullptr) return;
-
- auto finder = [](Expression* expr) {
- return expr->kind() == Expression::Kind::kTagProperty ||
- expr->kind() == Expression::Kind::kEdgeProperty;
- };
- FindVisitor visitor(finder, true);
- filter->accept(&visitor);
- for (auto expr : std::move(visitor).results()) {
- auto propExpr = static_cast<const PropertyExpression*>(expr);
- addLookupColumns(propExpr->prop(), propExpr->toString());
- }
-}
-
-void LookupPlanner::addLookupColumns(const std::string& retCol, const std::string& outCol) {
- auto iter = std::find(returnCols_.begin(), returnCols_.end(), retCol);
- if (iter == returnCols_.end()) {
- returnCols_.emplace_back(retCol);
- }
- iter = std::find(colNames_.begin(), colNames_.end(), outCol);
- if (iter == colNames_.end()) {
- colNames_.emplace_back(outCol);
- }
-}
-
 } // namespace graph
 } // namespace nebula

src/graph/planner/ngql/LookupPlanner.h

@@ -7,9 +7,6 @@
 #ifndef GRAPH_PLANNER_NGQL_LOOKUPPLANNER_H_
 #define GRAPH_PLANNER_NGQL_LOOKUPPLANNER_H_
 
-#include <memory>
-#include <string>
-
 #include "graph/planner/Planner.h"
 
 namespace nebula {
@@ -28,15 +25,6 @@ class LookupPlanner final : public Planner {
  static bool match(AstContext* astCtx);
 
  StatusOr<SubPlan> transform(AstContext* astCtx) override;
-
- private:
- YieldColumns* prepareReturnCols(LookupContext* lookupCtx);
- void appendColumns(LookupContext* lookupCtx, YieldColumns* columns);
- void extractUsedColumns(Expression* filter);
- void addLookupColumns(const std::string& retCol, const std::string& outCol);
-
- std::vector<std::string> returnCols_;
- std::vector<std::string> colNames_;
 };
 
 } // namespace graph

src/graph/validator/LookupValidator.cpp

@@ -13,7 +13,9 @@
 #include "graph/util/ExpressionUtils.h"
 #include "graph/util/FTIndexUtils.h"
 #include "graph/util/SchemaUtil.h"
+#include "graph/util/ValidateUtil.h"
 #include "interface/gen-cpp2/meta_types.h"
+#include "parser/TraverseSentences.h"
 
 using nebula::meta::NebulaSchemaProvider;
 using std::shared_ptr;
@@ -38,13 +40,13 @@ AstContext* LookupValidator::getAstContext() { return lookupCtx_.get(); }
 Status LookupValidator::validateImpl() {
  lookupCtx_ = getContext<LookupContext>();
 
- NG_RETURN_IF_ERROR(prepareFrom());
- NG_RETURN_IF_ERROR(prepareYield());
- NG_RETURN_IF_ERROR(prepareFilter());
+ NG_RETURN_IF_ERROR(validateFrom());
+ NG_RETURN_IF_ERROR(validateFilter());
+ NG_RETURN_IF_ERROR(validateYield());
  return Status::OK();
 }
 
-Status LookupValidator::prepareFrom() {
+Status LookupValidator::validateFrom() {
  auto spaceId = lookupCtx_->space.id;
  auto from = sentence()->from();
  auto ret = qctx_->schemaMng()->getSchemaIDByName(spaceId, from);
@@ -54,51 +56,152 @@ Status LookupValidator::prepareFrom() {
  return Status::OK();
 }
 
-Status LookupValidator::prepareYield() {
+Status LookupValidator::extractSchemaProp() {
+ shared_ptr<const NebulaSchemaProvider> schema;
+ NG_RETURN_IF_ERROR(getSchemaProvider(&schema));
+ for (std::size_t i = 0; i < schema->getNumFields(); ++i) {
+ const auto& propName = schema->getFieldName(i);
+ auto iter = std::find(idxReturnCols_.begin(), idxReturnCols_.end(), propName);
+ if (iter == idxReturnCols_.end()) {
+ idxReturnCols_.emplace_back(propName);
+ }
+ }
+ return Status::OK();
+}
+
+void LookupValidator::extractExprProps() {
+ auto addProps = [this](const std::set<folly::StringPiece>& propNames) {
+ for (const auto& propName : propNames) {
+ auto iter = std::find(idxReturnCols_.begin(), idxReturnCols_.end(), propName);
+ if (iter == idxReturnCols_.end()) {
+ idxReturnCols_.emplace_back(propName);
+ }
+ }
+ };
+ auto from = sentence()->from();
+ auto buildColNames = [&from](const std::string& colName) { return from + '.' + colName; };
  if (lookupCtx_->isEdge) {
+ for (const auto& edgeProp : exprProps_.edgeProps()) {
+ addProps(edgeProp.second);
+ }
+ std::vector<std::string> idxColNames = idxReturnCols_;
+ std::transform(idxColNames.begin(), idxColNames.end(), idxColNames.begin(), buildColNames);
+ lookupCtx_->idxColNames = std::move(idxColNames);
+ } else {
+ for (const auto& tagProp : exprProps_.tagProps()) {
+ addProps(tagProp.second);
+ }
+ std::vector<std::string> idxColNames = idxReturnCols_;
+ std::transform(idxColNames.begin(), idxColNames.end(), idxColNames.begin(), buildColNames);
+ idxColNames[0] = nebula::kVid;
+ lookupCtx_->idxColNames = std::move(idxColNames);
+ }
+ lookupCtx_->idxReturnCols = std::move(idxReturnCols_);
+}
+
+Status LookupValidator::validateYieldEdge() {
+ auto yield = sentence()->yieldClause();
+ auto yieldExpr = lookupCtx_->yieldExpr;
+ for (auto col : yield->columns()) {
+ if (ExpressionUtils::hasAny(col->expr(),
+ {Expression::Kind::kPathBuild, Expression::Kind::kVertex})) {
+ return Status::SemanticError("illegal yield clauses `%s'", col->toString().c_str());
+ }
+ if (ExpressionUtils::hasAny(col->expr(), {Expression::Kind::kEdge})) {
+ NG_RETURN_IF_ERROR(extractSchemaProp());
+ }
+ if (col->expr()->kind() == Expression::Kind::kLabelAttribute) {
+ const auto& schemaName = static_cast<LabelAttributeExpression*>(col->expr())->left()->name();
+ if (schemaName != sentence()->from()) {
+ return Status::SemanticError("Schema name error: %s", schemaName.c_str());
+ }
+ }
+ col->setExpr(ExpressionUtils::rewriteLabelAttr2EdgeProp(col->expr()));
+ NG_RETURN_IF_ERROR(ValidateUtil::invalidLabelIdentifiers(col->expr()));
+
+ auto colExpr = col->expr();
+ auto typeStatus = deduceExprType(colExpr);
+ NG_RETURN_IF_ERROR(typeStatus);
+ outputs_.emplace_back(col->name(), typeStatus.value());
+ yieldExpr->addColumn(col->clone().release());
+ NG_RETURN_IF_ERROR(deduceProps(colExpr, exprProps_));
+ }
+ return Status::OK();
+}
+
+Status LookupValidator::validateYieldTag() {
+ auto yield = sentence()->yieldClause();
+ auto yieldExpr = lookupCtx_->yieldExpr;
+ for (auto col : yield->columns()) {
+ if (ExpressionUtils::hasAny(col->expr(),
+ {Expression::Kind::kPathBuild, Expression::Kind::kEdge})) {
+ return Status::SemanticError("illegal yield clauses `%s'", col->toString().c_str());
+ }
+ if (ExpressionUtils::hasAny(col->expr(), {Expression::Kind::kVertex})) {
+ NG_RETURN_IF_ERROR(extractSchemaProp());
+ }
+ if (col->expr()->kind() == Expression::Kind::kLabelAttribute) {
+ const auto& schemaName = static_cast<LabelAttributeExpression*>(col->expr())->left()->name();
+ if (schemaName != sentence()->from()) {
+ return Status::SemanticError("Schema name error: %s", schemaName.c_str());
+ }
+ }
+ col->setExpr(ExpressionUtils::rewriteLabelAttr2TagProp(col->expr()));
+ NG_RETURN_IF_ERROR(ValidateUtil::invalidLabelIdentifiers(col->expr()));
+
+ auto colExpr = col->expr();
+ auto typeStatus = deduceExprType(colExpr);
+ NG_RETURN_IF_ERROR(typeStatus);
+ outputs_.emplace_back(col->name(), typeStatus.value());
+ yieldExpr->addColumn(col->clone().release());
+ NG_RETURN_IF_ERROR(deduceProps(colExpr, exprProps_));
+ }
+ return Status::OK();
+}
+
+Status LookupValidator::validateYield() {
+ auto pool = qctx_->objPool();
+ auto* newCols = pool->add(new YieldColumns());
+ lookupCtx_->yieldExpr = newCols;
+ if (lookupCtx_->isEdge) {
+ idxReturnCols_.emplace_back(kSrc);
+ idxReturnCols_.emplace_back(kDst);
+ idxReturnCols_.emplace_back(kRank);
+ idxReturnCols_.emplace_back(kType);
  outputs_.emplace_back(kSrcVID, vidType_);
  outputs_.emplace_back(kDstVID, vidType_);
  outputs_.emplace_back(kRanking, Value::Type::INT);
+ newCols->addColumn(new YieldColumn(ColumnExpression::make(pool, 0), kSrcVID));
+ newCols->addColumn(new YieldColumn(ColumnExpression::make(pool, 1), kDstVID));
+ newCols->addColumn(new YieldColumn(ColumnExpression::make(pool, 2), kRanking));
  } else {
+ idxReturnCols_.emplace_back(kVid);
  outputs_.emplace_back(kVertexID, vidType_);
+ newCols->addColumn(new YieldColumn(ColumnExpression::make(pool, 0), kVertexID));
  }
 
  auto yieldClause = sentence()->yieldClause();
  if (yieldClause == nullptr) {
+ extractExprProps();
  return Status::OK();
  }
  lookupCtx_->dedup = yieldClause->isDistinct();
-
- shared_ptr<const NebulaSchemaProvider> schemaProvider;
- NG_RETURN_IF_ERROR(getSchemaProvider(&schemaProvider));
-
- auto from = sentence()->from();
- for (auto col : yieldClause->columns()) {
- if (col->expr()->kind() != Expression::Kind::kLabelAttribute) {
- // TODO(yee): support more exprs, such as (player.age + 1) AS age
- return Status::SemanticError("Yield clauses are not supported: `%s'",
- col->toString().c_str());
- }
- auto la = static_cast<LabelAttributeExpression*>(col->expr());
- const std::string& schemaName = la->left()->name();
- if (schemaName != from) {
- return Status::SemanticError("Schema name error: %s", schemaName.c_str());
- }
-
- const auto& value = la->right()->value();
- DCHECK(value.isStr());
- const std::string& colName = value.getStr();
- auto ret = schemaProvider->getFieldType(colName);
- if (ret == meta::cpp2::PropertyType::UNKNOWN) {
- return Status::SemanticError(
- "Column `%s' not found in schema `%s'", colName.c_str(), from.c_str());
- }
- outputs_.emplace_back(col->name(), SchemaUtil::propTypeToValueType(ret));
+ if (lookupCtx_->isEdge) {
+ NG_RETURN_IF_ERROR(validateYieldEdge());
+ } else {
+ NG_RETURN_IF_ERROR(validateYieldTag());
+ }
+ if (exprProps_.hasInputVarProperty()) {
+ return Status::SemanticError("unsupport input/variable property expression in yield.");
+ }
+ if (exprProps_.hasSrcDstTagProperty()) {
+ return Status::SemanticError("unsupport src/dst property expression in yield.");
  }
+ extractExprProps();
  return Status::OK();
 }
 
-Status LookupValidator::prepareFilter() {
+Status LookupValidator::validateFilter() {
  auto whereClause = sentence()->whereClause();
  if (whereClause == nullptr) {
  return Status::OK();
@@ -120,6 +223,7 @@ Status LookupValidator::prepareFilter() {
  NG_RETURN_IF_ERROR(ret);
  lookupCtx_->filter = std::move(ret).value();
  }
+ NG_RETURN_IF_ERROR(deduceProps(lookupCtx_->filter, exprProps_));
  return Status::OK();
 }