Tash (ট্যাশ)

Tash (ট্যাশ) is a small Open Source (FreeBSD License) C++ library for ArangoDB Database which includes APIs for HTTP based document access and a query builder for AQL (Arango Query Language).

• Building
• Basic Example
• Query builder

---

Building

prerequisites

• C++ compiler
• CMake
• boost library
• nlohmann::json [OPTIONAL] (tash ships with a single file version of nlohmann::json)

compiling

git clone https://gitlab.com/neel.basu/tash.git
mkdir build
cd build
cmake ..
make

Basic Example

#include<iostream>
#include<tash/arango.h>
#include<boost/format.hpp>
#include<boost/beast/http/status.hpp>intmain(){
tash::shell school("school"); // shell("school", "localhost", 8529, "root", "root")if(school.exists() == boost::beast::http::status::not_found){
school.create();
}
tash::vertex students(school, "students");
if(students.exists() == boost::beast::http::status::not_found){
students.create();
}
nlohmann::json document = {
{"name", "Hijibijbij"},
{"fathers_name", "Hijibijbij"},
{"uncles_name", "Hijibijbij"}
};
boost::beast::http::status status = students.add(document);
if(status == boost::beast::http::status::accepted){
std::cout << boost::format("document created with key %1%") % document["_key"] << std::endl;
}else{
std::cout << "Failed to create document with error " << status << std::endl;
}
nlohmann::json hijibijbij = students.by_key(document["_key"].get<std::string>());
std::cout << "retrieved document " << std::endl;
std::cout << hijibijbij << std::endl;
return0;
}

AQL (Arango Query Language) Builder

Retrieve / Filter / Sort

tash::shell shell("school"); // shell("school", "localhost", 8529, "root", "root")
shell << select("s").in("students") // use select instead of FOR because for is a C++ keyword
/ filter((clause("s.name") == name) && (clause("s.fathers_name") == name)) // using std::string puts quotes around the value
/ sort().asc("s._key")
/ yield("s"); // use yield instead of RETURN because return is a C++ keyword
nlohmann::json result;
shell >> result;

FOR s IN students
FILTER s.name == "Hijibijbij" AND s.fathers_name == "Hijibijbij"
SORT s._key ASC RETURN s

select("s").in("students") / filter((clause("s.name") == "s.fathers_name")) // using C string doesn't put quotes around the value
/ sort().asc("s._key")
/ yield("s"); 

FOR s IN students
FILTER s.name == s.fathers_name
SORT s._key ASC RETURN s

insert

insert single row

insert(nlohmann::json{
{"name", "tash"},
{"fathers_name", "tash"}
}).in("students");

INSERT {"fathers_name":"tash","name":"tash"} INTO students

insert multiple rows

select("u").in({
{"name", "tash"},
{"fathers_name", "tash"}
}) / insert("u").in("students")

FOR u IN {"fathers_name":"tash","name":"tash"}
INSERT u INTO students

generate rows

• in nlohmann::json string values are always quoted
• tash::assign generates non-nested key value pairs (non-nested json)
• C style strings are unquoted, std::string is quoted

select("i").in(1, 10) / insert(
assign("name", "CONCAT('tash', i)")
.assign("gender", "(i % 2 == 0 ? 'f' : 'm')")
.assign("fathers_name", std::string("tash"))
).in("users")

FOR i IN 1..10
INSERT {
name: CONCAT('test', i), gender: (i % 2 == 0 ? 'f' : 'm'),
fathers_name: "tash"
} INTO users

update

update(nlohmann::json{
{"_key", 1234}
}).with({
{"uncles_name", "tash"}
}).in("students")

UPDATE {"_key":1234} WITH {"uncles_name":"tash"} IN students

let

 (let("date") = "DATE_NOW()")
/ select("user").in("users")
/ filter(clause("user.isImportantUser") == "null")
/ (let("numberOfLogins") = select("login").in("logins")
/ filter(clause("login.user") == "user._key")
/ collect().with("COUNT").in("numLogins")
/ yield("numLogins")
)
/ filter(clause("numberOfLogins") > 50)
/ update("user").with(
assign("isImportantUser", 1)
.assign("dateBecameImportant", "date")
.assign("uncles_name", std::string("tash"))
).in("users")

LET date = DATE_NOW()
FOR user IN users
FILTER user.isImportantUser == null
LET numberOfLogins = (
FOR login IN logins
FILTER login.user == user._key
COLLECT WITH COUNT INTO numLogins
RETURN numLogins
)
FILTER numberOfLogins > 50
UPDATE user WITH {
isImportantUser: 1, dateBecameImportant: date,
uncles_name: "tash"
} IN users

replace

replace(nlohmann::json{
{"_key", 1234}
}).with({
{"name", "tash"},
{"uncles_name", "tash"}
}).in("students")

REPLACE {"_key":1234} WITH {
"name":"tash",
"uncles_name":"tash"
} IN students

remove

erase(assign("_key", "1")).in("students")

REMOVE {_key: 1} IN students

upsert

upsert(nlohmann::json{
{"name", "tokai"}
}).insert({
{"name", "tokai"},
{"fathers_name", "tokai"}
}).update({
{"name", "tokai"},
{"fathers_name", "tokai"}
}).in("students")

UPSERT {"name":"tokai"} INSERT {"fathers_name":"tokai","name":"tokai"} UPDATE {"fathers_name":"tokai","name":"tokai"}
IN students

create graph

auto graph = ddl::graph_definition("corpus")
.add_edge_definition(ddl::edge_definition("StructuralE").add_from("Word").add_to("Word").add_to("Sentence"))
.add_edge_definition(ddl::edge_definition("WNeighbourhoodE").add_from("Word").add_to("Word"))
.add_edge_definition(ddl::edge_definition("InstanceE").add_from("Word").add_to("Vocabulary"));
query("_api/gharial", graph.json().dump());

create aql function

std::string function_str = R"( function(p1, p2){ // function body })";
auto fnc = nlohmann::json({
{"name", "NS::FNAME"},
{"code", function_str},
{"isDeterministic", true}
});
query("_api/aqlfunction", fnc.dump());