SchemaVer ver,

bool hasProp) {

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(ver));

if (!hasProp) {

return schema;

}

schema->addField(

"name", PropertyType::STRING, 0, false, ConstantExpression::make(pool, "")->encode());

// only age filed has no default value and nullable is false

schema->addField("age", PropertyType::INT64, 0, false);

schema->addField(

"playing", PropertyType::BOOL, 0, false, ConstantExpression::make(pool, true)->encode());

schema->addField(

"career", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 10L)->encode());

schema->addField(

"startYear", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 0L)->encode());

schema->addField(

"endYear", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 0L)->encode());

schema->addField(

"games", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 0L)->encode());

schema->addField(

"avgScore", PropertyType::DOUBLE, 0, false, ConstantExpression::make(pool, 0.0)->encode());

schema->addField(

"serveTeams", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 0L)->encode());

// Set ttl property

if (FLAGS_mock_ttl_col) {

schema->addField(

"insertTime", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 0L)->encode());

meta::cpp2::SchemaProp prop;

prop.ttl_col_ref() = "insertTime";

prop.ttl_duration_ref() = FLAGS_mock_ttl_duration;

schema->setProp(prop);

}

// Use default value

schema->addField("country",

PropertyType::STRING,

0,

false,

ConstantExpression::make(pool, "America")->encode());

// Use nullable

schema->addField("champions", PropertyType::INT64, 0, true);

return schema;

bool hasProp) {

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(ver));

if (!hasProp) {

return schema;

}

schema->addField("name", PropertyType::STRING);

return schema;

SchemaVer ver,

bool hasProp) {

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(ver));

if (!hasProp) {

return schema;

}

schema->addField(

"playerName", PropertyType::STRING, 0, false, ConstantExpression::make(pool, "")->encode());

schema->addField(

"teamName", PropertyType::STRING, 0, false, ConstantExpression::make(pool, "")->encode());

schema->addField(

"startYear", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 2020L)->encode());

schema->addField(

"endYear", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 2020L)->encode());

// only teamCareer filed has no default value and nullable is false

schema->addField("teamCareer", PropertyType::INT64, 0, false);

schema->addField(

"teamGames", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 1L)->encode());

schema->addField("teamAvgScore",

PropertyType::DOUBLE,

0,

false,

ConstantExpression::make(pool, 0.0)->encode());

// Set ttl property

if (FLAGS_mock_ttl_col) {

schema->addField(

"insertTime", PropertyType::INT64, 0, false, ConstantExpression::make(pool, 0L)->encode());

meta::cpp2::SchemaProp prop;

prop.ttl_col_ref() = "insertTime";

prop.ttl_duration_ref() = FLAGS_mock_ttl_duration;

schema->setProp(prop);

}

// Use default value

schema->addField(

"type", PropertyType::STRING, 0, false, ConstantExpression::make(pool, "trade")->encode());

// Use nullable

schema->addField("champions", PropertyType::INT64, 0, true);

return schema;

bool hasProp) {

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(ver));

if (!hasProp) {

return schema;

}

schema->addField("player1", PropertyType::STRING);

schema->addField("player2", PropertyType::STRING);

schema->addField("teamName", PropertyType::STRING);

schema->addField("startYear", PropertyType::INT64);

schema->addField("endYear", PropertyType::INT64);

return schema;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col;

col.name = "col_bool";

col.type.type_ref() = PropertyType::BOOL;

cols.emplace_back(std::move(col));

col.name = "col_int";

col.type.type_ref() = PropertyType::INT64;

cols.emplace_back(std::move(col));

col.name = "col_float";

col.type.type_ref() = PropertyType::FLOAT;

cols.emplace_back(std::move(col));

col.name = "col_double";

col.type.type_ref() = PropertyType::DOUBLE;

cols.emplace_back(std::move(col));

col.name = "col_str";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

return cols;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col;

col.name = "name";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

col.name = "age";

col.type.type_ref() = PropertyType::INT64;

cols.emplace_back(std::move(col));

col.name = "playing";

col.type.type_ref() = PropertyType::BOOL;

