构件运算的完整性证明及性质

当前对软件构件的描述均采用图形加文本的方式或形式化描述语言,这些描述对构件的动态行为、互操作和演化特征方面的描述明显不足,无法系统地科学地描述软件演化。软件演化是一个复杂的过程,这种复杂性决定了对软件演化的研究应从软件体系结构这一宏观层面入手。针对该问题,文章引入用代数理论对构件的属性和行为特征进行抽象而提出的用于描述体系结构的构件调用运算、协作运算和条件运算的新方法。该方法能够描述任意软件系统的体系结构和支持软件演化。在此基础上证明了构件运算系统是一个完整的代数系统,能够描述任意软件系统的体系结构,并探讨了构件运算的相关性质。     

Including scalars in a programming language based on the relationalalgebra

Scalars, arrays, and records, together with associated operations and syntax, have been introduced as special cases of relations into the relational programming system, relix. This permits all of these data types, as well as relations, to be stored persistently. The requirement in most languages that array elements and record fields can be assigned to leads in this case to the general implementation of QT-selectors as l-expressions, with, in particular, systematic interpretations of assignment to projections and selections of relations. The authors discuss the principles and the implementation of this extension to the relational algebra. They take advantage of the very specialized syntax of array access to build a tuned access method, using B-trees and Z-order. The performance results show the advantage of this implementation over the slower implementation required for general QT-selectors     

Decomposition of select expressions

A select operation that is part of an expression applying to a relational database is decomposed into one or more independent select operations for the purpose of optimising the relational expression. The select expression is treated as a logical expression. From the canonical form of this expression an optimal conjunctive form is obtained which can be decomposed into separate select operations. These separate selects can then be moved to the most effective place within the relational expression. The method also eliminates redundancy in the original expression. A prototype has been used in developing the optimisation method; from this prototype an implementation for use in an actual system has been derived.     

Using UML to model relational database operations

The Unified Modeling Language (UML) is being used as the de-facto standard in the software industry. With the adoption of UML 2.0, the new enhancements allow this version to describe many of the elements found in today's software technology as well as Model Driven Architecture and Service-Oriented Architecture. Although the Object Management Group (OMG) has released several UML Profiles to tailor the language to specific areas, relational database modeling is not fully addressed in these profiles. Many existing software applications involve complex application layer implemented in object-oriented programming languages and at the same time use relational database systems as the back-end data store. Modeling the whole system in a consistent manner will help developers and end users better understand the application. In this work we show how to model relational database operations using UML. Atomic database operations are modeled based on our framework and are used as building blocks to model more complex database operations.     

一个开放可扩展的SDAI实现系统

STEP标准数据存取界面－SDAI为应用程序提供了独立于数据存储的STEP数据访问界面，SDAI允许访问不同的数据存储系统，有不同的实现语言联编方式，如果对每一种实用语言和数据存储系统单独实现SDAI，其工作量将是巨大的，该文选择系数据库作为SDAI数据存储系统，C语言作为实现语言，实现系统独立于不同的关系数据库系统，并且为不同语言的联编提供了一个统一的开发平台，提高了系统的开放性和可扩展性，为STEP在企业信息集成中的应用提供了核心操作，STEP建模语言EXPRESS，关系数据库，SDAI实现语言在模式表示上的不匹配是系统实现要解决的主要问题，该文从数据字典，STEP数据的字储与访问等方面阐明了系统实现时没模式之间的匹配过程。     

Mapping Relational Databases to the Semantic Web with Original Meaning

Most of nowadays Web content is stored in relational databases. It is important to develop ways for representation of this information in the Semantic Web to allow software agents to process it intelligently. The paper presents an approach to translation of data, schema and the most important constraints from relational databases into the Semantic Web without any extensions to the Semantic Web languages.     

Updating extended possibility‐based fuzzy relational databases

Two kinds of fuzziness in attribute values of the fuzzy relational databases can be distinguished: one is that attribute values are possibility distributions and the other is that there are resemblance relations in attribute domains. The fuzzy relational databases containing these two kinds of fuzziness simultaneously are called extended possibility‐based fuzzy relational databases. In this article, we focus on such fuzzy relational databases and investigate three update operations for the fuzzy relational databases, which are Insertion, Deletion, and Modification, respectively. We develop the strategies and implementation algorithms of these operations. © 2007 Wiley Periodicals, Inc. Int J Int Syst 22: 237–258, 2007.     

A relational database machine with large semiconductor disk and hardware relational algebra processor

