Changeset 349 for trunk/src/TM-SPARQL

Timestamp:

11/23/10 16:45:57 (14 years ago)

Author:

lgiessmann

Message:

TM-SPARQL: fixed a recursion bug when parsing SELECT-WHERE-statements

Location:

trunk/src/TM-SPARQL

Files:

• sparql.lisp (modified) (3 diffs)
• sparql_parser.lisp (modified) (6 diffs)

trunk/src/TM-SPARQL/sparql.lisp ¶

@@ -17 +17 @@
 (defvar *empty-label* "_empty_label_symbol")
 
-(defclass Variable-Container ()
-  ((variables :initarg :variables
-              :accessor variables ;this value is only for internal purposes
-                                  ;purposes and mustn't be reset
-              :type List
-              :initform nil
-              :documentation "A list of the form ((:variable var-name
-                             :value value-object)), that contains tuples
-                             for each variable and its result."))
-   (:documentation "This class is used to store all variable in a WHERE{}
-                    statement"))
+
+;(defclass SPARQL-Triple ()
+;  (())
+;  )
 
 
-(defclass SPARQL-Query (Variable-Container)
+(defclass SPARQL-Query ()
   ((original-query :initarg :query
                    :accessor original-query  ;this value is only for internal
@@ -40 +33 @@
                                :message "From TM-Query(): original-query must be set"))
                    :documentation "Containst the original received querry as string")
+   (variables :initarg :variables
+              :accessor variables ;this value is only for internal purposes
+                                        ;purposes and mustn't be reset
+              :type List
+              :initform nil
+              :documentation "A list of the form ((:variable var-name
+                             :value value-object)), that contains tuples
+                             for each selected variable and its result.")
    (prefixes :initarg :prefixes
              :accessor prefixes ;this value is only for internal purposes
@@ -98 +99 @@
                    overwritten. An entry is of the form
                    (:variable string :value any-type).")
-  (:method ((construct Variable-Container) (variable-name String) variable-value)
+  (:method ((construct SPARQL-Query) (variable-name String) variable-value)
     (let ((existing-tuple
            (find-if #'(lambda(x)

trunk/src/TM-SPARQL/sparql_parser.lisp ¶

@@ -105 +105 @@
         (error (make-sparql-parser-condition trimmed-str
                                              (original-query construct) "{")))
-      (let ((query-tail (parse-group construct (subseq trimmed-str 1) nil nil)))
+      (let ((query-tail (parse-group construct (subseq trimmed-str 1))))
         ;TODO: process query-tail
         query-tail))))
 
 
-(defgeneric parse-group (construct query-string values filters)
+(defgeneric parse-group (construct query-string &key last-subject values filters)
   (:documentation "The entry-point for the parsing of a {} statement.")
   (:method ((construct SPARQL-Query) (query-string String)
-            (values List) (filters List))
+            &key (last-subject nil) (values nil) (filters nil))
+    (declare (List last-subject values filters))
     (let ((trimmed-str (cut-comment query-string)))
       (cond ((string-starts-with trimmed-str "BASE")
@@ -123 +124 @@
                      "FILTER, BASE, or triple. Grouping is currently no implemented.")))
             ((string-starts-with trimmed-str "FILTER")
-             nil) ;TODO: call parse-group with added filter
+             nil) ;TODO: parse-filter and store it
             ((string-starts-with trimmed-str "OPTIONAL")
              (error (make-sparql-parser-condition
@@ -136 +137 @@
              (subseq trimmed-str 1))
             (t
-             (let ((result (parse-triple construct trimmed-str values)))
-               (parse-group construct (getf result :next-query)
-                            (getf result :values) filters)))))))
-               
+             ;(let ((result
+             (parse-triple construct trimmed-str :values values
+                           :filters filters :last-subject last-subject))))))
+
+
+(defun parse-filter (query-string query-object)
+  "A helper functions that returns a filter and the next-query string
+   in the form (:next-query string :filter object)."
+  ;; !, +, -, *, /, (, ), &&, ||, =, !=, <, >, >=, <=, REGEX(string, pattern)
+  (declare (String query-string)
+           (SPARQL-Query query-object))
+  ;;TODO: implement
+  (or query-string query-object))
 
 
@@ -418 +428 @@
 
 
-(defgeneric parse-triple (construct query-string values &key last-subject)
+(defgeneric parse-triple (construct query-string
+                                    &key last-subject values filters)
   (:documentation "Parses a triple within a trippel group and returns a
                    a list of the form (:next-query :values (:subject
@@ -424 +435 @@
                    (:type <'VAR|'IRI> :value string)
                    :object (:type <'VAR|'IRI|'LITERAL> :value string))).")
-  (:method ((construct SPARQL-Query) (query-string String) (values List)
-            &key (last-subject nil))
-    (declare (List last-subject))
+  (:method ((construct SPARQL-Query) (query-string String)
+            &key (last-subject nil) (values nil) (filters nil))
+    (declare (List last-subject filters values))
     (let* ((trimmed-str (cut-comment query-string))
            (subject-result (if last-subject ;;is used after a ";"
@@ -445 +456 @@
       (let ((tr-str (cut-comment (getf object-result :next-query))))
         (cond ((string-starts-with tr-str ";")
-               (parse-triple construct (subseq tr-str 1) all-values
-                             :last-subject (list :value
-                                                 (getf subject-result :value))))
+               (parse-group
+                construct (subseq tr-str 1)
+                :last-subject (list :value (getf subject-result :value))
+                :values all-values
+                :filters filters))
               ((string-starts-with tr-str ".")
-               (parse-triple construct (subseq tr-str 1) all-values))
-              ((string-starts-with tr-str "}") ;no other triples follows
-               (list :next-query tr-str
-                     :values all-values)))))))
+               (parse-group construct (subseq tr-str 1) :values all-values
+                            :filters filters))
+              ((string-starts-with tr-str "}")
+               (parse-group construct tr-str :values all-values
+                            :filters filters)))))))