521 lines
16 KiB
C++
521 lines
16 KiB
C++
/*=============================================================================
|
|
# Filename: Strategy.cpp
|
|
# Author: Bookug Lobert
|
|
# Mail: zengli-bookug@pku.edu.cn
|
|
# Last Modified: 2016-05-07 16:31
|
|
# Description: implement functions in Strategy.h
|
|
=============================================================================*/
|
|
|
|
#include "Strategy.h"
|
|
|
|
using namespace std;
|
|
|
|
Strategy::Strategy()
|
|
{
|
|
this->method = 0;
|
|
this->kvstore = NULL;
|
|
this->vstree = NULL;
|
|
//this->prepare_handler();
|
|
}
|
|
|
|
Strategy::Strategy(KVstore* _kvstore, VSTree* _vstree, TYPE_TRIPLE_NUM* _pre2num, TYPE_PREDICATE_ID _limitID_predicate, TYPE_ENTITY_LITERAL_ID _limitID_literal)
|
|
{
|
|
this->method = 0;
|
|
this->kvstore = _kvstore;
|
|
this->vstree = _vstree;
|
|
this->pre2num = _pre2num;
|
|
this->limitID_predicate = _limitID_predicate;
|
|
this->limitID_literal = _limitID_literal;
|
|
//this->prepare_handler();
|
|
}
|
|
|
|
Strategy::~Strategy()
|
|
{
|
|
//delete[] this->dispatch;
|
|
}
|
|
|
|
//void
|
|
//Strategy::prepare_handler()
|
|
//{
|
|
//this->dispatch = new QueryHandler[Strategy::QUERY_HANDLER_NUM];
|
|
//this->dispatch[0] = Strategy::handler0;
|
|
//}
|
|
|
|
//NOTICE: 2-triple case ?s1 p1 c0 ?s2 p2 c0 is viewed as an unconnected graph
|
|
//however, this can be dealed due to several basic queries and linking
|
|
|
|
bool
|
|
Strategy::handle(SPARQLquery& _query, ResultFilter* _result_filter)
|
|
{
|
|
#ifdef MULTI_INDEX
|
|
Util::logging("IN GeneralEvaluation::handle");
|
|
|
|
vector<BasicQuery*>& queryList = _query.getBasicQueryVec();
|
|
// enumerate each BasicQuery and retrieve their variables' mapping entity in the VSTree.
|
|
vector<BasicQuery*>::iterator iter = queryList.begin();
|
|
for (; iter != queryList.end(); iter++)
|
|
if ((**iter).getEncodeBasicQueryResult())
|
|
{
|
|
this->method = -1;
|
|
|
|
vector<unsigned*>& result_list = (*iter)->getResultList();
|
|
//int select_var_num = (*iter)->getSelectVarNum();
|
|
//the num of vars needing to be joined, i.e. selectVarNum if only one triple
|
|
int varNum = (*iter)->getVarNum();
|
|
//all variables(not including pre vars)
|
|
int total_num = (*iter)->getTotalVarNum();
|
|
int pre_varNum = (*iter)->getPreVarNum();
|
|
int selected_pre_var_num = (*iter)->getSelectedPreVarNum();
|
|
int selected_var_num = (*iter)->getSelectVarNum();
|
|
|
|
//NOTICE: special case - query vertices only connected via same variables
|
|
//all constant triples will be viewed as unconnected, if a triple has no variable,
|
|
//then this triple is a BGP(no other triples in this BGP)
|
|
if(total_num == 0 && pre_varNum == 0)
|
|
{
|
|
this->method = 5;
|
|
}
|
|
else if ((*iter)->getTripleNum() == 1 && pre_varNum == 1)
|
|
{
|
|
this->method = 4;
|
|
}
|
|
|
|
if (this->method < 0 && pre_varNum == 0 && (*iter)->getTripleNum() == 1) //only one triple and no predicates
|
|
{
|
|
//only one variable and one triple: ?s pre obj or sub pre ?o
|
|
if (total_num == 1)
|
|
{
|
|
this->method = 1;
|
|
}
|
|
//only two vars: ?s pre ?o
|
|
else if (total_num == 2)
|
|
{
|
|
if (varNum == 1) //the selected id should be 0
|
|
{
|
|
this->method = 2;
|
|
}
|
|
else //==2
|
|
{
|
|
this->method = 3;
|
|
}
|
|
}
|
|
//cout << "this BasicQuery use query strategy 2" << endl;
|
|
//cout<<"Final result size: "<<(*iter)->getResultList().size()<<endl;
|
|
//continue;
|
|
}
|
|
if(this->method< 0)
|
|
{
|
|
this->method = 0;
|
|
}
|
|
|
|
//QueryHandler dispatch;
|
|
//dispatch[0] = handler0;
|
|
switch (this->method)
|
|
{
|
|
//BETTER: use function pointer array in C++ class
|
|
case 0:
|
|
//default:filter by vstree and then verified by join
|
|
this->handler0(*iter, result_list, _result_filter);
|
|
break;
|
|
case 1:
|
|
this->handler1(*iter, result_list);
|
|
break;
|
|
case 2:
|
|
this->handler2(*iter, result_list);
|
|
break;
|
|
case 3:
|
|
this->handler3(*iter, result_list);
|
|
break;
|
|
case 4:
|
|
this->handler4(*iter, result_list);
|
|
break;
|
|
case 5:
|
|
this->handler5(*iter, result_list);
|
|
break;
|
|
default:
|
|
cout << "not support this method" << endl;
|
|
|
|
}
|
|
cout << "BasicQuery -- Final result size: " << (*iter)->getResultList().size() << endl;
|
|
}
|
|
#else
|
|
cout << "this BasicQuery use original query strategy" << endl;
|
|
long tv_handle = Util::get_cur_time();
|
|
(this->vstree)->retrieve(_query);
|
|
long tv_retrieve = Util::get_cur_time();
|
|
cout << "after Retrieve, used " << (tv_retrieve - tv_handle) << "ms." << endl;
|
|
|
|
this->join = new Join(kvstore, pre2num, this->limitID_predicate, this->limitID_literal);
|
|
this->join->join_sparql(_query);
|
|
delete this->join;
|
|
|
|
long tv_join = Util::get_cur_time();
|
|
cout << "after Join, used " << (tv_join - tv_retrieve) << "ms." << endl;
|
|
#endif
|
|
Util::logging("OUT Strategy::handle");
|
|
return true;
|
|
}
|
|
|
|
void
|
|
Strategy::handler0(BasicQuery* _bq, vector<unsigned*>& _result_list, ResultFilter* _result_filter)
|
|
{
|
|
//long before_filter = Util::get_cur_time();
|
|
cout << "this BasicQuery use query strategy 0" << endl;
|
|
|
|
//BETTER:not all vars in join filtered by vstree
|
|
//(A)-B-c: B should by vstree, then by c, but A should be generated in join(first set A as not)
|
|
//if A not in join, just filter B by pre
|
|
//divided into star graphs, join core vertices, generate satellites
|
|
//join should also start from a core vertex(neighbor can be constants or vars) if available
|
|
//
|
|
//QUERY: is there any case that a node should be retrieved by other index?(instead of vstree or generate whne join)
|
|
//
|
|
//we had better treat 1-triple case(no ?p) as special, and then in other cases, core vertex exist(if connected)
|
|
//However, if containing ?p and 1-triple, we should treat it also as a special case, or select a variable as core vertex
|
|
//and retrieved (for example, ?s ?p o or s ?p ?o, generally no core vertex in these cases)
|
|
|
|
long tv_handle = Util::get_cur_time();
|
|
int varNum = _bq->getVarNum(); //the num of vars needing to be joined
|
|
//TODO:parallel by pthread
|
|
for (int i = 0; i < varNum; ++i)
|
|
{
|
|
if (_bq->if_need_retrieve(i) == false)
|
|
continue;
|
|
bool flag = _bq->isLiteralVariable(i);
|
|
const EntityBitSet& entityBitSet = _bq->getVarBitSet(i);
|
|
IDList* idListPtr = &(_bq->getCandidateList(i));
|
|
this->vstree->retrieveEntity(entityBitSet, idListPtr);
|
|
if (!flag)
|
|
{
|
|
//cout<<"set ready: "<<i<<endl;
|
|
_bq->setReady(i);
|
|
}
|
|
//the basic query should end if one non-literal var has no candidates
|
|
if (idListPtr->size() == 0 && !flag)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
//BETTER:end directly if one is empty!
|
|
|
|
long tv_retrieve = Util::get_cur_time();
|
|
cout << "after Retrieve, used " << (tv_retrieve - tv_handle) << "ms." << endl;
|
|
|
|
//between retrieve and join
|
|
if (_result_filter != NULL)
|
|
_result_filter->candFilterWithResultHashTable(*_bq);
|
|
|
|
Join *join = new Join(kvstore, pre2num, this->limitID_predicate, this->limitID_literal);
|
|
join->join_basic(_bq);
|
|
delete join;
|
|
|
|
long tv_join = Util::get_cur_time();
|
|
cout << "after Join, used " << (tv_join - tv_retrieve) << "ms." << endl;
|
|
}
|
|
|
|
void
|
|
Strategy::handler1(BasicQuery* _bq, vector<unsigned*>& _result_list)
|
|
{
|
|
long before_filter = Util::get_cur_time();
|
|
cout << "this BasicQuery use query strategy 1" << endl;
|
|
//int neighbor_id = (*_bq->getEdgeNeighborID(0, 0); //constant, -1
|
|
char edge_type = _bq->getEdgeType(0, 0);
|
|
int triple_id = _bq->getEdgeID(0, 0);
|
|
Triple triple = _bq->getTriple(triple_id);
|
|
TYPE_PREDICATE_ID pre_id = _bq->getEdgePreID(0, 0);
|
|
unsigned* id_list = NULL;
|
|
unsigned id_list_len = 0;
|
|
if (edge_type == Util::EDGE_OUT)
|
|
{
|
|
//cout<<"edge out!!!"<<endl;
|
|
TYPE_ENTITY_LITERAL_ID nid = (this->kvstore)->getIDByEntity(triple.object);
|
|
//if (nid == -1)
|
|
if (nid == INVALID_ENTITY_LITERAL_ID)
|
|
{
|
|
nid = (this->kvstore)->getIDByLiteral(triple.object);
|
|
}
|
|
this->kvstore->getsubIDlistByobjIDpreID(nid, pre_id, id_list, id_list_len);
|
|
}
|
|
else
|
|
{
|
|
//cout<<"edge in!!!"<<endl;
|
|
this->kvstore->getobjIDlistBysubIDpreID(this->kvstore->getIDByEntity(triple.subject), pre_id, id_list, id_list_len);
|
|
}
|
|
|
|
long after_filter = Util::get_cur_time();
|
|
cout << "after filter, used " << (after_filter - before_filter) << "ms" << endl;
|
|
_result_list.clear();
|
|
//cout<<"now to copy result to list"<<endl;
|
|
for (unsigned i = 0; i < id_list_len; ++i)
|
|
{
|
|
unsigned* record = new unsigned[1]; //only this var is selected
|
|
record[0] = id_list[i];
|
|
//cout<<this->kvstore->getEntityByID(record[0])<<endl;
|
|
_result_list.push_back(record);
|
|
}
|
|
long after_copy = Util::get_cur_time();
|
|
cout << "after copy to result list: used " << (after_copy - after_filter) << " ms" << endl;
|
|
delete[] id_list;
|
|
cout << "Final result size: " << _result_list.size() << endl;
|
|
}
|
|
|
|
void
|
|
Strategy::handler2(BasicQuery* _bq, vector<unsigned*>& _result_list)
|
|
{
|
|
long before_filter = Util::get_cur_time();
|
|
cout << "this BasicQuery use query strategy 2" << endl;
|
|
int triple_id = _bq->getEdgeID(0, 0);
|
|
Triple triple = _bq->getTriple(triple_id);
|
|
TYPE_PREDICATE_ID pre_id = _bq->getEdgePreID(0, 0);
|
|
|
|
//NOTICE:it is ok for var1 or var2 to be -1, i.e. not encoded
|
|
int var1_id = _bq->getIDByVarName(triple.subject);
|
|
int var2_id = _bq->getIDByVarName(triple.object);
|
|
|
|
unsigned* id_list = NULL;
|
|
unsigned id_list_len = 0;
|
|
if (var1_id == 0) //subject var selected
|
|
{
|
|
//use p2s directly
|
|
this->kvstore->getsubIDlistBypreID(pre_id, id_list, id_list_len);
|
|
}
|
|
else if (var2_id == 0) //object var selected
|
|
{
|
|
//use p2o directly
|
|
this->kvstore->getobjIDlistBypreID(pre_id, id_list, id_list_len);
|
|
}
|
|
else
|
|
{
|
|
cout << "ERROR in Database::handle(): no selected var!" << endl;
|
|
}
|
|
long after_filter = Util::get_cur_time();
|
|
cout << "after filter, used " << (after_filter - before_filter) << "ms" << endl;
|
|
_result_list.clear();
|
|
for (unsigned i = 0; i < id_list_len; ++i)
|
|
{
|
|
unsigned* record = new unsigned[1]; //only one var
|
|
record[0] = id_list[i];
|
|
_result_list.push_back(record);
|
|
}
|
|
long after_copy = Util::get_cur_time();
|
|
cout << "after copy to result list: used " << (after_copy - after_filter) << " ms" << endl;
|
|
delete[] id_list;
|
|
cout << "Final result size: " << _result_list.size() << endl;
|
|
}
|
|
|
|
void
|
|
Strategy::handler3(BasicQuery* _bq, vector<unsigned*>& _result_list)
|
|
{
|
|
long before_filter = Util::get_cur_time();
|
|
cout << "this BasicQuery use query strategy 3" << endl;
|
|
int triple_id = _bq->getEdgeID(0, 0);
|
|
Triple triple = _bq->getTriple(triple_id);
|
|
TYPE_PREDICATE_ID pre_id = _bq->getEdgePreID(0, 0);
|
|
unsigned* id_list = NULL;
|
|
unsigned id_list_len = 0;
|
|
|
|
_result_list.clear();
|
|
this->kvstore->getsubIDobjIDlistBypreID(pre_id, id_list, id_list_len);
|
|
int var1_id = _bq->getSelectedVarPosition(triple.subject);
|
|
int var2_id = _bq->getSelectedVarPosition(triple.object);
|
|
|
|
if(var1_id < 0 || var2_id < 0)
|
|
{
|
|
delete[] id_list;
|
|
return;
|
|
}
|
|
|
|
long after_filter = Util::get_cur_time();
|
|
cout << "after filter, used " << (after_filter - before_filter) << "ms" << endl;
|
|
|
|
for (unsigned i = 0; i < id_list_len; i += 2)
|
|
{
|
|
unsigned* record = new unsigned[2]; //2 vars and selected
|
|
record[var1_id] = id_list[i];
|
|
record[var2_id] = id_list[i + 1];
|
|
_result_list.push_back(record);
|
|
}
|
|
|
|
long after_copy = Util::get_cur_time();
|
|
cout << "after copy to result list: used " << (after_copy - after_filter) << " ms" << endl;
|
|
delete[] id_list;
|
|
cout << "Final result size: " << _result_list.size() << endl;
|
|
}
|
|
|
|
void
|
|
Strategy::handler4(BasicQuery* _bq, vector<unsigned*>& _result_list)
|
|
{
|
|
cout<<"Special Case: consider pre var in this triple"<<endl;
|
|
int varNum = _bq->getVarNum();
|
|
//all variables(not including pre vars)
|
|
int total_num = _bq->getTotalVarNum();
|
|
int pre_varNum = _bq->getPreVarNum();
|
|
int selected_pre_var_num = _bq->getSelectedPreVarNum();
|
|
int selected_var_num = _bq->getSelectVarNum();
|
|
Triple triple = _bq->getTriple(0);
|
|
int pvpos = _bq->getSelectedPreVarPosition(triple.predicate);
|
|
|
|
unsigned* id_list = NULL;
|
|
unsigned id_list_len = 0;
|
|
_result_list.clear();
|
|
|
|
//cout<<"total num: "<<total_num <<endl;
|
|
if (total_num == 2)
|
|
{
|
|
cout<<"Special Case 1"<<endl;
|
|
int svpos = _bq->getSelectedVarPosition(triple.subject);
|
|
int ovpos = _bq->getSelectedVarPosition(triple.object);
|
|
cout<<"subject: "<<triple.subject<<" "<<svpos<<endl;
|
|
cout<<"object: "<<triple.object<<" "<<ovpos<<endl;
|
|
cout<<"predicate: "<<triple.predicate<<" "<<pvpos<<endl;
|
|
//very special case, to find all triples, select ?s (?p) ?o where { ?s ?p ?o . }
|
|
//filter and join is too costly, should enum all predicates and use p2so
|
|
for(TYPE_PREDICATE_ID i = 0; i < this->limitID_predicate; ++i)
|
|
{
|
|
TYPE_PREDICATE_ID pid = i;
|
|
this->kvstore->getsubIDobjIDlistBypreID(pid, id_list, id_list_len);
|
|
int rsize = selected_var_num;
|
|
if(selected_pre_var_num == 1)
|
|
{
|
|
rsize++;
|
|
}
|
|
|
|
//always place s/o before p in result list
|
|
for (unsigned j = 0; j < id_list_len; j += 2)
|
|
{
|
|
unsigned* record = new unsigned[rsize];
|
|
//check the s/o var if selected, need to ensure the placement order
|
|
if(ovpos >= 0)
|
|
{
|
|
record[ovpos] = id_list[j+1];
|
|
}
|
|
if(svpos >= 0)
|
|
{
|
|
record[svpos] = id_list[j];
|
|
}
|
|
|
|
if(pvpos >= 0)
|
|
{
|
|
record[pvpos] = pid; //for the pre var
|
|
}
|
|
_result_list.push_back(record);
|
|
}
|
|
delete[] id_list;
|
|
}
|
|
id_list = NULL;
|
|
}
|
|
else if (total_num == 1)
|
|
{
|
|
cout<<"Special Case 2"<<endl;
|
|
int vpos = -1;
|
|
if(triple.subject[0] != '?') //constant
|
|
{
|
|
TYPE_ENTITY_LITERAL_ID sid = (this->kvstore)->getIDByEntity(triple.subject);
|
|
this->kvstore->getpreIDobjIDlistBysubID(sid, id_list, id_list_len);
|
|
vpos = _bq->getSelectedVarPosition(triple.object);
|
|
}
|
|
else if(triple.object[0] != '?') //constant
|
|
{
|
|
TYPE_ENTITY_LITERAL_ID oid = (this->kvstore)->getIDByEntity(triple.object);
|
|
//if (oid == -1)
|
|
if (oid == INVALID_ENTITY_LITERAL_ID)
|
|
{
|
|
oid = (this->kvstore)->getIDByLiteral(triple.object);
|
|
}
|
|
this->kvstore->getpreIDsubIDlistByobjID(oid, id_list, id_list_len);
|
|
vpos = _bq->getSelectedVarPosition(triple.subject);
|
|
}
|
|
|
|
int rsize = varNum;
|
|
if(selected_pre_var_num == 1)
|
|
{
|
|
rsize++;
|
|
}
|
|
//always place s/o before p in result list
|
|
for (unsigned i = 0; i < id_list_len; i += 2)
|
|
{
|
|
unsigned* record = new unsigned[rsize];
|
|
if(vpos >= 0)
|
|
{
|
|
record[vpos] = id_list[i + 1]; //for the s/o var
|
|
}
|
|
if(pvpos >= 0)
|
|
{
|
|
record[pvpos] = id_list[i]; //for the pre var
|
|
}
|
|
_result_list.push_back(record);
|
|
}
|
|
}
|
|
else if (total_num == 0) //only ?p and it must be selected
|
|
{
|
|
cout<<"Special Case 3"<<endl;
|
|
//just use so2p
|
|
unsigned sid = (this->kvstore)->getIDByEntity(triple.subject);
|
|
unsigned oid = (this->kvstore)->getIDByEntity(triple.object);
|
|
if (oid == -1)
|
|
{
|
|
oid = (this->kvstore)->getIDByLiteral(triple.object);
|
|
}
|
|
|
|
this->kvstore->getpreIDlistBysubIDobjID(sid, oid, id_list, id_list_len);
|
|
//copy to result list
|
|
for (unsigned i = 0; i < id_list_len; ++i)
|
|
{
|
|
unsigned* record = new unsigned[1];
|
|
record[0] = id_list[i];
|
|
_result_list.push_back(record);
|
|
}
|
|
}
|
|
|
|
delete[] id_list;
|
|
}
|
|
|
|
//TODO:if any constants in a query are not found in kvstore, then this BGP should end to speed up the processing
|
|
|
|
void
|
|
Strategy::handler5(BasicQuery* _bq, vector<unsigned*>& _result_list)
|
|
{
|
|
cout<<"Special Case: consider constant triple"<<endl;
|
|
Triple triple = _bq->getTriple(0);
|
|
_result_list.clear();
|
|
|
|
TYPE_ENTITY_LITERAL_ID subid = this->kvstore->getIDByEntity(triple.subject);
|
|
//if(subid == -1) //not found
|
|
if(subid == INVALID_ENTITY_LITERAL_ID) //not found
|
|
{
|
|
return;
|
|
}
|
|
TYPE_PREDICATE_ID preid = this->kvstore->getIDByPredicate(triple.predicate);
|
|
//if(preid == -1) //not found
|
|
if(preid == INVALID_PREDICATE_ID) //not found
|
|
{
|
|
return;
|
|
}
|
|
TYPE_ENTITY_LITERAL_ID objid = this->kvstore->getIDByEntity(triple.object);
|
|
//if(objid == -1)
|
|
if(objid == INVALID_ENTITY_LITERAL_ID)
|
|
{
|
|
objid = this->kvstore->getIDByLiteral(triple.object);
|
|
}
|
|
//if(objid == -1)
|
|
if(objid == INVALID_ENTITY_LITERAL_ID)
|
|
{
|
|
return;
|
|
}
|
|
|
|
unsigned* id_list = NULL;
|
|
unsigned id_list_len = 0;
|
|
(this->kvstore)->getobjIDlistBysubIDpreID(subid, preid, id_list, id_list_len);
|
|
if (Util::bsearch_int_uporder(objid, id_list, id_list_len) != INVALID)
|
|
{
|
|
unsigned* record = new unsigned[3];
|
|
record[0] = subid;
|
|
record[1] = preid;
|
|
record[2] = objid;
|
|
_result_list.push_back(record);
|
|
}
|
|
delete[] id_list;
|
|
}
|
|
|