helm/mathql/grammar.txt

   1 GRAMMATICA PER QUERY SU DOCUMENTI MATEMATICI
   2 MATHEMATICAL QUERY LANGUAGE (MathQL)
   3
   4 <query> := <list>                              (* clausola iniziale *)
   5
   6 <list> := <empty-string>                       (* lista vuota *)
   7        |  ( <list> )                           (* parentesizazione *)
   8        |  <rvar>                               (* lista singoletto var
   9                                                   (lista valori) *)
  10        |  <lvar>                               (* lista singoletto var
  11                                                   (lista valori) *)
  12        |  REFERENCE <reference>                (* oggetto referenziato da URI
  13                                                   esplicita *)
  14        |  PATTERN <pattern>                    (* espansione del pattern *)
  15        |  SELECT <rvar> IN <list> WHERE <bool> (* selezione *)
  16        |  LET <lvar> BE <list> IN <list>       (* assegnazione a var in
  17                                                   contesto *)
  18        |  USE <list> POSITION <svar>           (* unione lista backward *)
  19        |  USEDBY <list> POSITION <svar>        (* unione lista forward *)
  20        |  CONTRUCTORS <list>                   (* unione costruttori della
  21                                                   lista oggetti*)
  22        |  INTHEORY <list> ITEMTYPE <svar>      (* unione oggetti lista
  23                                                   teorie *)
  24        |  THEORYREFTO <list>                   (* unione teorie che fanno
  25                                                  riferimento a lista oggetti *)
  26        |  <list> OFTYPE <svar>                 (* unione oggetti in base a
  27                                                   classi RDF *)
  28        |  <list> OFSUPERTYPE <svar>            (* unione oggetti in base a
  29                                                   classi e loro superclassi *)
  30        |  <list> OFSUBTYPE <svar>              (* unione oggetti in base a
  31                                                   classi e loro sottoclassi *)
  32        |  <list> UNION <list>                  (* unione *)
  33        |  <list> INTERSECT <list>              (* intersezione *)
  34        |  <list> DIFF <list>                   (* differenza *)
  35        |  MINIMIZE <list>                      (* minimizzazione del numero
  36                                                   elementi della lista *)
  37        |  <list> SORTEDBY <function> <order>   (* unione lista ordinata secondo
  38                                                   valore funzione e ordine *)
  39 <order>:= DESC                                 (* ordinamento decrescente *)
  40        |  ASC                                  (* ordinamento crescente *)
  41
  42 <bool> := ( <bool> )                           (* parentesizzazione *)
  43        |  TRUE                                 (* vero *)
  44        |  FALSE                                (* falso *)
  45        |  NOT <bool>                           (* negazione *)
  46        |  <bool> AND <bool>                    (* congiunzione *)
  47        |  <bool> OR <bool>                     (* disgiunzione *)
  48        |  <string> IS <string>                 (* case sensitive matching *)
  49        |  <list> SETEQUAL <list>               (* uguaglianza tra liste *)
  50        |  <list> SUBSET <list>                 (* operazione di sottoinsieme *)
  51        |  EXISTS <rvar> IN <list>              (* esistenziale *)
  52
  53 <string> := <'-quoted-constant-string>         (* costante letterale *)
  54          |  MAINHYPOTHESIS | HYPOTHESIS        (* costanti simboliche *)
  55          |  MAINCONCLUSION | CONCLUSION | BODY
  56          |  <svar>                             (* variabile *)
  57          |  <rvar>                             (* variabile *)
  58          |  <function> <rvar>                  (* applicazione di funzione *)
  59
  60 <function> := NAME                             (* URIREF -> nome_oggetto *)
  61            |  <property>                       (* proprieta' RDF *)
  62
  63 <property> := THEORY                           (* URIREF -> valore_proprieta' *)
  64            |  TITLE                            (* URIREF -> valore_prop_DC *)
  65            |  CONTRIBUTOR
  66            |  CREATOR
  67            |  PUBLISHER
  68            |  SUBJECT
  69            |  DESCRIPTION
  70            |  DATE
  71            |  TYPE
  72            |  FORMAT
  73            |  IDENTIFIER
  74            |  LANGUAGE
  75            |  RELATION
  76            |  SOURCE
  77            |  COVERAGE
  78            |  RIGHTS
  79            |  INSTITUTION
  80            |  CONTACT
  81            |  FIRSTVERSION
  82            |  MODIFIED
  83            |  VALUEOF <propname>               (* nome_propr URIREF ->
  84                                                   valore_Proprieta' *)
  85            |  <refineprop> <property>
  86
  87 <refineprop> := SUB                            (* proprieta' e sotto-proprieta'
  88                                                   di *)
  89              |  SUPER                          (* proprieta' e super-proprieta'
  90                                                   di *)
  91 <propname> := <'-quoted-constant-string>       (* costante letterale *)
  92
  93 <pattern> := <"-quoted-constant-string>        (* pattern costante *)
  94 <reference> := <'-quoted-constant-string>      (* riferimento costante *)
  95
  96 <rvar> := <not-reserved-identifier>            (* variabile per riferimenti *)
  97 <svar> := $ <not-reserved-identifier>          (* variabile per stringhe *)
  98 <lvar> := % <not-reserved-identifier>          (* variabile per liste *)
  99
 100 - query vuota e' caso patologico: non si puo' verificare
 101 - le stringhe sono "case sensitive"
 102 - la funzione non definita sull'argomento restituisce la stringa nulla
 103 - le <rvar> si presuppongono essere istanziate come URI references costituite
 104   da un URI e da un fragment identifier opzionale complete; i riferimenti
 105   identificano risorse
 106 - ogni binding lega una variabile libera (nomi nuovi)
 107 - Precedenza operatori:
 108   NOT (+)  DIFF
 109   AND      INTERSECT
 110   OR  (-)  UNION
 111 - Possibili tipi di RELATION e DEPENDENCE sono rappresentati dalle loro
 112   subproperties
 113 - FUTURO: thesauri di parole e sinonimi per ricerche testuali, ordinamenti sui
 114   risultati, caratteri jolly. Una volta reperito l'oggetto si possono
 115   visualizzare le info associate.
 116 - FUTURO: in output numeri ad esempio a fini statistici, aggiungendo anche
 117   operatori aritmetici e di confronto (< = >). Es. Quante proofs di un certo
 118   teorema ci sono?
 119 - L'ordinamento di default e' quello alfabetico crescente in base al nome
 120   delle rvar
 121 - REFERENCE aumenta performance perche' NON accede al data base (costoso).
 122 - Note su <pattern>
 123   Contiene un'espressione regolare per selezionare delle "reference"
 124   (cioe` delle uri eventualmente seguite da un fragment identifier)
 125   L'espressione regolare contiene i seguenti costrutti:
 126
 127   costrutto        semanticamente fa match con
 128   ?                un singolo carattere diverso da / # :
 129   *                la piu' lunga sottostringa che non contiene / # :
 130   **               la piu' lunga sottostringa che non contiene # :
 131   altro carattere  solo se' stesso
 132
 133   costrutto        puo' appareire in
 134   ?                "body"
 135   *                dovunque
 136   **               "body" e "fragment"
 137   altro carattere  dovunque
 138
 139   "body"     parte compresa fra le occorrenze di ":/" e "#1" escluse
 140   "fragment" parte successiva all'occorrenza "#1"
 141 - Condizioni associate alla var dell'esisteziale possono essere espresse
 142   nella clausola WHERE di un SELECT nell'argomento <list> dell'EXISTS.
 143 - RILASSAMENTO degli operatori UNION e INTERSECT. Operatori fuzzy con
 144   introduzione di pesi associati ai risultati.
 145 - VALUEOF restituisce il valore o, ricorsivamente sulla struttura, i valori
 146   (delle proprieta' delle classi di valori) della proprieta' passatagli.
 147   Problema: e' necessario gestire sia i nomi delle classi (costrutti TYPEOF)
 148   sia i nomi delle proprieta' (menu a tendina di suggerimenti all'utente in
 149   base agli Schemi RDF relativi ai dati).
 150 - L'algoritmo che implementa MINIMIZE puo' ad esempio eliminare le entrate
 151   URI+insieme_di_attributi duplicate oppure le entrate con URI ripetute
 152   accorpando i diversi insieme_di_attributi per l'URI in un unica entrata
 153   della lista.
 154