This paper describes the basic concepts, design and implementation decisions, standpoints and significance of the database machine Delta in the scope of Japan’s Fifth Generation Computer Project. Delta is planned to be operational in 1985 for researchers’ use as a backend database machine for logic programming software development. Delta is basically a relational database machine system. It combines hardware facilities for efficient relational database operations, which are typically represented by relational algebra, and software which deals with hardware control and actual database management requirements. Notable features include attribute-based internal schema in accordance with the characteristics found in the relation access from logic programming environment. This is also useful for the hardware relational algebra manipulation algorithm based on merge-sorting of attributes by hardware and a large capacity Semiconductor Disk for fast access to databases. Various implementation decisions of database management requirements are made in this novel system configuration, which will be meaningful to give an example for constructing a hardware and software combination of a relational database machine. Delta is in the stage between detailed design and implementation.     

Extending a multi-set relational algebra to a parallel environment

Parallel database systems will very probably be the future for high-performance data-intensive applications. In the past decade, many parallel database systems have been developed, together with many languages and approaches to specify operations in these systems. A common background is still missing, however. This paper proposes an extended relational algebra for this purpose, based on the well-known standard relational algebra. The extended algebra provides both complete database manipulation language features, and data distribution and process allocation primitives to describe parallelism. It is defined in terms of multi-sets of tuples to allow handling of duplicates and to obtain a close connection to the world of high-performance data processing. Due to its algebraic nature, the language is well suited for optimization and parallelization through expression rewriting. The proposed language can be used as a database manipulation language on its own, as has been done in the PRISMA parallel database project, or as a formal basis for other languages, like SQL.Recommended by: Patrick Valduriez     

Constraint query algebras

Constraint query languages are natural extensions of relational database query languages. A framework for their declarative specification (constraint calculi) and efficient implementation (low data complexity and secondary storage indexing) was presented in Kanellakis et al., 1995. Constraint query algebras form a procedural language layer between high-level declarative calculi and low-level indexing methods. Just like the relational algebra, this intermediate layer can be very useful for program optimization. In this paper, we study properties of constraint query algebras, which we present through three concrete examples. The dense order constraint algebra illustrates how the appropriate canonical form can simplify expensive operations, such as projection, and facilitate interaction with updates. The monotone two-variable linear constraint algebra illustrates the concept of strongly polynomial operations. Finally, the lazy evaluation of (non)linear constraint algebras illustrates how large numbers of (non)linear constraints could be implemented with only a small amount of costly symbolic processing.Paris C. Kanellakis, one of the authors of this paper, died in a tragic accident shortly after the completion of the first draft. We thank all the reviewers, whose comments were invaluable in helping us complete the work. We also thank Raghu Ramakrishnan for making a last-minute review of the final draft. Research supported by ONR Contracts N00014-94-1-1153 and N00014-91-J-4052, ARPA Order 8225, and by NSF Grant IRI-9509933.     

From types to type requirements: genericity for model-driven engineering

Model-driven engineering (MDE) is a software engineering paradigm that proposes an active use of models during the development process. This paradigm is inherently type-centric, in the sense that models and their manipulation are defined over the types of specific meta-models. This fact hinders the reuse of existing MDE artefacts with other meta-models in new contexts, even if all these meta-models share common characteristics. To increase the reuse opportunities of MDE artefacts, we propose a paradigm shift from type-centric to requirement-centric specifications by bringing genericity into models, meta-models and model management operations. For this purpose, we introduce so-called concepts gathering structural and behavioural requirements for models and meta-models. In this way, model management operations are defined over concepts, enabling the application of the operations to any meta-model satisfying the requirements imposed by the concept. Model templates rely on concepts to define suitable interfaces, hence enabling the definition of reusable model components. Finally, similar to mixin layers, templates can be defined at the meta-model level as well, to define languages in a modular way, as well as layers of functionality to be plugged-in into other meta-models. These ideas have been implemented in MetaDepth, a multi-level meta-modelling tool that integrates action languages from the Epsilon family for model management and code generation.     

Temporal relational data model

This paper incorporates a temporal dimension to nested relations. It combines research in temporal databases and nested relations for managing the temporal data in nontraditional database applications. A temporal data value is represented as a temporal atom; a temporal atom consists of two parts: a temporal set and a value. The temporal atom asserts that the value is valid over the time duration represented by its temporal set. The data model allows relations with arbitrary levels of nesting and can represent the histories of objects and their relationships. Temporal relational algebra and calculus languages are formulated and their equivalence is proved. Temporal relational algebra includes operations to manipulate temporal data and to restructure nested temporal relations. Additionally, we define operations to generate a power set of a relation, a set membership test, and a set inclusion test, which are all derived from the other operations of temporal relational algebra. To obtain a concise representation of temporal data (temporal reduction), collapsed versions of the set-theoretic operations are defined. Procedures to express collapsed operations by the regular operations of temporal relational algebra are included. The paper also develops procedures to completely flatten a nested temporal relation into an equivalent 1 NF relation and back to its original form, thus providing a basis for the semantics of the collapsed operations by the traditional operations on 1 NF relations     

