Modified Files:

1) grammar.txt xmathql.dtd: modified EXISTS, added SORTEDBY and MINIMIZE
Added Files:
1) core_grammar.txt: implemented grammar

diff --git a/helm/mathql/core_grammar.txt b/helm/mathql/core_grammar.txt
new file mode 100644 (file)
index 0000000..65c6cbe
--- /dev/null
+++ b/helm/mathql/core_grammar.txt
@@ -0,0 +1,104 @@
+GRAMMATICA PER QUERY SU DOCUMENTI MATEMATICI
+       VERSIONE IMPLEMENTATA
+MATHEMATICAL QUERY LANGUAGE (MathQL) 
+
+<query> := <list>                              (* clausola iniziale *)
+
+<list> := ( <list> )                           (* parentesizazione *)
+       |  <rvar>                              (* lista singoletto var 
+                                                 (lista valori) *)
+       |  <lvar>                              (* lista singoletto var
+                                                 (lista valori) *)
+       |  REFERENCE <reference>                (* oggetto referenziato da URI
+                                                 esplicita *)
+       |  PATTERN <pattern>                    (* espansione del pattern *)
+       |  SELECT <rvar> IN <list> WHERE <bool> (* selezione *)
+       |  LET <lvar> BE <list> IN <list>       (* assegnazione a var in 
+                                                  contesto *)
+       |  USE <list> POSITION <svar>           (* unione lista backward *)
+       |  USEDBY <list> POSITION <svar>        (* unione lista forward *)
+       |  <list> UNION <list>                  (* unione *)
+       |  <list> INTERSECT <list>              (* intersezione *)
+       |  <list> SORTEDBY <function> <order>   (* unione lista ordinata secondo
+                                                  valore funzione e ordine *)
+<order>:= DESC                                 (* ordinamento decrescente *)
+       |  ASC                                 (* ordinamento crescente *) 
+
+<bool> := ( <bool> )                           (* parentesizzazione *)
+       |  TRUE                                 (* vero *)
+       |  FALSE                                (* falso *)
+       |  NOT <bool>                           (* negazione *)
+       |  <bool> AND <bool>                    (* congiunzione *)
+       |  <bool> OR <bool>                     (* disgiunzione *)
+       |  <string> IS <string>                 (* case sensitive matching *)
+       |  <list> SETEQUAL <list>               (* uguaglianza tra liste *)
+       |  <list> SUBSET <list>                (* operazione di sottoinsieme *)
+
+<string> := <'-quoted-constant-string>         (* costante letterale *)
+         |  MAINHYPOTHESIS | HYPOTHESIS        (* costanti simboliche *)
+         |  MAINCONCLUSION | CONCLUSION | BODY 
+        |  <svar>                             (* variabile *)
+         |  <rvar>                             (* variabile *)
+        |  <function> <rvar>                  (* applicazione di funzione *)
+        
+<function> := NAME                            (* URIREF -> nome_oggetto *)
+           |  TITLE                           (* URIREF -> valore_prop_DC *)
+           |  CONTRIBUTOR
+           |  CREATOR
+           |  PUBLISHER
+           |  SUBJECT
+           |  DESCRIPTION
+           |  DATE
+           |  TYPE
+           |  FORMAT
+           |  IDENTIFIER
+           |  LANGUAGE
+           |  RELATION
+           |  SOURCE
+           |  COVERAGE
+           |  RIGHTS
+          |  INSTITUTION
+          |  CONTACT
+          |  FIRSTVERSION
+          |  MODIFIED
+
+<pattern> := <"-quoted-constant-string>        (* pattern costante *)
+<reference> := <'-quoted-constant-string>      (* riferimento costante *)
+
+<rvar> := <not-reserved-identifier>            (* variabile per riferimenti *)
+<svar> := $ <not-reserved-identifier>          (* variabile per stringhe *)
+<lvar> := % <not-reserved-identifier>          (* variabile per liste *)
+
+
+- le stringhe sono "case sensitive" 
+- la funzione non definita sull'argomento restituisce la stringa nulla
+- le <rvar> si presuppongono essere istanziate come URI references costituite
+  da un URI e da un fragment identifier opzionale complete; i riferimenti 
+  identificano risorse 
+- ogni binding lega una variabile libera (nomi nuovi) 
+- Precedenza operatori:
+  NOT (+)  DIFF
+  AND      INTERSECT
+  OR  (-)  UNION
+- L'ordinamento di default e' quello alfabetico crescente in base al nome 
+  delle rvar
+- REFERENCE aumenta performance perche' NON accede al data base (costoso).
+- Note su <pattern>
+  Contiene un'espressione regolare per selezionare delle "reference" 
+  (cioe` delle uri eventualmente seguite da un fragment identifier)
+  L'espressione regolare contiene i seguenti costrutti:
+
+  costrutto        semanticamente fa match con                       
+  ?                un singolo carattere diverso da / # :             
+  *                la piu' lunga sottostringa che non contiene / # : 
+  **               la piu' lunga sottostringa che non contiene # :
+  altro carattere  solo se' stesso
+
+  costrutto        puo' appareire in
+  ?                "body"
+  *                dovunque
+  **               "body" e "fragment"
+  altro carattere  dovunque
+
+  "body"     parte compresa fra le occorrenze di ":/" e "#1" escluse
+  "fragment" parte successiva all'occorrenza "#1"
\ No newline at end of file

diff --git a/helm/mathql/grammar.txt b/helm/mathql/grammar.txt
index 699a6f20a3489b51d596c041c07865cf133b51c1..4a54af0702c7df4c19f9dd347ab1ea41884030d3 100644 (file)
--- a/helm/mathql/grammar.txt
+++ b/helm/mathql/grammar.txt
@@ -3,16 +3,16 @@ MATHEMATICAL QUERY LANGUAGE (MathQL)
 
 <query> := <list>                              (* clausola iniziale *)
 
-<list> := ( <list> )                           (* parentesizazione *)
+<list> := <empty-string>                      (* lista vuota *)
+       |  ( <list> )                           (* parentesizazione *)
        |  <rvar>                              (* lista singoletto var 
                                                  (lista valori) *)
        |  <lvar>                              (* lista singoletto var
                                                  (lista valori) *)
-       |  REFERENCE <reference>                (* oggetto referenziato da
-                                                 pattern costante *)
+       |  REFERENCE <reference>                (* oggetto referenziato da URI
+                                                 esplicita *)
        |  PATTERN <pattern>                    (* espansione del pattern *)
        |  SELECT <rvar> IN <list> WHERE <bool> (* selezione *)
-       |  EXISTS <rvar> IN <list> WHERE <bool> (* esistenziale *)
        |  LET <lvar> BE <list> IN <list>       (* assegnazione a var in 
                                                   contesto *)
        |  USE <list> POSITION <svar>           (* unione lista backward *)
@@ -32,6 +32,12 @@ MATHEMATICAL QUERY LANGUAGE (MathQL)
        |  <list> UNION <list>                  (* unione *)
        |  <list> INTERSECT <list>              (* intersezione *)
        |  <list> DIFF <list>                   (* differenza *)
+       |  MINIMIZE <list>                     (* minimizzazione del numero
+                                                 elementi della lista *)
+       |  <list> SORTEDBY <function> <order>   (* unione lista ordinata secondo
+                                                  valore funzione e ordine *)
+<order>:= DESC                                 (* ordinamento decrescente *)
+       |  ASC                                 (* ordinamento crescente *) 
 
 <bool> := ( <bool> )                           (* parentesizzazione *)
        |  TRUE                                 (* vero *)
@@ -42,6 +48,7 @@ MATHEMATICAL QUERY LANGUAGE (MathQL)
        |  <string> IS <string>                 (* case sensitive matching *)
        |  <list> SETEQUAL <list>               (* uguaglianza tra liste *)
        |  <list> SUBSET <list>                (* operazione di sottoinsieme *)
+       |  EXISTS <rvar> IN <list>             (* esistenziale *)
 
 <string> := <'-quoted-constant-string>         (* costante letterale *)
          |  MAINHYPOTHESIS | HYPOTHESIS        (* costanti simboliche *)
@@ -90,13 +97,13 @@ MATHEMATICAL QUERY LANGUAGE (MathQL)
 <svar> := $ <not-reserved-identifier>          (* variabile per stringhe *)
 <lvar> := % <not-reserved-identifier>          (* variabile per liste *)
 
-- () = lista vuota (?)
+- query vuota e' caso patologico: non si puo' verificare
 - le stringhe sono "case sensitive" 
 - la funzione non definita sull'argomento restituisce la stringa nulla
 - le <rvar> si presuppongono essere istanziate come URI references costituite
   da un URI e da un fragment identifier opzionale complete; i riferimenti 
   identificano risorse 
-- ogni binding lega una variabile libera (nuova) 
+- ogni binding lega una variabile libera (nomi nuovi) 
 - Precedenza operatori:
   NOT (+)  DIFF
   AND      INTERSECT
@@ -111,6 +118,7 @@ MATHEMATICAL QUERY LANGUAGE (MathQL)
   teorema ci sono? 
 - L'ordinamento di default e' quello alfabetico crescente in base al nome 
   delle rvar
+- REFERENCE aumenta performance perche' NON accede al data base (costoso).
 - Note su <pattern>
   Contiene un'espressione regolare per selezionare delle "reference" 
   (cioe` delle uri eventualmente seguite da un fragment identifier)
