microsoft.com

An Online Bibliography on Schema Evolution

Authors: 
Rahm, Erhard; Bernstein, Philip A.
Year: 
2006
Venue: 
Sigmod Record

We briefly motivate and present a new online bibliography on schema evolution, an area which has recently gained much interest in both research and practice.

A Vision for Management of Complex Models

Authors: 
Bernstein, P.A.; Levy, A.Y.; Pottinger, R.A.
Year: 
2000
Venue: 
Sigmod Record

Many problems encountered when building applications of database systems involve the manipulation
of models. By “model,” we mean a complex structure that represents a design artifact,
such as a relational schema, object-oriented interface, UML model, XML DTD, web-site schema,
semantic network, complex document, or software configuration. Many uses of models involve
managing changes in models and transformations of data from one model into another. These uses
require an explicit representation of “mappings” between models. We propose to make database

Model-Independent Schema and Data Translation

Authors: 
Atzeni, P; Cappellari, P; Bernstein, PA
Year: 
2006
Venue: 
Proc. EDBT 2006 (LNCS)

We describe MIDST, an implementation of the model management
operator ModelGen, which translates schemas from one model
to another, for example from OO to SQL or from SQL to XSD. It extends
past approaches by translating database instances, not just their
schemas. The operator can be used to generate database wrappers (e.g.
OO or XML to relational), default user interfaces (e.g. relational to
forms), or default database schemas from other representations. The approach
translates both schemas and data: given a source instance I of a

Composition of Mappings Given by Embedded Dependencies

Authors: 
Bernstein, P.A.; Melnik, S.; Nash, A.
Year: 
2005
Venue: 
PODS 2005

Composition of mappings between schemas is essential to support
schema evolution, data exchange, data integration, and other data
management tasks. In many applications, mappings are given by
embedded dependencies. In this paper, we study the issues involved
in composing such mappings.
Our algorithms and results extend those of Fagin et al. [8] who
studied composition of mappings given by several kinds of constraints.
In particular, they proved that full source-to-target tuplegenerating
dependencies (tgds) are closed under composition, but

Incremental Schema Matching

Authors: 
Bernstein, P.A.; Melnik, S.; Churchill, J.E.
Year: 
2006
Venue: 
Proc. VLDB06 (Demo paper)

The goal of schema matching is to identify correspondences between the elements of two schemas.
Most schema matching systems calculate and display the entire set of correspondences in a single
shot. Invariably, the result presented to the engineer includes many false positives, especially for

Implementing Mapping Composition

Authors: 
Bernstein, P.A.; Green, T.J.; Melnik, S.; Nash, A.
Year: 
2006
Venue: 
Prov. VLDB06

Mapping composition is a fundamental operation in metadata
driven applications. Given a mapping over schemas S1 and S2 and
a mapping over schemas S2 and S3, the composition problem is
to compute an equivalent mapping over S1 and S3. We describe
a new composition algorithm that targets practical applications. It
incorporates view unfolding. It eliminates as many S2 symbols as
possible, even if not all can be eliminated. It covers constraints
expressed using arbitrary monotone relational operators and, to a
lesser extent, non-monotone operators. And it introduces the new

Developing Metadata-Intensive Applications with Rondo

Authors: 
Melnik, Sergey; Rahm, Erhard; Bernstein, Philip A.
Year: 
2003
Venue: 
Journal of Web Semantics, 2003

The future of the Semantic Web depends on whether or not we succeed to integrate reliably thousands of online applications, services, and databases. These systems are tied together using mediators, mappings, database views, and transformation scripts. Model-management aims at reducing the amount of programming needed for the development of such integrated applications. We present a first complete prototype of a generic model-management system, in which high-level operators are used to manipulate models and mappings between models.

Generic Schema Matching With Cupid

Authors: 
Madhavan, J.; Bernstein, P. A.; Rahm, E.
Year: 
2001
Venue: 
VLDB, 2001

Schema matching is a critical step in many applications, such as XML message mapping, data warehouse loading, and schema integration. In this paper, we investigate algorithms for generic schema matching, outside of any particular data model or application. We first present a taxonomy for past solutions, showing that a rich range of techniques is available. We then propose a new algorithm, Cupid, that discovers mappings between schema elements based on their names, data types, constraints, and schema structure, using a broader set of techniques than past approaches.

Is Generic Metadata Management Feasible?

Authors: 
Bernstein, Philip A.
Year: 
2000
Venue: 
Proc. VLDB, Panel, 2000