cols.emplace_back(std::move(col));

return cols;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col;

col.name = "name";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

return cols;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col;

col.name = "col_date";

col.type.type_ref() = PropertyType::DATE;

cols.emplace_back(std::move(col));

return cols;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col;

col.name = "playerName";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

col.name = "teamName";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

col.name = "startYear";

col.type.type_ref() = PropertyType::INT64;

cols.emplace_back(std::move(col));

return cols;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col;

col.name = "player1";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

col.name = "player2";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

col.name = "teamName";

col.type.type_ref() = PropertyType::FIXED_STRING;

col.type.type_length_ref() = 20;

cols.emplace_back(std::move(col));

return cols;

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(0));

schema->addField("col_bool", PropertyType::BOOL);

schema->addField("col_int", PropertyType::INT64);

schema->addField("col_float", PropertyType::FLOAT);

schema->addField("col_double", PropertyType::DOUBLE);

schema->addField("col_str", PropertyType::STRING);

return schema;

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(1));

schema->addField("col_bool", PropertyType::BOOL);

schema->addField("col_int", PropertyType::INT64);

schema->addField("col_float", PropertyType::FLOAT);

schema->addField("col_double", PropertyType::DOUBLE);

schema->addField("col_str", PropertyType::STRING);

schema->addField("col_int8", PropertyType::INT8);

schema->addField("col_int16", PropertyType::INT16);

schema->addField("col_int32", PropertyType::INT32);

schema->addField("col_timestamp", PropertyType::TIMESTAMP);

schema->addField("col_date", PropertyType::DATE);

schema->addField("col_datetime", PropertyType::DATETIME);

return schema;

std::shared_ptr<meta::NebulaSchemaProvider> schema(new meta::NebulaSchemaProvider(0));

schema->addField("col_bool", PropertyType::BOOL);

schema->addField("col_bool_null", PropertyType::BOOL, 0, true);

schema->addField("col_bool_default",

PropertyType::BOOL,

0,

false,

ConstantExpression::make(pool, true)->encode());

schema->addField("col_int", PropertyType::INT64);

schema->addField("col_int_null", PropertyType::INT64, 0, true);

schema->addField("col_int_default",

PropertyType::INT64,

0,

false,

ConstantExpression::make(pool, 20L)->encode());

schema->addField("col_float", PropertyType::FLOAT);

schema->addField("col_float_null", PropertyType::FLOAT, 0, true);

schema->addField("col_float_default",

PropertyType::FLOAT,

0,

false,

ConstantExpression::make(pool, 2.2F)->encode());

schema->addField("col_str", PropertyType::STRING);

schema->addField("col_str_null", PropertyType::STRING, 0, true);

schema->addField("col_str_default",

PropertyType::STRING,

0,

false,

ConstantExpression::make(pool, "sky")->encode());

schema->addField("col_date", PropertyType::DATE);

schema->addField("col_date_null", PropertyType::DATE, 0, true);

const Date date = {2020, 2, 20};

schema->addField("col_date_default",

PropertyType::DATE,

0,

false,

ConstantExpression::make(pool, date)->encode());

return schema;

std::vector<nebula::meta::cpp2::ColumnDef> cols;

meta::cpp2::ColumnDef col_bool;

col_bool.name = "col_bool";

col_bool.type.type_ref() = PropertyType::BOOL;

cols.emplace_back(std::move(col_bool));

meta::cpp2::ColumnDef col_bool_null;

col_bool_null.name = "col_bool_null";

col_bool_null.type.type_ref() = PropertyType::BOOL;

col_bool_null.nullable_ref() = true;

cols.emplace_back(std::move(col_bool_null));

meta::cpp2::ColumnDef col_bool_default;

col_bool_default.name = "col_bool_default";

col_bool_default.type.type_ref() = PropertyType::BOOL;

cols.emplace_back(std::move(col_bool_default));

meta::cpp2::ColumnDef col_int;

col_int.name = "col_int";

col_int.type.type_ref() = PropertyType::INT64;

cols.emplace_back(std::move(col_int));

meta::cpp2::ColumnDef col_int_null;