A case study in mapping conceptual designs to object‐relational schemas

The recent emergence of object‐relational technology into the commercial database market has caused new challenges for the implementation of conceptual database designs. This paper presents our experience with using the Oracle 8 object‐relational data model in the implementation of an engineering application described using the EXPRESS conceptual modeling language. EXPRESS is part of the engineering community's Standard for the Exchange of Product Data and can be characterized as a structurally object‐oriented modeling language, supporting the notion of entities, entity hierarchies, complex constraints on entity hierarchies, relationships and inverse relationships between entities, and user‐defined types. As a result, EXPRESS provides an excellent framework for studying the mapping of conceptual modeling concepts into an object‐relational model. In this paper, we describe the way in which the features of EXPRESS can be mapped into object‐relational features such as object tables, object references, and nested tables. We also describe the manner in which features such as member functions on object types, triggers, and stored procedures can be used to support the implementation of constraints associated with a conceptual schema. Although the mappings presented are specific to EXPRESS and Oracle 8, the mappings are generalizable to conceptual modeling languages and object‐relational models with similar features. Our work defines how traditional mapping concepts must be revised in order to make adequate use of the features now found in object‐relational models. As part of this paper, we also compare our mapping approach using Oracle 8 to mapping issues for the PostgreSQL object‐relational model and the Objectivity/DB object‐oriented data model. Copyright © 2000 John Wiley & Sons, Ltd.     

PIT: A macro-implemented implementation language

An implementation technique called PIT, for pseudo instructional technique, is described which utilizes the macro capabilities of most macro assemblers. A low level machine architecture is described via a set of macros that include some ‘high level’ features. Since the macros manipulate computer words, and refer to actual registers, their implementation in a system is relatively efficient, but since they do not reflect any one particular hardware design, they can be implemented by almost any macro assembler. Tests are built into the macros so that a PIT program will run without change on any machine that has defined these macros This technique should provide an alternative to using higher level languages as implementation languages if the object code produced by those compilers is deemed too slow (or too large) for the application that is being programmed.     

Hierarchical development of programming languages

The experience in designing large software systems shows that even the definitions of a programming language can be seen as the application of specific implementation and formalization techniques rather than as the result of a «designing art». In this context, a formalism is proposed here as a tool for defining conventional high level programming languages. The formalism is an algebraic model supporting the definition of representational entities such as types. A Type is a set of data and operations on them. An isomorphism between language components and types realizes an isomorphism between the language and its specification on the model. Then, the definition of a language can be performed by stepwise definitions of the types representing the language components. So the model is also a language development tool. Stepwise definition methodologies are also investigated and two are the proposed ones: the horizontal, methodology and the vertical methodology. In particular, the vertical methodology defines languages by the development of a hierarchy of abstraction levels, each corresponding to one class of languages: The last class only contains the language being defined.     

OO代数——一个面向对象的数据库的基本查询模型

本文提出了一个面向对象的数据库系统的基本查询模型－ＯＯ代数，它具有关系代数相似的形式，具有封闭性和远比关系代数强得多的表达能力。文中首先给出了面向对象的数据库系统的数据结构的一种形式化描述－ＯＳＧ，然后ＯＯ代数的五种基本运算：并、差、类间连接、类内选择及广义投影被一一定义，并说明了用关系代数实现这五种运算的方法。     

Name analysis for modern languages: a general solution

Classical strategies for matching identifier uses with declarations cannot handle the complexities of modern languages: arbitrarily qualified superclass names, cyclic dependence among lookup operations, and contextual access constraints. We have developed a language‐independent algorithm and supporting data structure that overcome these problems. A well‐defined interface allows introduction of arbitrary code to enforce language‐specific constraints within the basic lookup operations. This paper explains the limitations of the classical strategies, presents the concepts on which our approach is based, and showcases an implementation based on attribute grammars. We explore the major issues through a series of examples and show how one can deal with those issues in a general framework. Many of the issues are specific to a particular language, and in those cases, we explain the solutions that our general interface supports. Although attribute grammars simplify the task of incorporating the model into a compiler, the model itself is completely independent of attribute grammars. We validated our model by using an implementation to process programs in several representative languages. In particular, we mechanically compared the results produced by that implementation with those produced by the Java SE 8 compiler on complete Java programs that are in general use. Performance data obtained during this processing show that our implementation is efficient. Copyright © 2017 John Wiley & Sons, Ltd.