@@ -130,22 +138,17 @@ MATHEMATICAL QUERY LANGUAGE (MathQL)
 
   "body"     parte compresa fra le occorrenze di ":/" e "#1" escluse
   "fragment" parte successiva all'occorrenza "#1"
-- FUTURO: operatore di ordinamento sul risultato finale della query.
-  <query> SORTEDBY <order> <function>   (* unione lista ordinata secondo
-                                           ordine e valore funzione *)
-  <order>    := DESC                           (* ordinamento decrescente *)
-            |  ASC                            (* ordinamento crescente *)     
-  DTD:
-  <!ENTITY % order '(ascendant|descendant)'>
-  <!ELEMENT Query %queryexpr;>
-  <!ELEMENT SortBy (Query, SortField)>
-  <!ELEMENT SortField %functexpr;>
-  <!ATTLIST SortField 
-            order %order; #IMPLIED>
+- Condizioni associate alla var dell'esisteziale possono essere espresse
+  nella clausola WHERE di un SELECT nell'argomento <list> dell'EXISTS.
 - RILASSAMENTO degli operatori UNION e INTERSECT. Operatori fuzzy con 
   introduzione di pesi associati ai risultati.
 - VALUEOF restituisce il valore o, ricorsivamente sulla struttura, i valori 
   (delle proprieta' delle classi di valori) della proprieta' passatagli. 
   Problema: e' necessario gestire sia i nomi delle classi (costrutti TYPEOF) 
   sia i nomi delle proprieta' (menu a tendina di suggerimenti all'utente in 
-  base agli Schemi RDF relativi ai dati).
\ No newline at end of file
+  base agli Schemi RDF relativi ai dati).
+- L'algoritmo che implementa MINIMIZE puo' ad esempio eliminare le entrate
+  URI+insieme_di_attributi duplicate oppure le entrate con URI ripetute 
+  accorpando i diversi insieme_di_attributi per l'URI in un unica entrata 
+  della lista.
+ 
\ No newline at end of file