col_int_null.name = "col_int_null";

col_int_null.type.type_ref() = PropertyType::INT64;

col_int_null.nullable_ref() = true;

cols.emplace_back(std::move(col_int_null));

meta::cpp2::ColumnDef col_float;

col_float.name = "col_float";

col_float.type.type_ref() = PropertyType::FLOAT;

cols.emplace_back(std::move(col_float));

meta::cpp2::ColumnDef col_float_null;

col_float_null.name = "col_float_null";

col_float_null.type.type_ref() = PropertyType::FLOAT;

col_float_null.nullable_ref() = true;

cols.emplace_back(std::move(col_float_null));

meta::cpp2::ColumnDef col_str;

col_str.name = "col_str";

col_str.type.type_ref() = PropertyType::FIXED_STRING;

col_str.type.type_length_ref() = 20;

cols.emplace_back(std::move(col_str));

meta::cpp2::ColumnDef col_str_null;

col_str_null.name = "col_str_null";

col_str_null.type.type_ref() = PropertyType::FIXED_STRING;

col_str_null.type.type_length_ref() = 20;

col_str_null.nullable_ref() = true;

cols.emplace_back(std::move(col_str_null));

meta::cpp2::ColumnDef col_date;

col_date.name = "col_date";

col_date.type.type_ref() = PropertyType::DATE;

cols.emplace_back(std::move(col_date));

meta::cpp2::ColumnDef col_date_null;

col_date_null.name = "col_date_null";

col_date_null.type.type_ref() = PropertyType::DATE;

col_date_null.nullable_ref() = true;

cols.emplace_back(std::move(col_date_null));

return cols;

std::vector<VertexData> ret;

// Multiple vertices, each vertex has two tags, player and team

// player tagId is 1, team tagId is 2

for (auto& player : players_) {

VertexData data;

data.tId_ = 1;

std::vector<Value> props;

if (upper) {

std::string upperName;

upperName.resize(player.name_.size());

auto toupper = [](auto c) { return ::toupper(c); };

std::transform(player.name_.begin(), player.name_.end(), upperName.begin(), toupper);

data.vId_ = upperName;

props.emplace_back(upperName);

} else {

data.vId_ = player.name_;

props.emplace_back(player.name_);

}

props.emplace_back(player.age_);

props.emplace_back(player.playing_);

props.emplace_back(player.career_);

props.emplace_back(player.startYear_);

props.emplace_back(player.endYear_);

props.emplace_back(player.games_);

props.emplace_back(player.avgScore_);

props.emplace_back(player.serveTeams_);

// Use insert time as ttl col

if (FLAGS_mock_ttl_col) {

props.emplace_back(std::time(NULL));

}

// Use default value and nullable

if (player.country_.compare("") != 0) {

props.emplace_back(player.country_);

if (player.champions_) {

props.emplace_back(player.champions_);

}

}

data.props_ = std::move(props);

ret.emplace_back(std::move(data));

}

for (auto& team : teams_) {

VertexData data;

data.vId_ = team;

data.tId_ = 2;

std::vector<Value> props;

props.emplace_back(team);

data.props_ = std::move(props);

ret.emplace_back(std::move(data));

}

return ret;

std::vector<std::pair<PartitionID, std::string>> keys;

for (auto& player : players_) {

std::string name;

if (upper) {

std::string upperName;

upperName.resize(player.name_.size());

auto toupper = [](auto c) { return ::toupper(c); };

std::transform(player.name_.begin(), player.name_.end(), upperName.begin(), toupper);

name = upperName;

} else {

name = player.name_;

}

auto part = std::hash<std::string>()(name) % 6 + 1;

std::string values;

values.append(encodeFixedStr(name, 20));

values.append(IndexKeyUtils::encodeValue(player.age_));

values.append(IndexKeyUtils::encodeValue(player.playing_));

auto indexKeys = IndexKeyUtils::vertexIndexKeys(32, part, 1, name, {std::move(values)});

for (auto& indexKey : indexKeys) {

auto pair = std::make_pair(part, std::move(indexKey));

keys.emplace_back(std::move(pair));

}

}

