Coverage report: /development/source/library/org/datagraph/spocq-shard/src/core/encoding/ssf-sparql-1-0-1.lisp

KindCoveredAll%
expression2575 33.3
branch16 16.7
Key
Not instrumented
Conditionalized out
Executed
Not executed
 
Both branches taken
One branch taken
Neither branch taken
1
 ;;; -*- Mode: lisp; Syntax: ansi-common-lisp; Base: 10; Package: org.datagraph.spocq.sparql-1-0-1; -*-
2
 
3
 (in-package :org.datagraph.spocq.sparql-1-0-1)
4
 
5
 
6
 ;;; reduction operators
7
 
8
 (defun |Aggregate-Constructor| (ArithmeticAggregate ConcatAggregate CountAggregate)
9
   (or ArithmeticAggregate ConcatAggregate CountAggregate))
10
 
11
 (defun |ArithmeticAggregate-Constructor| (ArithmeticAggregateOperator Distinctness? Expression)
12
   `(,ArithmeticAggregateOperator ,Expression
13
                                  ,@(when Distinctness? `(:distinct ,Distinctness?))))
14
 
15
 (defun |ArithmeticAggregateOperator-Constructor| (item)
16
   (if (eq (symbol-package item) *syntax-package*)
17
     (or (find-builtin-operator item)
18
         (error "Invalid built-in operator: '~a'." item))
19
     item))
20
 
21
 (defun |ConcatAggregate-Constructor| (Distinctness? Expression String)
22
   `(spocq.a:|group_concat| ,Expression
23
                            ,@(when Distinctness? `(:distinct ,Distinctness?))
24
                            ,@(when String `(:separator ,String))))
25
 
26
 (defun |CountAggregate-Constructor| (Distinctness? Expression Wild)
27
   `(spocq.a:|count| ,(or Expression Wild
28
                          (error "Either Expression or Wild is required."))
29
                     ,@(when Distinctness? `(:distinct ,Distinctness?))))
30
 
31
 (defun |PrimaryExpression-Constructor| (|Aggregate| |BooleanLiteral| |BrackettedExpression| |BuiltInCall|
32
                                         |IRIrefOrFunction| |NumericLiteral| |RDFLiteral| |Var|)
33
   (or |Aggregate| |BooleanLiteral| |BrackettedExpression| |BuiltInCall|
34
       |IRIrefOrFunction| |NumericLiteral| |RDFLiteral| |Var|))
35
 
36
 (defun |SelectQuery-Constructor| (|DatasetClause| |Distinctness| |SolutionModifier| |VarIableOrBinding*| |WhereClause| Wild)
37
   (update-dataset-graphs |DatasetClause| :query)
38
   (destructuring-bind (&key limit offset order group-by) |SolutionModifier|
39
     (declare (ignore group-by))
40
     (when order
41
         (setf |WhereClause| `(spocq.a:|order| ,|WhereClause| ,order)))
42
     (when |Distinctness|
43
       (let ((vob-variables (and (consp |VarIableOrBinding*|) (remove-if-not #'symbolp |VarIableOrBinding*|))))
44
         (if vob-variables
45
           (setf |WhereClause| `(,|Distinctness| (spocq.a:|project| ,|WhereClause| ,vob-variables)))
46
           (setf |WhereClause| `(,|Distinctness| ,|WhereClause|)))))
47
     (when (or limit offset)
48
       (setf |WhereClause| `(spocq.a:|slice| ,|WhereClause|
49
                                             ,@(when offset `(:offset ,offset))
50
                                             ,@(when limit `(:count ,limit))))))
51
   `(spocq.a:|select| ,|WhereClause|
52
                      ,(cond (Wild
53
                              (reverse *variables*))
54
                             (|VarIableOrBinding*|
55
                              (reverse |VarIableOrBinding*|))
56
                             (t
57
                              (error "Either VariableOrBinding or Wild is required.")))))
58
 
59
 (defun |VariableOrBinding-Constructor| (Expression Var)
60
   (if Expression
61
     `(,Var ,Expression)
62
     Var))
63
 
64
 (defun |Wild-Constructor| (item)
65
   item)
66
 
67
 
68
 #|
69
 ;;; to compile the parser state machine manually
70
 (load (compile-file #p"LIBRARY:org;datagraph;spocq;src;parser;sparql.lisp"))
71
 
72
 ;;; to translate the bnf into lisp
73
 ;;; requires the de.setf.atn-parser system
74
 (let ((bnfp:*class.atn* bnfp:*class.atn*)
75
       (bnfp:*class.atn-node* bnfp:*class.atn-node*)
76
       (bnfp:*class.cat-atn-edge* bnfp:*class.cat-atn-edge*)
77
       (bnfp:*class.pop-atn-edge* bnfp:*class.pop-atn-edge*)
78
       (bnfp:*class.push-atn-edge* bnfp:*class.push-atn-edge*)
79
       (bnfp:*class.test-atn-edge* bnfp:*class.test-atn-edge*))
80
   (bnfp:compile-atn-system  #p"P-LIBRARY:org;datagraph;spocq;src;core;encoding;sparql-1-0-1.bnf"
81
                             :execute t :compile nil
82
                             :token-package (find-package :spocq.s)
83
                             :source-package (find-package :sparql-1-0-1)
84
                             :source-pathname "P-LIBRARY:org;datagraph;spocq;src;core;encoding;sparql-1-0-1.lisp"
85
                             :input-function 'input-reference
86
                             :input-eof-function 'input-eof?
87
                             :ambiguous t
88
                             :trace nil))
89
 
90
 ;;; generate the grammar's atn definition
91
 (let ((bnfp:*class.atn* bnfp:*class.atn*)
92
       (bnfp:*class.atn-node* bnfp:*class.atn-node*)
93
       (bnfp:*class.cat-atn-edge* bnfp:*class.cat-atn-edge*)
94
       (bnfp:*class.pop-atn-edge* bnfp:*class.pop-atn-edge*)
95
       (bnfp:*class.push-atn-edge* bnfp:*class.push-atn-edge*)
96
       (bnfp:*class.test-atn-edge* bnfp:*class.test-atn-edge*))
97
   (atnp::print-atn-system #p"LIBRARY:org;datagraph;spocq;src;core;encoding;sparql-1-0-1.bnf"
98
                           :source-package (find-package :sparql-1-0-1)))
99
 
100
 (let ((bnfp:*class.atn* bnfp:*class.atn*)
101
       (bnfp:*class.atn-node* bnfp:*class.atn-node*)
102
       (bnfp:*class.cat-atn-edge* bnfp:*class.cat-atn-edge*)
103
       (bnfp:*class.pop-atn-edge* bnfp:*class.pop-atn-edge*)
104
       (bnfp:*class.push-atn-edge* bnfp:*class.push-atn-edge*)
105
       (bnfp:*class.test-atn-edge* bnfp:*class.test-atn-edge*))
106
   (atnp::graph-atn-system #p"LIBRARY:org;datagraph;spocq;src;core;encoding;sparql-1-0-1.bnf"
107
                           :source-package (find-package :sparql-1-0-1)))
108
                           
109
 
110
 |#