Changeset 418

Timestamp:

04/06/11 11:01:57 (14 years ago)

Author:

lgiessmann

Message:

TM-SPARQL: filters use now the actual datatype, e.g. 82 instead of '82' ...

Location:

trunk/src

Files:

• TM-SPARQL/sparql.lisp (modified) (5 diffs)
• unit_tests/sparql_test.lisp (modified) (1 diff)

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

@@ -298 +298 @@
 
 
+
+(defgeneric cast-variable-values(construct variable-value-list)
+  (:documentation "Casts all values contained in the variable value list
+                   to the corresponding type that is also stored in the
+                   variable-value list.")
+  (:method ((construct SPARQL-Query) (variable-value-list List))
+    (map 'list
+         #'(lambda(item)
+             (map 'list
+                  #'(lambda(inner-item)
+                      (list :variable-name (getf inner-item :variable-name)
+                            :variable-value
+                            (if (and (getf inner-item :variable-value)
+                                     (getf inner-item :literal-datatype))
+                                (cast-literal (getf inner-item :variable-value)
+                                              (getf inner-item :literal-datatype)
+                                              :back-as-string-when-unsupported t)
+                                (getf inner-item :variable-value))))
+                  item))
+         variable-value-list)))
+
+
 (defgeneric make-variable-values(construct variable-name existing-results)
   (:documentation "Returns a list of values that are bound to the passed
@@ -311 +333 @@
                          (string= (value (subject triple)) variable-name))
                return (progn (setf found-p t)
-                             (subject-result triple))
+                             (list :result (subject-result triple)))
                when (and (variable-p (predicate triple))
                          (string= (value (predicate triple)) variable-name))
                return (progn (setf found-p t)
-                             (predicate-result triple))
+                             (list :result (predicate-result triple)))
                when (and (variable-p (object triple))
                          (string= (value (object triple))
                                   variable-name))
                return (progn (setf found-p t)
-                             (object-result triple))))
+                             (list :result (object-result triple)
+                                   :literal-datatype (object-datatype triple)))))
            (new-results nil))
       (if (not found-p)
           existing-results
           (if existing-results
-              (dolist (result results new-results)
+              (dotimes (idx (length (getf results :result)) new-results)
                 (dolist (old-result existing-results)
-                  (push (append old-result (list (list :variable-name variable-name
-                                                       :variable-value result)))
+                  (push (append old-result
+                                (list
+                                 (list :variable-name variable-name
+                                       :literal-datatype
+                                       (when (getf results :literal-datatype)
+                                         (elt (getf results :literal-datatype) idx))
+                                       :variable-value
+                                       (elt (getf results :result) idx))))
                         new-results)))
-              (map 'list #'(lambda(result)
-                             (list (list :variable-name variable-name
-                                         :variable-value result)))
-                   results))))))
+              (loop for idx to (1- (length (getf results :result)))
+                 collect (list
+                          (list :variable-name variable-name
+                                :literal-datatype
+                                (when (getf results :literal-datatype)
+                                  (elt (getf results :literal-datatype) idx))
+                                :variable-value
+                                (elt (getf results :result) idx)))))))))
 
 
@@ -390 +423 @@
           (setf filter-variable-values
                 (make-variable-values construct var-name filter-variable-values)))
+        (setf filter-variable-values
+              (cast-variable-values construct filter-variable-values))
         (dolist (filter (filters construct))
           (dolist (var-elem filter-variable-values)
+
+            ;(format t "~a~%==>~a~%~%" (to-lisp-code var-elem filter)
+            ;(eval (read-from-string (to-lisp-code var-elem filter)))) ;TODO: remove
+
             (when (eval (read-from-string (to-lisp-code var-elem filter)))
               (map 'list #'(lambda(list-elem)
                              (push list-elem true-values))
                    var-elem))))
+        ;(format t "tv: -->~a<--~%" true-values) ;TODO: remove
         (let ((values-to-remove
                (return-false-values filter-variable-values
                                     (remove-duplicates true-values
                                                        :test #'variable-list=))))
+          ;(format t "vr: -->~a<--~%" values-to-remove) ;TODO: remove
           (dolist (to-del values-to-remove)
             (delete-rows-by-value construct (getf to-del :variable-name)
@@ -416 +457 @@
            (cond ((eql what :subject) (subject-result construct))
                  ((eql what :predicate) (predicate-result construct))
-                 ((eql what :object) (object-result construct))))
-          (is-variable
+                 ((eql what :object)
+                  (if (object-datatype construct)
+                      (loop for idx to (1- (length (object-result construct)))
+                         when (elt (object-datatype construct) idx)
+                         collect (cast-literal
+                                  (elt (object-result construct) idx)
+                                  (elt (object-datatype construct) idx)
+                                  :back-as-string-when-unsupported t)
+                         else
+                         collect (elt (object-result construct) idx))
+                      (object-result construct)))))
+          (variable-p
            (cond ((eql what :subject)
                   (and (variable-p (subject construct))
@@ -427 +478 @@
                   (and (variable-p (object construct))
                        (value (object construct)))))))
-      (when is-variable
+      (when variable-p
         (remove-null
          (dotimes (idx (length local-results))

trunk/src/unit_tests/sparql_test.lisp ¶

@@ -2366 +2366 @@
                    <http://some.where/tmsparql/author/goethe> ?pred1 ?obj1.
                    FILTER ?obj1 = 'von Goethe' || ?obj1 = 82
-                   FILTER ?obj1 = 'von Goethe' || ?obj1 = 82
-                   FILTER (?obj1 = 'von Goethe' || 82 = ?obj1)
-                   FILTER (?obj1 = 'von Goethe') || (82 = ?obj1)
-                   FILTER ((?obj1 = 'von Goethe') || (82 = ?obj1))"
-                 "
+                   #FILTER ?obj1 = 'von Goethe' || ?obj1 = '82'^^" *xml-integer* "
+                   #FILTER (?obj1 = 'von Goethe' || 82 = ?obj1)
+                   #FILTER (?obj1 = 'von Goethe') || (82 = ?obj1)
+                   #FILTER ((?obj1 = 'von Goethe') || (82 = ?obj1))"
+                 "
 }"))
            (r-1 (tm-sparql:result (make-instance 'TM-SPARQL:SPARQL-Query :query q-1))))
 
 
-      (map 'list #'(lambda(triple)
-                     (format t "~a - ~a - ~a[~a]~%"
-                             (tm-sparql::subject-result triple)
-                             (tm-sparql::predicate-result triple)
-                             (tm-sparql::object-result triple)
-                             (tm-sparql::object-datatype triple)))
-           (tm-sparql::select-group (make-instance 'TM-SPARQL:SPARQL-Query :query q-1)))
+      ;(map 'list #'(lambda(triple)
+      ;(format t "~a - ~a - ~a[~a]~%"
+      ;(tm-sparql::subject-result triple)
+      ;(tm-sparql::predicate-result triple)
+      ;(tm-sparql::object-result triple)
+      ;(tm-sparql::object-datatype triple)))
+      ;(tm-sparql::select-group (make-instance 'TM-SPARQL:SPARQL-Query :query q-1)))