" #-}
diff --git a/XML/HXQ/XQuery.hs b/XML/HXQ/XQuery.hs
--- a/XML/HXQ/XQuery.hs
+++ b/XML/HXQ/XQuery.hs
@@ -4,7 +4,7 @@
- Programmer: Leonidas Fegaras
- Email: fegaras@cse.uta.edu
- Web: http://lambda.uta.edu/
-- Creation: 03/22/08, last update: 05/06/08
+- Creation: 03/22/08, last update: 05/30/08
-
- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.
- This material is provided as is, with absolutely no warranty expressed or implied.
@@ -13,10 +13,11 @@
-
--------------------------------------------------------------------------------------}
+
-- | HXQ is a fast and space-efficient compiler from XQuery (the standard
-- query language for XML) to embedded Haskell code. The translation is
-- based on Haskell templates. It also provides an interpreter for
--- evaluating ad-hoc XQueries read from input or from files.
+-- evaluating ad-hoc XQueries read from input or from files and database connectivity using HDBC.
-- For more information, look at .
module XML.HXQ.XQuery (
-- * The XML Data Representation
@@ -24,10 +25,19 @@
-- * The XQuery Compiler
xq, xe,
-- * The XQuery Interpreter
- xquery, xfile
+ xquery, xfile,
+ -- * The XQuery Compiler with Database Connectivity
+ xqdb, connect, disconnect, prepareSQL, executeSQL,
+ -- * The XQuery Interpreter with Database Connectivity
+ xqueryDB, xfileDB,
+ -- * Shredding and Publishing XML Documents Using a Relational Database
+ shred, createIndex
) where
import HXML(AttList)
import XML.HXQ.XTree
import XML.HXQ.Compiler
import XML.HXQ.Interpreter
+import XML.HXQ.DB
+import XML.HXQ.DBConnect
+import Database.HDBC(disconnect)
diff --git a/XML/HXQ/XQueryDB.hs b/XML/HXQ/XQueryDB.hs
deleted file mode 100644
--- a/XML/HXQ/XQueryDB.hs
+++ /dev/null
@@ -1,38 +0,0 @@
-{-------------------------------------------------------------------------------------
--
-- The XQuery Compiler and Interpreter with HDBC connectivity
-- Programmer: Leonidas Fegaras
-- Email: fegaras@cse.uta.edu
-- Web: http://lambda.uta.edu/
-- Creation: 05/12/08, last update: 05/12/08
--
-- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.
-- This material is provided as is, with absolutely no warranty expressed or implied.
-- Any use is at your own risk. Permission is hereby granted to use or copy this program
-- for any purpose, provided the above notices are retained on all copies.
--
---------------------------------------------------------------------------------------}
-
-
--- | HXQ is a fast and space-efficient compiler from XQuery (the standard
--- query language for XML) to embedded Haskell code. The translation is
--- based on Haskell templates. It also provides an interpreter for
--- evaluating ad-hoc XQueries read from input or from files.
--- For more information, look at .
-module XML.HXQ.XQueryDB (
- -- * The XML Data Representation
- XTree(..), XSeq, Tag, AttList, putXSeq,
- -- * The XQuery Compiler
- xq, xe,
- -- * The XQuery Interpreter
- xquery, xfile,
- -- * The XQuery Compiler with Database Connectivity
- xqdb, disconnect, prepareSQL, executeSQL
- ) where
-
-import HXML(AttList)
-import XML.HXQ.XTree
-import XML.HXQ.Compiler
-import XML.HXQ.Interpreter
-import XML.HXQ.DB
-import Database.HDBC(disconnect)
diff --git a/XML/HXQ/XTree.hs b/XML/HXQ/XTree.hs
--- a/XML/HXQ/XTree.hs
+++ b/XML/HXQ/XTree.hs
@@ -1,10 +1,10 @@
{-------------------------------------------------------------------------------------
-
-- XML Trees (rose trees)
+- XML Trees (represented as rose trees)
- Programmer: Leonidas Fegaras
- Email: fegaras@cse.uta.edu
- Web: http://lambda.uta.edu/
-- Creation: 05/01/08, last update: 05/05/08
+- Creation: 05/01/08, last update: 05/30/08
-
- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.
- This material is provided as is, with absolutely no warranty expressed or implied.
@@ -22,8 +22,13 @@
import System.IO
import XMLParse(XMLEvent(..))
import HXML(AttList)
+import XML.HXQ.Parser(Ast(..))
+import Database.HDBC(Statement)
+instance Eq Statement where x == y = False
+
+
type Tag = String
@@ -38,23 +43,26 @@
| XGERef Tag -- ^ general entity reference
| XComment String -- ^ comment
| XError String -- ^ error report
+ | XStmt Statement -- ^ used internally to wrap an SQL statement
+ | XNoPad -- ^ marker for no padding in XSeq
deriving Eq
+
type XSeq = [XTree]
showAL :: AttList -> String
-showAL = foldr(\(a,v) r -> " "++a++"=\""++v++"\""++r) []
+showAL = foldr (\(a,v) r -> " "++a++"=\""++v++"\""++r) []
showXT :: XTree -> Bool -> String
showXT e pad
= case e of
- XElem tag al _ [] -> "<"++tag++(showAL al)++"/>"
- XElem tag al _ xs -> "<"++tag++(showAL al)++">"++(showXS xs)++""
- XText text -> text
- XInt n -> p++(show n)
- XFloat n -> p++(show n)
- XBool v -> p++(if v then "true" else "false")
+ XElem tag al _ [] -> "<"++tag++showAL al++"/>"
+ XElem tag al _ xs -> "<"++tag++showAL al++">"++showXS xs++""
+ XText text -> p++text
+ XInt n -> p++show n
+ XFloat n -> p++show n
+ XBool v -> p++if v then "true" else "false"
XComment s -> ""
XPI n s -> ""
XError s -> error s
@@ -63,15 +71,19 @@
showXS :: XSeq -> String
showXS [] = ""
-showXS (x:xs) = (showXT x False) ++ (concatMap (\x -> showXT x True) xs)
+showXS (x:xs) = showXT x False ++ sXS xs
+ where sXS (XNoPad:x:xs) = (showXT x False) ++ sXS xs
+ sXS (x:xs) = (showXT x True) ++ sXS xs
+ sXS _ = ""
instance Show XTree where
show t = showXT t False
--- | Print the XQuery result (which is a sequence of XML fragments) with no waiting
+-- | Print the XQuery result (which is a sequence of XML fragments) without buffering.
putXSeq :: XSeq -> IO ()
putXSeq xs = hSetBuffering stdout NoBuffering >> putStrLn (showXS xs)
+
{--------------- Build the rose tree from the XML stream ----------------------------}
diff --git a/XQueryParser.y b/XQueryParser.y
--- a/XQueryParser.y
+++ b/XQueryParser.y
@@ -4,7 +4,7 @@
- Programmer: Leonidas Fegaras
- Email: fegaras@cse.uta.edu
- Web: http://lambda.uta.edu/
-- Creation: 02/15/08, last update: 05/01/08
+- Creation: 02/15/08, last update: 05/15/08
-
- Copyright (c) 2008 by Leonidas Fegaras, the University of Texas at Arlington. All rights reserved.
- This material is provided as is, with absolutely no warranty expressed or implied.
@@ -35,9 +35,7 @@
')' { RP }
'{' { LSB }
'}' { RSB }
- '\'{' { LESCAPE }
- '}\'' { RESCAPE }
- 'to' { TO }
+ 'to' { TO }
'+' { PLUS }
'-' { MINUS }
'*' { TIMES }
@@ -175,7 +173,7 @@
| '+' expr %prec UMINUS { call "uplus" [$2] }
| '-' expr %prec UMINUS { call "uminus" [$2] }
| 'not' expr %prec UMINUS { call "not" [$2] }
- | 'String' { Astring $1 }
+ | string { $1 }
| 'Integer' { Aint $1 }
| 'Double' { Afloat $1 }
@@ -225,15 +223,17 @@
element :: { Ast }
element : stag '>' content '' { if head $1 == Astring $5
- then Ast "construction" ($1++[concatAll $3])
- else error("Unmatched tags in element construction: "++(show (head $1))++" '"++$5++"'") }
+ then Ast "element_construction" ($1++[Ast "append" $3])
+ else parseError [TError ("Unmatched tags in element construction: "
+ ++(show (head $1))++" '"++$5++"'")] }
| stag '>' '' { if head $1 == Astring $4
- then Ast "construction" ($1++[call "empty" []])
- else error("Unmatched tags in element construction: "++(show (head $1))++" '"++$4++"'") }
- | stag '/>' { Ast "construction" ($1++[call "empty" []]) }
- | 'element' '{' expr '}' '{' expl '}' { Ast "element_construction" [$3,concatenateAll $6] }
+ then Ast "element_construction" ($1++[Ast "append" []])
+ else parseError [TError ("Unmatched tags in element construction: "
+ ++(show (head $1))++" '"++$4++"'")] }
+ | stag '/>' { Ast "element_construction" ($1++[Ast "append" []]) }
+ | 'element' '{' expr '}' '{' expl '}' { Ast "element_construction" [$3,Ast "attributes" [],concatenateAll $6] }
| 'attribute' '{' expr '}''{' expl '}'{ Ast "attribute_construction" [$3,concatenateAll $6] }
- | 'element' 'QName' '{' expl '}' { Ast "element_construction" [Astring $2,concatenateAll $4] }
+ | 'element' 'QName' '{' expl '}' { Ast "element_construction" [Astring $2,Ast "attributes" [],concatenateAll $4] }
| 'attribute' 'QName' '{' expl '}' { Ast "attribute_construction" [Astring $2,concatenateAll $4] }
stag :: { [ Ast ] }
@@ -250,12 +250,18 @@
| content 'XMLtext' { $1++[Astring $2] }
| content element { $1++[$2] }
+string :: { Ast }
+string : stringc { if length $1 == 1 then head $1 else Ast "append" $1 }
+
+stringc :: { [Ast] }
+stringc : 'String' { if $1=="" then [] else [Astring $1] }
+ | '{' expl '}' { [concatenateAll $2] }
+ | stringc 'String' { if $2=="" then $1 else $1++[Astring $2] }
+ | stringc '{' expl '}' { $1++[concatenateAll $3] }
+
attributes :: { [ Ast ] }
-attributes : 'QName' '=' 'String' { [Ast "pair" [Astring $1,Astring $3]] }
- | 'QName' '=' '\'{' expr '}\'' { [Ast "pair" [Astring $1,$4]] }
- | attributes 'QName' '=' 'String' { $1++[Ast "pair" [Astring $2,Astring $4]] }
- | attributes 'QName' '='
- '\'{' expr '}\'' { $1++[Ast "pair" [Astring $2,$5]] }
+attributes : 'QName' '=' string { [Ast "pair" [Astring $1,$3]] }
+ | attributes 'QName' '=' string { $1++[Ast "pair" [Astring $2,$4]] }
full_path :: { Ast }
full_path : predicate_step { Ast "step" ($1 "child_step" (Avar ".")) }
@@ -290,13 +296,10 @@
then concatenateAll $2
else Ast "context" [e,Astring t,concatenateAll $2] }
| '(' ')' { \_ _ -> call "empty" [] }
- | 'QName' '(' expl ')' { \_ e -> if e == Avar "."
+ | 'QName' '(' expl ')' { \t e -> if e == Avar "."
then call $1 $3
- else Ast "context" [e,call $1 $3] }
- | 'QName' '(' ')' { if elem $1 ["text"]
- then \_ e -> call $1 [e]
- else \_ _ -> call $1 [] }
-
+ else Ast "context" [e,Astring t,call $1 $3] }
+ | 'QName' '(' ')' { \_ e -> call $1 (if e == Avar "." then [] else [e]) }
{
@@ -311,8 +314,8 @@
instance Show Ast
where show (Ast s []) = s ++ "()"
- show (Ast s (x:xs)) = s ++ "(" ++ (show x)
- ++ (foldr (\a r -> ","++(show a)++r) "" xs)
+ show (Ast s (x:xs)) = s ++ "(" ++ show x
+ ++ foldr (\a r -> ","++show a++r) "" xs
++ ")"
show (Avar s) = s
show (Aint n) = show n
@@ -320,23 +323,45 @@
show (Astring s) = "\'" ++ s ++ "\'"
+screenSize = 80::Int
+
+prettyAst :: Ast -> Int -> (String,Int)
+prettyAst (Avar s) p = (s,(length s)+p)
+prettyAst (Aint n) p = let s = show n in (s,(length s)+p)
+prettyAst (Afloat n) p = let s = show n in (s,(length s)+p)
+prettyAst (Astring s) p = ("\'" ++ s ++ "\'",(length s)+p+2)
+prettyAst (Ast s args) p
+ = let (ps,np) = prettyArgs args
+ in (s++"("++ps++")",np+1)
+ where prettyArgs [] = ("",p+1)
+ prettyArgs xs = let ss = show (head xs) ++ foldr (\a r -> ","++show a++r) "" (tail xs)
+ np = (length s)+p+1
+ in if (length ss)+p < screenSize
+ then (ss,(length ss)+p)
+ else let ds = map (\x -> let (s,ep) = prettyAst x np
+ in (s ++ ",\n" ++ space np,ep)) (init xs)
+ (ls,lp) = prettyAst (last xs) np
+ in (concatMap fst ds ++ ls,lp)
+ space n = replicate n ' '
+
+
+ppAst :: Ast -> String
+ppAst e = let (s,_) = prettyAst e 0 in s
+
+
call :: String -> [Ast] -> Ast
call name args = Ast "call" ((Avar name):args)
concatenateAll :: [Ast] -> Ast
+concatenateAll [x] = x
concatenateAll (x:xs) = foldl (\a r -> call "concatenate" [a,r]) x xs
concatenateAll _ = call "empty" []
-concatAll :: [Ast] -> Ast
-concatAll (x:xs) = foldl (\a r -> call "concat" [a,r]) x xs
-concatAll _ = call "empty" []
-
-
data Token
= RETURN | SOME | EVERY | IF | THEN | ELSE | LB | RB | LP | RP | LSB | RSB
- | LESCAPE | RESCAPE | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD
+ | TO | PLUS | MINUS | TIMES | DIV | IDIV | MOD
| TEQ | TNE | TLT | TLE | TGT | TGE | SEQ | SNE | SLT | SLE | SGT | SGE
| AND | OR | NOT | UNION | INTERSECT | EXCEPT | FOR | LET | IN | COMMA
| ASSIGN | WHERE | ORDER | BY | ASCENDING | DESCENDING | ELEMENT
@@ -354,6 +379,7 @@
show (TInteger n) = "Integer("++(show n)++")"
show (TFloat n) = "Double("++(show n)++")"
show (TString s) = "String("++s++")"
+ show (TError s) = "'"++s++"'"
show t = case filter (\(n,_) -> n==t) tokenList of
(_,b):_ -> b
_ -> "Illegal token"
@@ -361,7 +387,7 @@
tokenList :: [(Token,String)]
tokenList = [(RETURN,"return"),(SOME,"some"),(EVERY,"every"),(IF,"if"),(THEN,"then"),(ELSE,"else"),
- (LB,"["),(RB,"]"),(LP,"("),(RP,")"),(LSB,"{"),(RSB,"}"),(LESCAPE,"\"{"),(RESCAPE,"}\""),
+ (LB,"["),(RB,"]"),(LP,"("),(RP,")"),(LSB,"{"),(RSB,"}"),
(TO,"to"),(PLUS,"+"),(MINUS,"-"),(TIMES,"*"),(DIV,"div"),(IDIV,"idiv"),(MOD,"mod"),
(TEQ,"="),(TNE,"!="),(TLT,"<"),(TLE,"<="),(TGT,">"),(TGE,">="),(PRE,"<<"),(POST,">>"),
(IS,"is"),(SEQ,"eq"),(SNE,"ne"),(SLT,"lt"),(SLE,"le"),(SGT,"gt"),(SGE,"ge"),(AND,"and"),
@@ -373,50 +399,60 @@
(AT,"at"),(DOTS,".."),(DOT,"."),(SEMI,";")]
-parseError [] = error "Reached end-of-input"
-parseError [_] = error "Reached end-of-input"
-parseError tk = error("Parse error: "++(show (take 10 (init tk))))
+parseError tk = error (case tk of
+ ((TError s):_) -> "Parse error: "++s
+ _ -> "Parse error: "++(foldr (\a r -> (show a)++" "++r) "" (take 20 tk)))
scan :: String -> [Token]
-scan cs = lexer cs [0]
+scan cs = lexer cs ""
+
xmlText :: String -> [Token]
xmlText "" = []
xmlText text = [XMLtext text]
+
-- scans XML syntax and returns an XMLtext token with the text
-xml :: String -> String -> [Int] -> [Token]
-xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs (0:n))
-xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs n)
+xml :: String -> String -> String -> [Token]
+xml ('{':cs) text n = (xmlText text)++(LSB : lexer cs ('{':n))
+xml ('<':'/':cs) text n = (xmlText text)++(STAG : lexer cs ('<':'/':n))
xml ('<':'!':'-':cs) text n = xmlComment cs (text++" String -> [Int] -> [Token]
+
+xqComment :: String -> String -> String -> [Token]
xqComment (':':')':cs) text n = xml cs text n
xqComment (_:cs) text n = xqComment cs text n
xqComment [] text _ = xmlText text
-xmlComment :: String -> String -> [Int] -> [Token]
+
+xmlComment :: String -> String -> String -> [Token]
xmlComment ('-':'>':cs) text n = xml cs (text++"->") n
xmlComment (c:cs) text n = xmlComment cs (text++[c]) n
xmlComment [] text _ = xmlText text
+
isQN :: Char -> Bool
isQN c = elem c "_:-" || isDigit c || isAlpha c
+
isVar :: Char -> Bool
isVar c = elem c "_" || isDigit c || isAlpha c
+
+inXML :: String -> Bool
+inXML ('>':'<':_) = True
+inXML _ = False
+
+
-- the XQuery scanner
-lexer :: String -> [Int] -> [Token]
-lexer [] [0] = []
-lexer [] _ = error "Unbalanced tags"
+lexer :: String -> String -> [Token]
+lexer [] "" = []
+lexer [] _ = [ TError "Unexpected end of input" ]
lexer (' ':'>':' ':cs) n = TGT : lexer cs n
lexer (c:cs) n
| isSpace c = lexer cs n
@@ -425,46 +461,50 @@
lexer ('$':c:cs) n | isAlpha c
= let (var,rest) = span isVar (c:cs)
in (Variable var) : lexer rest n
-lexer ('\'':'{':cs) n = LESCAPE : lexer cs n
-lexer ('\"':'{':cs) n = LESCAPE : lexer cs n
lexer (':':'=':cs) n = ASSIGN : lexer cs n
-lexer ('<':'/':cs) n = STAG : lexer cs n
+lexer ('<':'/':cs) n = STAG : lexer cs ('<':'/':n)
lexer ('<':'=':cs) n = TLE : lexer cs n
lexer ('>':'=':cs) n = TGE : lexer cs n
lexer ('<':'<':cs) n = PRE : lexer cs n
lexer ('>':'>':cs) n = POST : lexer cs n
-lexer ('/':'>':cs) (k:n) = ETAG : lexer cs (k-2:n)
+lexer ('/':'>':cs) m = case m of
+ '<':n -> ETAG : (if inXML n then xml cs "" n else lexer cs n)
+ _ -> [ TError "Unexpected token: '/>'" ]
lexer ('(':':':cs) n = lexComment cs n
lexer ('<':'!':'-':cs) n = lexXmlComment cs " RSB : lexString cs "" ('\"':n)
+ '{':'\'':n -> RSB : lexString cs "" ('\'':n)
+ '{':n -> RSB : (if inXML n then xml cs "" n else lexer cs n)
+ _ -> [ TError "Unexpected token: '}'" ]
lexer ('+':cs) n = PLUS : lexer cs n
lexer ('-':cs) n = MINUS : lexer cs n
lexer ('*':cs) n = TIMES : lexer cs n
lexer ('=':cs) n = TEQ : lexer cs n
-lexer ('<':c:cs) n | not(isAlpha c) = TLT : lexer (c:cs) n
-lexer ('<':cs) (k:n) = TLT : lexer cs (k+2:n)
-lexer ('>':cs) (k:n) = TGT : (if k==1 then lexer cs (0:n) else xml cs "" (k-1:n))
+lexer ('<':c:cs) n = TLT : (lexer (c:cs) (if isAlpha c then ('<':n) else n))
+lexer ('>':cs) m = case m of
+ '<':'/':'>':'<':n -> TGT : (if inXML n then xml cs "" n else lexer cs n)
+ '<':n -> TGT : xml cs "" ('>':m)
+ _ -> TGT : lexer cs m
lexer (',':cs) n = COMMA : lexer cs n
lexer ('@':cs) n = ATSIGN : lexer cs n
lexer ('/':cs) n = SLASH : lexer cs n
-lexer ('{':cs) n = LSB : lexer cs (0:n)
+lexer ('{':cs) n = LSB : lexer cs ('{':n)
lexer ('|':cs) n = UNION : lexer cs n
lexer (';':cs) n = SEMI : lexer cs n
-lexer (c:cs) n = error("Illegal character "++[c])
+lexer (c:cs) n = TError ("Illegal character: '"++[c,'\'']) : lexer cs n
-lexNum :: String -> [Int] -> [Token]
+
+lexNum :: String -> String -> [Token]
lexNum cs n = if null rest || head rest /= '.'
then TInteger (read k) : lexer rest n
else let (m,rest2) = span isDigit (tail rest)
@@ -475,66 +515,73 @@
_ -> (TFloat val) : lexer rest2 n
where (k,rest) = span isDigit cs
-lexString :: String -> [Int] -> [Token]
-lexString cs n = TString s : lexer (tail rest) n
- where (s,rest) = span inString cs
- inString c = c /= '\''
-lexString2 :: String -> [Int] -> [Token]
-lexString2 cs n = TString s : lexer (tail rest) n
- where (s,rest) = span inString cs
- inString c = c /= '\"'
+lexString :: String -> String -> String -> [Token]
+lexString ('\"':cs) s m = case m of
+ '\"':n -> (TString s) : (lexer cs n)
+ _ -> lexString cs (s++"\"") m
+lexString ('\'':cs) s m = case m of
+ '\'':n -> (TString s) : (lexer cs n)
+ _ -> lexString cs (s++"\'") m
+lexString ('{':cs) s n = (TString s) : LSB : (lexer cs ('{':n))
+lexString (c:cs) s n = lexString cs (s++[c]) n
+lexString [] s n = [ TError "End of input while in string" ]
-lexComment :: String -> [Int] -> [Token]
+
+lexComment :: String -> String -> [Token]
lexComment (':':')':cs) n = lexer cs n
lexComment (_:cs) n = lexComment cs n
-lexComment [] n = []
+lexComment [] n = [ TError "End of input while in comment" ]
-lexXmlComment :: String -> String -> [Int] -> [Token]
+
+lexXmlComment :: String -> String -> String -> [Token]
lexXmlComment ('-':'>':cs) text n = (xmlText (text++"->"))++(lexer cs n)
lexXmlComment (c:cs) text n = lexXmlComment cs (text++[c]) n
lexXmlComment [] text _ = xmlText text
-lexVar :: String -> [Int] -> [Token]
+
+lexVar :: String -> String -> [Token]
lexVar cs n =
- case span isQN cs of
- ("return",rest) -> RETURN : lexer rest n
- ("some",rest) -> SOME : lexer rest n
- ("every",rest) -> EVERY : lexer rest n
- ("if",rest) -> IF : lexer rest n
- ("then",rest) -> THEN : lexer rest n
- ("else",rest) -> ELSE : lexer rest n
- ("to",rest) -> TO : lexer rest n
- ("div",rest) -> DIV : lexer rest n
- ("idiv",rest) -> IDIV : lexer rest n
- ("mod",rest) -> MOD : lexer rest n
- ("and",rest) -> AND : lexer rest n
- ("or",rest) -> OR : lexer rest n
- ("not",rest) -> NOT : lexer rest n
- ("union",rest) -> UNION : lexer rest n
- ("intersect",rest) -> INTERSECT : lexer rest n
- ("except",rest) -> EXCEPT : lexer rest n
- ("for",rest) -> FOR : lexer rest n
- ("let",rest) -> LET : lexer rest n
- ("in",rest) -> IN : lexer rest n
- ("where",rest) -> WHERE : lexer rest n
- ("order",rest) -> ORDER : lexer rest n
- ("by",rest) -> BY : lexer rest n
- ("ascending",rest) -> ASCENDING : lexer rest n
- ("descending",rest) -> DESCENDING : lexer rest n
- ("element",rest) -> ELEMENT : lexer rest n
- ("attribute",rest) -> ATTRIBUTE : lexer rest n
- ("satisfies",rest) -> SATISFIES : lexer rest n
- ("declare",rest) -> DECLARE : lexer rest n
- ("function",rest) -> FUNCTION : lexer rest n
- ("variable",rest) -> VARIABLE : lexer rest n
- ("at",rest) -> AT : lexer rest n
- ("eq",rest) -> SEQ : lexer rest n
- ("ne",rest) -> SNE : lexer rest n
- ("lt",rest) -> SLT : lexer rest n
- ("le",rest) -> SLE : lexer rest n
- ("gt",rest) -> SGT : lexer rest n
- ("ge",rest) -> SGE : lexer rest n
- ("is",rest) -> IS : lexer rest n
- (var,rest) -> QName var : lexer rest n
+ let (nm,rest) = span isQN cs
+ in (case nm of
+ "return" -> RETURN
+ "some" -> SOME
+ "every" -> EVERY
+ "if" -> IF
+ "then" -> THEN
+ "else" -> ELSE
+ "to" -> TO
+ "div" -> DIV
+ "idiv" -> IDIV
+ "mod" -> MOD
+ "and" -> AND
+ "or" -> OR
+ "not" -> NOT
+ "union" -> UNION
+ "intersect" -> INTERSECT
+ "except" -> EXCEPT
+ "for" -> FOR
+ "let" -> LET
+ "in" -> IN
+ "where" -> WHERE
+ "order" -> ORDER
+ "by" -> BY
+ "ascending" -> ASCENDING
+ "descending" -> DESCENDING
+ "element" -> ELEMENT
+ "attribute" -> ATTRIBUTE
+ "satisfies" -> SATISFIES
+ "declare" -> DECLARE
+ "function" -> FUNCTION
+ "variable" -> VARIABLE
+ "at" -> AT
+ "eq" -> SEQ
+ "ne" -> SNE
+ "lt" -> SLT
+ "le" -> SLE
+ "gt" -> SGT
+ "ge" -> SGE
+ "is" -> IS
+ var -> QName var
+ ) : lexer rest n
}
diff --git a/data/q1.xq b/data/q1.xq
--- a/data/q1.xq
+++ b/data/q1.xq
@@ -4,8 +4,8 @@
declare function f ( $name, $gpa ) {
{ $name/firstname/text(),
- ' ',$name/lastname/text(),
- ': ',$gpa
+ $name/lastname/text(),
+ ':',$gpa
}
};
diff --git a/data/q3.xq b/data/q3.xq
new file mode 100644
--- /dev/null
+++ b/data/q3.xq
@@ -0,0 +1,8 @@
+{
+let $a := distinct-values(doc("data/cs.xml")//gradstudent)
+for $s in $a
+return {
+ doc("data/cs.xml")//gradstudent[.//lastname = $s//lastname]//name,
+ count(.//*)
+ }
+}
diff --git a/hxml-0.2/XMLScanner.hs b/hxml-0.2/XMLScanner.hs
--- a/hxml-0.2/XMLScanner.hs
+++ b/hxml-0.2/XMLScanner.hs
@@ -168,7 +168,8 @@
doEntityRef entities k r = doSpan (';'/=) (++) replacement (k . drop1) r where
replacement ename = case DTD.expandInternalEntity entities ename of
Just s -> s
- _ -> error ("entity " ++ ename ++ " not defined")
+-- changed by Leonidas Fegaras 5/27/08
+ _ -> "" -- error ("entity " ++ ename ++ " not defined")
-- [...]
markupMode [] = []
diff --git a/index.html b/index.html
--- a/index.html
+++ b/index.html
@@ -26,24 +26,26 @@
Also XQilla, which is written in C++, took 1 minute and 10 secs
(using 1150MB of heap space). (All results are taken on an Intel Core 2 Duo 2.2GHz 2GB running ghc-6.8.2 on Linux 2.6.23 kernel.)
-HXQ uses the HXML parser for XML (developed by Joe English),
-which is included in the source.
-I have also tried hexpat, tagsoup, HXT, and HaXML Xtract, but they all have space leaks.
-For example, when I replaced the HXML parser with tagsoup
-in HXQ, it required more than 3GB heap space for the above query
-and gave partial results.
+Finally, HXQ can store XML documents in a relational database (currently SQLite), by shredding XML into relational
+tuples, and by translating XQueries over the shredded documents into optimized SQL queries.
Installation Instructions
First, you need to install the Glasgow Haskell Compiler,
ghc,
-and the parser generator for Haskell,
-happy.
-For example, in Fedora Linux, you install both using:
+the parser generator for Haskell,
+happy,
+and SQLite for database connectivity (optional).
+For example, in Fedora Linux, you install them using:
-yum install ghc happy
+yum install ghc happy sqlite
-Then download HXQ and untar it.
+Then, you need to install the haskell packages: HDBC
+and the
+HDBC-sqlite3 driver
+to connect to SQLite relational databases.
+
+Finally, download HXQ and untar it.
You can use either make or cabal to build it. To build it with cabal, you do:
runhaskell Setup.lhs configure --prefix=$HOME
@@ -51,7 +53,7 @@
runhaskell Setup.lhs install
(The last command must be run as root.)
-It will create the executable xquery, which is the XQuery interepreter, and the HXQ library.
+It will create the executable xquery, which is the XQuery interpreter, and the HXQ library.
To use the library, you run ghc or ghci with -package HXQ.
Current Status
@@ -64,9 +66,12 @@
Some, but not all, parent axis steps are removed using optimization rules; all others cause a compilation error.
Finally, the XQuery semantics requires duplicate elimination and
sorting by document order for every XPath step, which is very expensive and unnecessary in most cases.
-For exmple, e//*//* may return duplicate elements in HXQ.
+For example, e//*//* may return duplicate elements in HXQ.
This will be addressed in the future (needs a static analysis to determine when duplicate elimination is necessary).
+HXQ uses the HXML parser for XML (developed by Joe English),
+which is included in the source. I have also tried hexpat, tagsoup, HXT, and HaXML Xtract, but they all have space leaks.
+
Using the Compiler
The main functions for embedding XQueries in Haskell are:
@@ -131,16 +136,34 @@
xquery -p "//inproceedings[100]" data/dblp.xml.
With xquery -help you get the list of system functions and usage information.
-
Experimental Features
+Database Connectivity
-There is an experimental interface to HDBC to query relational data inside an XQuery.
-To use it, you need to install HDBC
-and HDBC-sqlite3
-(or some other HDBC driver, such ODBC). The main function is
-$(xqdb query) :: (IConnection conn) => conn -> IO XSeq.
-The XQuery may contain multiple SQL queries in the form sql(query,args),
-where query is the sql query that may contain parameters (denoted by ?), which are bound to the values in args.
-An example can be found in TestDB.hs. To run it, you need
+HXQ provides an interface to HDBC to query relational data inside an XQuery.
+For the HXQ compiler, the main function that allows database connectivity is:
+
+$(xqdb query) :: (IConnection conn) => conn -> IO XSeq
+
+For example, if the database name is "myDB", then
+
+do db <- connect "myDB"
+ result <- $(xqdb xquery) db
+
+For the HXQ interpreter, the function is:
+
+xqueryDB :: (IConnection conn) => String -> conn -> IO XSeq
+
+The xquery executable can also run xqueries that use a database by specifying the database name using the -db option.
+
+Currently, HXQ works with SQLite only, but is very easy to make it work
+with any relational database that supports ODBC: simply install
+HDBC-odbc
+and change the file XML/HXQ/DBConnect.hs accordingly.
+
+
Querying an Existing Database
+
+An XQuery may contain multiple SQL queries in the form sql(query,args),
+where query is the sql query that may contain parameters (denoted by ?), which are bound to the values in args (an XSeq).
+An example can be found in TestDB.hs. To run this example, you need
to install the company database. For example, using the sqlite3
interpreter, you do:
@@ -148,17 +171,52 @@
.read data/company.sql
.quit
-and then you do make testdb on linux.
+and then compile and run TestDB.hs (or just do make test3 on linux).
-Finally, there is an experimental
+
Shredding
+
+To store an XML document into a relational database, use the following Haskell function:
+
+shred :: (IConnection conn) => conn -> String -> String -> IO ()
+shred db file name
+
+that shreds and stores the XML document located at the file pathname in the database db under a unique name.
+HXQ will find a good relational schema (using hybrid inlining) to store the XML data by first scanning the document to
+extract its structural summary, then deriving a good relational schema, and finally scanning the document
+for a second time to store its data into the relational tables. For example,
+
+do db <- connect "myDB"
+ shred db "data/cs.xml" "c"
+
+
+The haskell function
+
+createIndex db name tagname
+
+creates a secondary index on tagname for the shredded document under the given name.
+
+
Publishing
+
+You can query a shredded XML document using the XQuery function:
+
+publish(dbame,name)
+
+where dbname is the database file name and name is the unique name assigned to the XML document when was shredded.
+The translation from XQuery to SQL is done at compile-time, so both dbname and name must be constant strings.
+HXQ will do its best to push relevant predicates to the generated SQL query (using partial evaluation and code folding),
+thus deriving an efficient execution. One example is TestDB2.hs (do make test4 to run it on linux).
+
+
Experimental Features
+
+There is an experimental
program, called hxqc, that works like xquery but is faster because it uses the
-HXQ compiler instead of the interpreter. It's constracted with the Unix Makefile (make hxqc).
+HXQ compiler instead of the interpreter. It's constructed with the Unix Makefile (make hxqc).
It is unstable and the hxqc executable is 10 times larger than xquery since it
uses the ghc libraries at run-time. Also, although it is faster than the interpreter, it is slower than a
-compiled xquery since it uses part of the heap for the ghc compiler to compile Haskell code on-the-fly.
+compiled xquery because it uses part of the heap for the ghc compiler to compile Haskell code on-the-fly.