static typing in xquery mary fernández, jérôme siméon, philip wadler Επιμέλεια...
Post on 19-Dec-2015
215 Views
Preview:
TRANSCRIPT
Static Typing in XQuery
Mary Fernández, Jérôme Siméon, Philip Wadler
Επιμέλεια Παρουσίασης:
Μαγδαληνός Παναγής
Contents
Introduction XQuery Processing Phases
Definitions Example
Static Analysis Phase Dynamic Evaluation Phase
Values and Types in XQuery XML Schema and XQuery Types Values Relating Values and Types
Examples
Introduction
DefinitionsExample
Static Analysis PhaseDynamic Evaluation Phase
Definitions
Dynamic Typing: The process of checking during dynamic evaluation that the type of a value is compatible with the context in which it is used.
Static Typing: The process of checking during static analysis that the type of an expression is compatible with the context in which it is used
Type Correct Program: Never raise a type error in any evaluation
Definitions (Cont.)
Dynamic Typing ?Sort of run-time evaluation.
Static Typing ?Sort of compile-time and pre-compile time
evaluation.Type Correct ?
An equivalent to a Java program being able to compile.
Example – Relation Data in XML<auction xmlns=”http://www.example.com/auction”>
<users><user id=“U01”>
<name><first>Tom</first><last>Jones</last></name><rating>B</rating>
</user></users><articles>
<article id=“1001”><name>Red Bicycle</name><seller idref=“U01”/><start_date>1999-01-05</start_date><end_date>1999-01-20</end_date><reserve_price>40</reserve_prize>
</article></articles><bids>
<bid><userid idref=“U01”/><articleno idref=“1001”/><amount>45</amount><date>1999-01-13</date>
</bid></bids>
</auction>
Example – XML Schema<xs:schema targetNamespace=“http://example.com/auction”
xmlns:xs=“http://www.w3.org/2001/XMLSchema”xmlns=“http://www.example.com/auction” >
…………………………………………………………………………..<xs:element name=”users”>
<xs:complexType> <xs:sequence>
<xs:element name=“users”/><xs:element name=“articles”/><xs:element name=“bids”/>
</xs:sequence></sx:complexType>
</xs:element>
<xs:element name=“users”><xs:complexType>
<xs:element ref=“user” maxOccurs=“unbounded”/></xs:complexType>
</xs:element>…………………………………………………………………………<xs:element name=“user” type=“User”/><xs:complexType name=“User”>
…………………………….</xs:complexType>………………………………………………………………………….
</xs:schema>
Static Analysis Phase
Static type: A type such that, when the expression is evaluated, the resulting type will always conform to the static type
Static Error: Parse Error Inconsistency between Op-
Tree and Static Context Type Error: Incompatibility
between the static type of an expression and the type required by the context.
XQuery Op - Tree
Static Context
Parse Query
Modules
Normalize
Static Type Check
Res
olve
Nam
es
Sta
tic Q
uery
Pro
log
Environmental Initialization
Static Analysis Phase (Cont.)
Static Analysis equiv. Writing & Compiling Static Type example:
Java: Vector v; ……. v.elementAt(i); Return type is always java.lang.Object
Type Error example: Java:
Vector v; v.add(new Integer(1)); int i =v.elementAt(0) Type Error. Expected type java.lang.Object
but primitive type int was found
Dynamic Evaluation Phase
Dynamic Type: Associated with each value during computation. More specific than Static Type.
Dynamic Error: Errors occurring at runtime Type casting Schema dis-conformance
Type Error: The dynamic type of a value does not match the expected type of the context in which the value occurs.
ExecutionEngine
DynamicContext
Access Op - Tree
Acc
ess
and
Cha
nge
Environmental Initialization
Provide Access
Access and Create
Dat
a M
odel
Ins
tanc
es
Data
Dynamic Evaluation Phase (Cont.)
Dynamic Evaluation equiv. Execution Dynamic Type Example:
Java: Vector v; ……. v.elementAt(i); Return type is always java.lang.Object
Type Error & Dynamic Error Example Java:
Vector v; v.add(new Integer(1)); double i =Double.valueOf((Double)v.elementAt(0)) Dynamic & Type Error
Values and Types in XQuery
XML Schema and XQuery TypesValuesRelating Values and Types
XML Schema and XQuery Types
XML Schema XQuery type notation Global/Local element declaration A local element is distinguished by content Type can be either user-defined or predefined An element declaration associates an element name and a type. E.g
<xs: element name=“name” type=“xs:string”/> define element name of type xs:string
A complex type declaration associates name and content model define type User{
attribute id of type xs:ID,element name of AnonymousType 1,element rating ?}
Types can be combined with operators (, | ? + *) define type IntegerList {xs:integer + }
Derivation by Restriction define type NewUser restricts User
Values
XML input document:<user id=“U02”>
<name><first>Mary</first><last>Doe</last>
</name><rating>A</rating>
</user> XQuery formal notation:
element user of type User{attribute id of type xs:ID { “U02” },element name of type AnonymousType1{
element first of type xs:string { “Mary “} ,element last of type xs:string { “Doe” },
},element rating of type xs:string { “A” }
}
Relating Values and Types
Usage of XQuery TypesAnalysis timeEvaluation time
Both proceed bottom – up Labeled sub-expressions, label an overall
expressionLabeled values of sub-expressions, label
the value of an overall expression
Examples
Literals and Operators
The static type system checks that the type of an expression is compatible with the type required by the context in which the expression is used. Examples:
“hello” has type xs:string 42 + 69 has type xs:integer 42 + 69.00 has type xs:decimal (type promotion) “42” + 69.00 is a static type error “one” < “two” has type xs:boolean “one” < 2 is a static type error
Variables
Variable bounding: let $z:= 1 + 2 return $z + $z has type xs:integer
Variable sub-typing: let $x as xs:decimal :=1 + 2 return $x + $x has type xs:decimal
Variable sub-typing is different than type promotion let $x as xs:double :=1 + 2 return $x + $x is a static type error
Correct (sort of type-casting): let $x as xs:double :=xs:double( 1 + 2) return $x +$x has type xs:double
Sum up: Every expression is evaluated with respect to its sub-expressions
let $x as xs:decimal :=1 , $y as xs:integer :=$x + $x return $y + $y Why does it raise a static type error? let $x :=1 , $y :=$x + $x return $y + $y What is the variable’s y and return value’s type?
Functions
Every function has a signature fn:concat ($op1 as xs:string ?, $op2 as xs:string ?) as xs:string
Every function must be well-typed:Required types:
Derive from the signature declared typesAre promoted to the signature declared types
Conditionals
The condition must be a Boolean if ( $x<$y ) then 3 else 4 has type xs:integer If ( $x<$y ) then “three” else 4.00 has type
(xs:string | xs:decimal) ( if ($x<$y) then 4.2e1 else 69) +0.5 has type
(xs:double | xs:decimal) if( alwaysTrue() then 1 else “two”) +3 raises a
static type error!Conclusion: Typing rules understand no
infeasible paths
Path Expressions
Examples: $auction/articles/article
Meaning : all local elements article of local element articles of global element auction
Has type :element (article) + $auction/(articles | users)
Meaning: all articles and users elements of element auction Has type :((element(articles) | element(users)) +
The previous : factored type Any re-ordering in a factored type sequence results in the same
factored type What is the meaning of the following?
$auction//(user|articles)/name Has type
( element(type(User)/name) | element(type(Article)/name) ) +
Predicates
A predicate selects nodes in a path expression that satisfy a given expression: $auction/articles/article [start_date<=date()] has
type element(article)* Why the following?
$auction/articles/article [@id=$id] has type element(article)* !!!
exactly-one(),zero-or-one() functions More than one predicates can be used in an
expression: $auction/articles/article[start_date<=current_date()][1])
has type element(article) ?
FLWOR Expressions
FLWOR Expressions relies on factored types
Examples: for $article in $articles
return $article/end_date - $article/start_date has type xdt:dayTimeDuration +
for $article in $articles
where $article/start_date <= current_date()
return $article/end_date - $article/start_date has type xdt:dayTimeDuration *
Validation Context
Hierarchically defined context validationTree-like definition of the validation context
Global, …
Explicitly defined context validation $first := validate context user/name {<first>Mary</first>}
The latter is used if the context definition cannot be done lexically
Validation Mode
Valid XML Data: Conform to an XML Schema or a DTD
Well Formed XML Data: All open tags have matching end tags
Validation modes: Strict : A declaration is available for the element and the
element must validate with respect to that declaration Skip : Only well formatting constraints Lax : Validate strictly if a declaration is available
Validation is lexically defined Any conflicts can be surpassed with “overriding”
Conclusions
To Conclude…
Today we’ve learned about:The XQuery processing systemThe values and types in XQuery and their
associations with XML SchemaThe way types and values are assigned to
variables, functions,…The way an XQuery is validated and the
different validation forms
top related