4,082 research outputs found
Consistently Updating XML Documents Using Incremental checks With XQueries
When updating a valid XML Data or Schema, an efficient yet light-weight mechanism is needed to determine if the update would invalidate the document. Towards this goal, we have developed a framework called SAXE. First, we analyzed the constraints expressed in XML schema specifications to establish constraint rules that must be observed when a schema or an XML data conforming to a given XML Schema is altered. We then classify the rules based on their relevancy for a given update case. That is, we show the minimal set of rules that must be checked to guarantee the safety for each update primitive. Next, we illustrate that this set of incremental constraint checks can be specified using generic XQuery expressions composed of three type of components. Safe updates for the XML data have the following components: (1) XML schema meta-queries to retrieve any con-straint knowledge potentially relevant to the given update from the schema or XMl data being altered, (2) retrieval of specific characteristics from the to-be-modified XML, and (3) lastly an analysis of information collected about the XML schema and the affected XML document to determine validity of the update. For the safe schema alteration, the components are: (1) XML schema meta-queries to retrieve relevant information from the schema (2)analysis and usage of retrieved information to update the schema, and lastly to (3) propagate the changes to the XML data when necessary. As a proof of concept, we have established a library of these generic XQuery constraint checks for the type-related XML constraints. The key idea of SAXE is to rewrite each XQuery update into a safe XML Query by extending it with appropriate constraint check subqueries. This en-hanced XML update query can then safely be executed using any existing XQuery engine that supports updates - thus turning any update engine automatically into an incremen-tal constraint-check engine. In order to verify the feasibility of our approach, we have implemented a prototype system SAXE that generates safe XQuery updates. Our experimental evaluation assesses the overhead of rewriting as well as the relative performance of our loosely-coupled incremental constraint check approach against the more traditional first-change-document and then revalidate-it approach
Managing the consistency of distributed documents
Many businesses produce documents as part of their daily activities: software engineers
produce requirements specifications, design models, source code, build scripts and more;
business analysts produce glossaries, use cases, organisation charts, and domain ontology
models; service providers and retailers produce catalogues, customer data, purchase orders,
invoices and web pages.
What these examples have in common is that the content of documents is often semantically
related: source code should be consistent with the design model, a domain ontology
may refer to employees in an organisation chart, and invoices to customers should be consistent
with stored customer data and purchase orders. As businesses grow and documents
are added, it becomes difficult to manually track and check the increasingly complex relationships
between documents. The problem is compounded by current trends towards
distributed working, either over the Internet or over a global corporate network in large
organisations. This adds complexity as related information is not only scattered over
a number of documents, but the documents themselves are distributed across multiple
physical locations.
This thesis addresses the problem of managing the consistency of distributed and possibly
heterogeneous documents. āDocumentsā is used here as an abstract term, and does not
necessarily refer to a human readable textual representation. We use the word to stand
for a file or data source holding structured information, like a database table, or some
source of semi-structured information, like a file of comma-separated values or a document
represented in a hypertext markup language like XML [Bray et al., 2000]. Document
heterogeneity comes into play when data with similar semantics is represented in different
ways: for example, a design model may store a class as a rectangle in a diagram whereas
a source code file will embed it as a textual string; and an invoice may contain an invoice
identifier that is composed of a customer name and date, both of which may be recorded
and managed separately.
Consistency management in this setting encompasses a number of steps. Firstly, checks
must be executed in order to determine the consistency status of documents. Documents
are inconsistent if their internal elements hold values that do not meet the properties
expected in the application domain or if there are conflicts between the values of elements
in multiple documents. The results of a consistency check have to be accumulated and
reported back to the user. And finally, the user may choose to change the documents to
bring them into a consistent state.
The current generation of tools and techniques is not always sufficiently equipped to deal
with this problem. Consistency checking is mostly tightly integrated or hardcoded into tools, leading to problems with extensibility with respect to new types of documents.
Many tools do not support checks of distributed data, insisting instead on accumulating
everything in a centralized repository. This may not always be possible, due to organisational
or time constraints, and can represent excessive overhead if the only purpose of
integration is to improve data consistency rather than deriving any additional benefit.
This thesis investigates the theoretical background and practical support necessary to
support consistency management of distributed documents. It makes a number of contributions
to the state of the art, and the overall approach is validated in significant case
studies that provide evidence of its practicality and usefulness
XML documents clustering using a tensor space model
The traditional Vector Space Model (VSM) is not able to represent both the structure and the content of XML documents. This paper introduces a novel method of representing XML documents in a Tensor Space Model (TSM) and then utilizing it for clustering. Empirical analysis shows that the proposed method is scalable for large-sized datasets; as well, the factorized matrices produced from the proposed method help to improve the quality of clusters through the enriched document representation of both structure and content information
XRound : A reversible template language and its application in model-based security analysis
Successful analysis of the models used in Model-Driven Development requires the ability to synthesise the results of analysis and automatically integrate these results with the models themselves. This paper presents a reversible template language called XRound which supports round-trip transformations between models and the logic used to encode system properties. A template processor that supports the language is described, and the use of the template language is illustrated by its application in an analysis workbench, designed to support analysis of security properties of UML and MOF-based models. As a result of using reversible templates, it is possible to seamlessly and automatically integrate the results of a security analysis with a model. (C) 2008 Elsevier B.V. All rights reserved
A Model-Based Approach for the Management of Electronic Invoices
The globalized market pushes companies to expand their business boundaries to a whole new level. In order to efficiently support this environment, business transactions must be executed over the Internet. However, there are several factors complicating this process, such as the current state of electronic invoices. Electronic invoice adoption is not widespread because of the current format fragmentation originated by national regulations. In this paper we present an approach based on Model-Driven Engineering techniques and abstractions for supporting the core functions of invoice management systems. We compare our solution with the traditional implementations and try to analyze the advantages MDE can bring to this specific domain
XSRL: An XML web-services request language
One of the most serious challenges that web-service enabled e-marketplaces face is the lack of formal support for expressing service requests against UDDI-resident web-services in order to solve a complex business problem. In this paper we present a web-service request language (XSRL) developed on the basis of AI planning and the XML database query language XQuery. This framework is designed to handle and execute XSRL requests and is capable of performing planning actions under uncertainty on the basis of refinement and revision as new service-related information is accumulated (via interaction with the user or UDDI) and as execution circumstances necessitate change
Reactivity on the Web
Reactivity, the ability to detect simple and composite events and respond in a timely
manner, is an essential requirement in many present-day information systems. With
the emergence of new, dynamic Web applications, reactivity on the Web is receiving
increasing attention. Reactive Web-based systems need to detect and react not only
to simple events but also to complex, real-life situations. This paper introduces
XChange, a language for programming reactive behaviour on the Web, emphasising
the querying of event data and detection of composite events
Precise service level agreements
SLAng is an XML language for defining service level agreements, the part of a contract between the client and provider of an Internet service that describes the quality attributes that the service is required to possess. We define the semantics of SLAng precisely by modelling the syntax of the language in UML, then embedding the language model in an environmental model that describes the structure and behaviour of services. The presence of SLAng elements imposes behavioural constraints on service elements, and the precise definition of these constraints using OCL constitutes the semantic description of the language. We use the semantics to define a notion of SLA compatibility, and an extension to UML that enables the modelling of service situations as a precursor to analysis, implementation and provisioning activities
- ā¦