return keys;

int32_t parts) {

std::unordered_map<PartitionID, std::vector<VertexData>> ret;

auto verticesVec = mockVertices();

for (auto& vertexData : verticesVec) {

auto partId = std::hash<std::string>()(vertexData.vId_) % parts + 1;

ret[partId].emplace_back(std::move(vertexData));

}

return ret;

std::vector<VertexID> ret;

// Multiple vertices, each vertex has two tags, player and team

// player tagId is 1, team tagId is 2

for (auto& player : players_) {

VertexID data;

data = player.name_;

ret.push_back(data);

}

for (auto& team : teams_) {

VertexID data;

data = team;

ret.push_back(data);

}

return ret;

std::vector<VertexID> ret;

for (auto& player : players_) {

VertexID data;

data = player.name_;

ret.push_back(data);

}

return ret;

std::vector<EdgeData> ret;

// Use serve data, positive edgeType is 101, reverse edgeType is -101

for (auto& serve : serves_) {

EdgeData positiveEdge;

positiveEdge.type_ = 101;

positiveEdge.rank_ = serve.startYear_;

positiveEdge.dstId_ = serve.teamName_;

std::vector<Value> props;

if (upper) {

std::string upperName;

upperName.resize(serve.playerName_.size());

auto toupper = [](auto c) { return ::toupper(c); };

std::transform(

serve.playerName_.begin(), serve.playerName_.end(), upperName.begin(), toupper);

positiveEdge.srcId_ = upperName;

props.emplace_back(upperName);

} else {

positiveEdge.srcId_ = serve.playerName_;

props.emplace_back(serve.playerName_);

}

props.emplace_back(serve.teamName_);

props.emplace_back(serve.startYear_);

props.emplace_back(serve.endYear_);

props.emplace_back(serve.teamCareer_);

props.emplace_back(serve.teamGames_);

props.emplace_back(serve.teamAvgScore_);

// Use insert time as ttl col

if (FLAGS_mock_ttl_col) {

props.emplace_back(std::time(NULL));

}

// Use default value and nullable

if (!serve.type_.empty()) {

props.emplace_back(serve.type_);

if (serve.champions_) {

props.emplace_back(serve.champions_);

}

}

positiveEdge.props_ = std::move(props);

auto reverseData = getReverseEdge(positiveEdge);

ret.emplace_back(std::move(positiveEdge));

if (hasInEdges) {

ret.emplace_back(std::move(reverseData));

}

}

return ret;

std::vector<std::pair<PartitionID, std::string>> keys;

for (auto& serve : serves_) {

auto part = std::hash<std::string>()(serve.playerName_) % 6 + 1;

std::string values;

values.append(encodeFixedStr(serve.playerName_, 20));

values.append(encodeFixedStr(serve.teamName_, 20));

values.append(IndexKeyUtils::encodeValue(serve.startYear_));

auto idxKeys = IndexKeyUtils::edgeIndexKeys(

32, part, 101, serve.playerName_, serve.startYear_, serve.teamName_, {std::move(values)});

for (auto& idxkey : idxKeys) {

auto pair = std::make_pair(part, std::move(idxkey));

keys.emplace_back(std::move(pair));

}

}

return keys;

auto ret = mockEdges();

for (const auto& teammate : teammates_) {

EdgeData data;

data.srcId_ = teammate.player1_;

data.type_ = 102, data.rank_ = teammate.startYear_;

data.dstId_ = teammate.player2_;

std::vector<Value> props;

props.emplace_back(teammate.player1_);

props.emplace_back(teammate.player2_);

props.emplace_back(teammate.teamName_);

props.emplace_back(teammate.startYear_);

props.emplace_back(teammate.endYear_);

data.props_ = std::move(props);

EdgeData antiData = data;

data.srcId_ = teammate.player2_;

data.dstId_ = teammate.player1_;

auto reverseData = getReverseEdge(data);

ret.emplace_back(std::move(data));

ret.emplace_back(std::move(reverseData));

auto reverseAntiData = getReverseEdge(antiData);

ret.emplace_back(std::move(antiData));

ret.emplace_back(std::move(reverseAntiData));

}

return ret;

std::unordered_map<PartitionID, std::vector<EdgeData>> ret;

auto edgesVec = mockEdges();

for (auto& EdgeData : edgesVec) {

auto partId = std::hash<std::string>()(EdgeData.srcId_) % parts + 1;

ret[partId].emplace_back(std::move(EdgeData));

}

return ret;

std::vector<EdgeData> ret;

// Use serve data, positive edgeType is 101, reverse edgeType is -101

for (auto& serve : serves_) {

EdgeData positiveEdge;

positiveEdge.srcId_ = serve.playerName_;

positiveEdge.type_ = 101;

positiveEdge.rank_ = serve.startYear_;

positiveEdge.dstId_ = serve.teamName_;

// Reverse edge

auto reverseEdge = getReverseEdge(positiveEdge);

ret.push_back(positiveEdge);

ret.push_back(reverseEdge);

}

return ret;

EdgeRanking rankCount) {

std::unordered_map<VertexID, std::vector<EdgeData>> ret;

// add multiple serve edge for benchmark

// Use serve data, EdgeType is 101, also use the rank as startYear and endYear

for (EdgeRanking rank = 0; rank < rankCount; rank++) {

for (const auto& serve : serves_) {

EdgeData data;

data.srcId_ = serve.playerName_;

data.type_ = 101;

data.rank_ = rank;

data.dstId_ = serve.teamName_;

std::vector<Value> props;

props.emplace_back(serve.playerName_);

props.emplace_back(serve.teamName_);

props.emplace_back(rank);

props.emplace_back(rank);

props.emplace_back(serve.teamCareer_);

props.emplace_back(serve.teamGames_);

props.emplace_back(serve.teamAvgScore_);

// Use insert time as ttl col

if (FLAGS_mock_ttl_col) {

props.emplace_back(std::time(NULL));

}

// Use default value and nullable

if (!serve.type_.empty()) {

props.emplace_back(serve.type_);

if (serve.champions_) {

props.emplace_back(serve.champions_);

}

}

data.props_ = std::move(props);

ret[data.srcId_].emplace_back(std::move(data));

}

}

return ret;

nebula::storage::cpp2::AddVerticesRequest req;

req.space_id_ref() = 1;

req.if_not_exists_ref() = true;

auto retRecs = mockVertices(upper);

for (auto& rec : retRecs) {

nebula::storage::cpp2::NewVertex newVertex;

nebula::storage::cpp2::NewTag newTag;

auto partId = std::hash<std::string>()(rec.vId_) % parts + 1;

newTag.tag_id_ref() = rec.tId_;

newTag.props_ref() = std::move(rec.props_);

std::vector<nebula::storage::cpp2::NewTag> newTags;

newTags.push_back(std::move(newTag));

newVertex.id_ref() = rec.vId_;

newVertex.tags_ref() = std::move(newTags);

(*req.parts_ref())[partId].emplace_back(std::move(newVertex));

}

return req;

nebula::storage::cpp2::DeleteVerticesRequest req;

req.space_id_ref() = 1;

auto retRecs = mockVerticeIds();

for (auto& rec : retRecs) {

auto partId = std::hash<std::string>()(rec) % parts + 1;

(*req.parts_ref())[partId].emplace_back(std::move(rec));

}

return req;

int32_t parts,

bool hasInEdges) {

nebula::storage::cpp2::AddEdgesRequest req;

req.space_id_ref() = 1;

req.if_not_exists_ref() = true;

auto retRecs = mockEdges(upper, hasInEdges);

for (auto& rec : retRecs) {

nebula::storage::cpp2::NewEdge newEdge;

nebula::storage::cpp2::EdgeKey edgeKey;

auto partId = std::hash<std::string>()(rec.srcId_) % parts + 1;

edgeKey.src_ref() = rec.srcId_;

edgeKey.edge_type_ref() = rec.type_;

edgeKey.ranking_ref() = rec.rank_;

edgeKey.dst_ref() = rec.dstId_;