ion of operations on models and mappings  something much higher level than navigating object structures. Some candidate operators are: x Match – automatically create a mapping between two models. x Merge – merge two models into a third, or merge one model into another based on a mapping. x Compose – return the composition of two mappings (if map

Merging Models Based on Given Correspondences

Authors: 
Bernstein, Philip A.; Pottinger, Rachel A.
Year: 
2003
Venue: 
29th VLDB Conference, 2003

A model is a formal description of a complex application artifact, such as a database schema, an application interface, a UML model, an ontology, or a message format. The problem of merging such models lies at the core of many meta data applications, such as view integration, mediated schema creation for data integration, and ontology merging. This paper examines the problem of merging two models given correspondences between them. It presents requirements for conducting a merge and a specific algorithm that subsumes previous work.

Representing and Reasoning about Mappings between Domain Models

Authors: 
Madhavan, J.; Bernstein, P.; Domingos, P.; Halevy, A.
Year: 
2002
Venue: 
AAAI, 2002

Mappings between disparate models are fundamental to any
application that requires interoperability between heterogeneous
data and applications. Generating mappings is a laborintensive
and error prone task. To build a system that helps
users generate mappings, we need an explicit representation
of mappings. This representation needs to have well-defined
semantics to enable reasoning and comparison between mappings.
This paper first presents a powerful framework for
defining languages for specifying mappings and their associated
semantics. We examine the use of mappings and identify

Instance-based Schema Matching for Web Databases by Domain-specific Query Probing

Authors: 
Wang, J.; Wen, J.; Lochovsky, F.; Ma, W.
Year: 
2004
Venue: 
VLDB, 2004

In a Web database that dynamically provides information in response to user queries, two distinct schemas, interface schema (the schema users can query) and result schema (the schema users can browse), are presented to users. Each partially reflects the actual schema of the Web database. Most previous work only studied the problem of schema matching across query interfaces of Web databases. In this paper, we propose a novel schema model that distinguishes the interface and the result schema of a Web database in a specific domain.

Supporting Executable Mappings in Model Management

Authors: 
Melnik, S.; Bernstein, P.; Halevy, A.; Rahm, E.
Year: 
2005
Venue: 
SIGMOD, 2005

Model management is an approach to simplify the programming
of metadata-intensive applications. It offers developers powerful
operators, such as Compose, Diff, and Merge, that are applied to
models, such as database schemas or interface specifications, and
to mappings between models. Prior model management solutions
focused on a simple class of mappings that do not have executable
semantics. Yet many metadata applications require that mappings
be executable, expressed in SQL, XSLT, or other data transformation
languages.
In this paper, we develop a semantics for model-management

Visualization of Mappings Between Schemas

Authors: 
Robertson, G. G.; Czerwinski, M. P.; Churchill, J. E.
Year: 
2005
Venue: 
CHI, 2005

Adapting a Generic Match Algorithm to Align Ontologies of Human Anatomy

Authors: 
Mork, P.; Bernstein, P.
Year: 
2004
Venue: 
ICDE, 2004

The difficulty inherent in schema matching has led
to the development of several generic match algorithms.
This paper describes how we adapted general
approaches to the specific task of aligning two ontologies
of human anatomy, the Foundational Model of
Anatomy and the GALEN Common Reference Model.
Our approach consists of three phases: lexical, structural
and hierarchical, which leverage different aspects
of the ontologies as they are represented in a
generic meta-model. Lexical matching identifies concepts
with similar names. Structural matching identifies

ModelGen: Model Independent Schema Translation

Authors: 
Atzeni, P.; Cappellari, P.; Bernstein, P.
Year: 
2005
Venue: 
ICDE, 2005

Corpus-based Schema Matching

Authors: 
Madhavan, J.; Bernstein, P.; Doan, A.; Halevy, A.
Year: 
2005
Venue: 
ICDE, 2005

Model Management: First Steps and Beyond

Authors: 
Melnik, S.
Year: 
2005
Venue: 
BTW 2005: 455-464

Most information systems rely on meta data artifacts, such as database schemas, interface specifications, or view definitions, to store, transform, validate, and exchange information. Applications that produce and manipulate these meta data artifacts are complex and hard to build. The goal of model management research is to develop a set of powerful high-level operators that simplify the programming of such applications, and increase the productivity of developers by an order of magnitude.

Rondo: A Programming Platform for Generic Model Management

Authors: 
Melnik, S.; Rahm, E.; Bernstein, P.A.
Year: 
2003
Venue: 
Proc. SIGMOD 2003, pp. 193-204

Model management aims at reducing the amount of programming needed for the development of metadata-intensive applications. We present a first complete prototype of a generic modelmanagement system, in which high-level operators are used to manipulate models and mappings between models. We define the key conceptual structures: models, morphisms, and selectors, and describe their use and implementation. We specify the semantics of the known model-management operators applied to these structures, suggest new ones, and develop new algorithms for implementing the individual operators.

Data Warehouse Scenarios for Model Management

Authors: 
Bernstein, P.A.; Rahm, E.
Year: 
2000
Venue: 
Proc. 19. Intl. Conf. on Conceptual Modeling (ER), LNCS, Springer-Verlag, Oct. 2000

Model management is a framework for supporting meta-data related applications where models and mappings are manipulated as first class objects using operations such as Match, Merge, ApplyFunction, and Compose. To demonstrate the approach, we show how to use model management in two scenarios related to loading data warehouses. The case study illustrates the value of model management as a methodology for approaching meta-data related problems. It also helps clarify the required semantics of key operations.

Applying Model Management to Classical Meta Data Problems

Authors: 
Bernstein, P.A.
Year: 
2003
Venue: 
Proc. CIDR 2003, pp. 209-220

Model management is a new approach to meta data management that offers a higher level programming interface than current techniques. The main abstractions are models (e.g., schemas, interface definitions) and mappings between models. It treats these abstractions as bulk objects and offers such operators as Match, Merge, Diff, Compose, Apply, and ModelGen. This paper extends earlier treatments of these operators and applies them to three classical meta data management problems: schema integration, schema evolution, and round-trip engineering.

Syndicate content