diff --git a/helm/mathql/xmathql.dtd b/helm/mathql/xmathql.dtd
index 88462d5d27111d80a61ebda874cc3d8cea1ba8cb..69b0cab9e0eeb991bacededc4bfc2a50d657dca5 100644 (file)
--- a/helm/mathql/xmathql.dtd
+++ b/helm/mathql/xmathql.dtd
@@ -40,6 +40,7 @@
 <!-- MathQL.                                                         -->
 <!-- Operators are unambiguous (binary or unary), so there isn't any -->
 <!-- grouping operator.                                              -->
+<!-- SORTBY operator for sorting query results.                      -->
 <!-- CONST is the constant string; rvar is for references and lvar   -->
 <!-- for list.                                                       -->
 <!-- The attributes binder, rvar, lvar declare variables which are   -->
@@ -50,6 +51,8 @@
 <!-- PROPERTY works on a specified RDF property returning its value. -->
 <!--*****************************************************************-->
 
+<!ENTITY % order '(ascendant|descendant)'>
+
 <!ENTITY % position '(MainHypothesis|Hypothesis|MainConclusion|Conclusion|
                       Body)'>
 
@@ -59,13 +62,14 @@
 
 <!-- MathQL list expression declaration -->
 
-<!ENTITY % listexpr '(Rvar|Lvar|Reference|Pattern|Select|Exists|LetIn|
+<!ENTITY % listexpr '(Rvar|Lvar|Reference|Pattern|Select|LetIn|SortBy|
                       Use|UsedBy|ConstructorsOf|InTheory|TheoryRefTo|
-                      TypeOf|SuperTypeOf|SubTypeOf|Union|Intersect|Diff)'>
+                      TypeOf|SuperTypeOf|SubTypeOf|Union|Intersect|Diff|
+                      Minimize)'>
 
 <!-- MathQL boolean expression declaration -->
 
-<!ENTITY % boolexpr '(BOOL|NOT|AND|OR|IS|SETEQUAL|SUBSET)'>
+<!ENTITY % boolexpr '(BOOL|NOT|AND|OR|IS|SETEQUAL|SUBSET|EXISTS)'>
 
 <!-- MathQL string expression declaration -->
 
@@ -93,8 +97,6 @@
 
 <!ELEMENT Select (In, Where)>
 
-<!ELEMENT Exists (In, Where)>
-
 <!ELEMENT LetIn (%listexpr;, Target)>
 
 <!ELEMENT Use (%listexpr;, Position)>
@@ -125,6 +127,10 @@
 
 <!ELEMENT Diff (%listexpr;, %listexpr;)>
 
+<!ELEMENT SortBy (%listexpr;, SortField)>
+
+<!ELEMENT Minimize %listexpr;>
+
 <!-- MathQL list sub-expressions -->
 
 <!ELEMENT RPrefix (CONST)>
@@ -178,6 +184,10 @@
 <!ATTLIST ItemType
           binder CDATA #REQUIRED>
 
+<!ELEMENT SortField %functexpr;>
+<!ATTLIST SortField 
+          order %order; #IMPLIED>
+
 <!-- MathQL boolean expressions -->
 
 <!ELEMENT BOOL EMPTY>
@@ -196,6 +206,8 @@
 
 <!ELEMENT SUBSET (%listexpr;, %listexpr;)>
 
+<!ELEMENT EXISTS (RVAR, %listexpr;)>
+
 <!-- MathQL string expressions -->
 
 <!ELEMENT CONST (#PCDATA)>