// _____________________________________________________________________________
ParsedQuery SparqlParser::parse(const string& query) {
ParsedQuery result;
result._originalString = query;
// Split prologue
size_t i = query.find("SELECT");
if (i == string::npos) {
throw ParseException("Missing keyword \"SELECT\", "
"currently only select queries are supported.");
}
size_t j = query.find("WHERE");
if (j == string::npos) {
throw ParseException("Missing keyword \"WHERE\", "
"currently only select queries are supported.");
}
if (i >= j) {
throw ParseException("Keyword \"WHERE\" "
"found after keyword \"SELECT\". Invalid query.");
}
size_t k = query.find("}", j);
if (k == string::npos) {
throw ParseException("Missing \"}\" symbol after \"WHERE\".");
}
parsePrologue(ad_utility::strip(query.substr(0, i), " \n\t"), result);
parseSelect(ad_utility::strip(query.substr(i, j - i), " \n\t"), result);
parseWhere(ad_utility::strip(query.substr(j, k - j + 1), " \n\t"), result);
parseSolutionModifiers(ad_utility::strip(query.substr(k + 1), " \n\t"),
result);
return result;
}
PARSENODE_PTR SQLParser::parseStatement() {
if (!startsStatement(nowReading)) {
syntaxError(nowReading, "expect start token!");
return nullptr;
}
if (startsCreate(nowReading)) {
return parseCreate();
}
else if (startsSelect(nowReading)) {
return parseSelect();
}
else if (startsDelete(nowReading)) {
return parseDelete();
}
else if (startsInsert(nowReading)) {
return parseInsert();
}
else if (startsDrop(nowReading)) {
return parseDrop();
}
else if (nowReading == QUIT) {
readToken();
expect(TERMINATOR);
return PARSENODE_PTR(new ParseNode(QUIT));
}
else if (nowReading == EXECFILE) {
readToken();
expect(TERMINATOR);
return PARSENODE_PTR(new ParseNode(EXECFILE));
}
else {
assert(false);
return nullptr;
}
}
static int
parseSelect(char *resReq, struct resVal *resVal, struct lsInfo *lsInfo, bool_t parseXor, int options)
{
static char fname[] = "parseSelect";
int cc;
enum syntaxType syntax;
char *expr, *countPtr;
int i, numXorExprs;
struct resVal tmpResVal;
char *resReq2 = NULL;
if (logclass & (LC_TRACE | LC_SCHED))
ls_syslog(LOG_DEBUG3, "%s: resReq=%s", fname, resReq);
if (parseXor && resReq[0] != '\0') {
countPtr = (char *)malloc(strlen(resReq)+1);
if (countPtr == NULL) {
return(PARSE_BAD_MEM);
}
strcpy(countPtr, resReq);
expr = strtok(countPtr, ",");
if (expr == NULL) {
numXorExprs = 0;
} else {
numXorExprs = 1;
while (strtok(NULL, ",")) {
numXorExprs++;
}
}
free(countPtr);
if (logclass & (LC_TRACE |LC_SCHED))
ls_syslog(LOG_DEBUG3,"%s: numXorExprs = %d", fname, numXorExprs);
if (numXorExprs > 1) {
resVal->xorExprs =
(char **)calloc(numXorExprs + 1, sizeof(char*));
if (resVal->xorExprs == NULL)
return(PARSE_BAD_MEM);
resReq2 = (char *)malloc(strlen(resReq) + numXorExprs * 4 - 1);
if ( resReq2== NULL)
return (PARSE_BAD_MEM);
resReq2[0] = '\0';
expr = strtok(resReq, ",");
for ( i =0 ; i < numXorExprs; i++) {
initResVal(&tmpResVal);
ALLOC_STRING(tmpResVal.selectStr, tmpResVal.selectStrSize,
MAX(3*strlen(expr) + 1, MAXLINELEN + MAXLSFNAMELEN));
if (tmpResVal.selectStr == NULL) {
FREEUP(resReq2);
return PARSE_BAD_MEM;
}
if (setDefaults(&tmpResVal, lsInfo, options) < 0) {
FREEUP(resReq2);
return (PARSE_BAD_MEM);
}
if ((cc = parseSelect(expr, &tmpResVal, lsInfo, FALSE, options)) != PARSE_OK) {
for (i--;i>=0; i--) {
FREEUP(resVal->xorExprs[i]);
}
FREEUP(resReq2);
return cc;
}
resVal->xorExprs[i] =
(char *)calloc(strlen(tmpResVal.selectStr) + 1,
sizeof(char));
if (resVal->xorExprs[i] == NULL)
return (PARSE_BAD_MEM);
strcpy(resVal->xorExprs[i], tmpResVal.selectStr);
if (logclass & (LC_TRACE | LC_SCHED))
ls_syslog(LOG_DEBUG3,"%s: xorExprs[%d] = %s", fname, i, resVal->xorExprs[i]);
if (i == 0 ) {
sprintf(resReq2, "(%s)", expr);
} else {
sprintf(resReq2, "%s||(%s)", resReq2, expr);
}
freeResVal(&tmpResVal);
expr = strtok(NULL, ",");
}
resVal->xorExprs[i] = NULL;
if (logclass & (LC_TRACE | LC_SCHED))
ls_syslog(LOG_DEBUG3,"%s: new selectStr=%s", fname, resReq2);
resReq = resReq2;
} else {
if (numXorExprs == 1) {
if (strchr(resReq,',')) {
return(PARSE_BAD_EXP);
}
} else {
return(PARSE_BAD_EXP);
}
}
}
syntax = getSyntax(resReq);
switch(syntax) {
case OLD:
if ((cc =resToClassOld(resReq, resVal, lsInfo)) != PARSE_OK) {
resVal->selectStr[0] = '\0';
FREEUP(resReq2);
return cc;
}
break;
case NEW:
if ((cc =resToClassNew(resReq, resVal, lsInfo)) != PARSE_OK) {
resVal->selectStr[0] = '\0';
FREEUP(resReq2);
return cc;
}
break;
case EITHER:
if ((cc =resToClassOld(resReq, resVal, lsInfo)) != PARSE_OK) {
if (cc == PARSE_BAD_NAME || cc == PARSE_BAD_VAL) {
resVal->selectStr[0] = '\0';
FREEUP(resReq2);
return cc;
}
if ( (cc =resToClassNew(resReq, resVal, lsInfo)) != PARSE_OK) {
resVal->selectStr[0] = '\0';
FREEUP(resReq2);
return cc;
}
}
break;
default:
FREEUP(resReq2);
return PARSE_BAD_EXP;
}
FREEUP(resReq2);
return PARSE_OK;
}
int
parseResReq(char *resReq,
struct resVal *resVal,
struct lsInfo *lsInfo,
int options)
{
static char fname[] = "parseResReq()";
int cc;
struct sections reqSect;
if (logclass & (LC_TRACE | LC_SCHED))
ls_syslog(LOG_DEBUG3, "%s: resReq=%s", fname, resReq);
initResVal(resVal);
ALLOC_STRING(resVal->selectStr,
resVal->selectStrSize,
MAX(3*strlen(resReq) + 1, MAXLINELEN + MAXLSFNAMELEN));
if ((cc = parseSection(resReq, &reqSect)) != PARSE_OK)
return cc;
if ((cc = setDefaults(resVal, lsInfo, options)) < 0)
return cc;
if (options & PR_SELECT) {
if (options & PR_XOR) {
if ((cc = parseSelect(reqSect.select,
resVal,
lsInfo,
TRUE,
options)) != PARSE_OK)
return cc;
} else {
if ((cc = parseSelect(reqSect.select,
resVal,
lsInfo,
FALSE,
options)) != PARSE_OK)
return cc;
}
}
if (options & PR_ORDER) {
if ((cc = parseOrder(reqSect.order,
resVal,
lsInfo)) != PARSE_OK)
return cc;
}
if (options & PR_RUSAGE) {
if ((cc = parseUsage(reqSect.rusage,
resVal,
lsInfo)) != PARSE_OK)
return cc;
}
if (options & PR_FILTER) {
if ((cc = parseFilter(reqSect.filter,
resVal,
lsInfo)) != PARSE_OK)
return cc;
}
if (options & PR_SPAN) {
if ((cc = parseSpan(reqSect.span,
resVal)) != PARSE_OK)
return cc;
}
return(PARSE_OK);
}
